input
stringlengths
2.65k
237k
output
stringclasses
1 value
from datetime import datetime #from sklearn import metrics from theano import tensor as T import cPickle import numpy import os import sys import theano import time from collections import defaultdict import subprocess import pandas as pd from tqdm import tqdm import nn_layers import sgd_trainer import warnings warnings.filterwarnings("ignore") # TODO remove ### THEANO DEBUG FLAGS # theano.config.optimizer = 'fast_compile' # theano.config.exception_verbosity = 'high' def main(): # ZEROUT_DUMMY_WORD = False ZEROUT_DUMMY_WORD = True ## Load data # mode = 'TRAIN-ALL' mode = 'train' if len(sys.argv) > 1: mode = sys.argv[1] data_dir = sys.argv[2] '''if mode == 'cui_train': data_dir = mode mode = 'TRAIN' else: data_dir = mode ''' if not mode in ['TRAIN', 'TRAIN-ALL']: print "ERROR! The two possible training settings are: ['TRAIN', 'TRAIN-ALL']" sys.exit(1) print "Running training in the {} setting".format(mode) if mode in ['TRAIN-ALL']: q_train = numpy.load(os.path.join(data_dir, 'train-all.questions.npy')) a_train = numpy.load(os.path.join(data_dir, 'train-all.answers.npy')) q_overlap_train = numpy.load(os.path.join(data_dir, 'train-all.q_overlap_indices.npy')) a_overlap_train = numpy.load(os.path.join(data_dir, 'train-all.a_overlap_indices.npy')) y_train = numpy.load(os.path.join(data_dir, 'train-all.labels.npy')) else: q_train = numpy.load(os.path.join(data_dir, 'train.questions.npy')) a_train = numpy.load(os.path.join(data_dir, 'train.answers.npy')) q_overlap_train = numpy.load(os.path.join(data_dir, 'train.q_overlap_indices.npy')) a_overlap_train = numpy.load(os.path.join(data_dir, 'train.a_overlap_indices.npy')) y_train = numpy.load(os.path.join(data_dir, 'train.labels.npy')) q_dev = numpy.load(os.path.join(data_dir, 'dev.questions.npy')) a_dev = numpy.load(os.path.join(data_dir, 'dev.answers.npy')) q_overlap_dev = numpy.load(os.path.join(data_dir, 'dev.q_overlap_indices.npy')) a_overlap_dev = numpy.load(os.path.join(data_dir, 'dev.a_overlap_indices.npy')) y_dev = numpy.load(os.path.join(data_dir, 'dev.labels.npy')) qids_dev = numpy.load(os.path.join(data_dir, 'dev.qids.npy')) q_test = numpy.load(os.path.join(data_dir, 'test.questions.npy')) a_test = numpy.load(os.path.join(data_dir, 'test.answers.npy')) q_overlap_test = numpy.load(os.path.join(data_dir, 'test.q_overlap_indices.npy')) a_overlap_test = numpy.load(os.path.join(data_dir, 'test.a_overlap_indices.npy')) y_test = numpy.load(os.path.join(data_dir, 'test.labels.npy')) qids_test = numpy.load(os.path.join(data_dir, 'test.qids.npy')) # x_train = numpy.load(os.path.join(data_dir, 'train.overlap_feats.npy')) # x_dev = numpy.load(os.path.join(data_dir, 'dev.overlap_feats.npy')) # x_test = numpy.load(os.path.join(data_dir, 'test.overlap_feats.npy')) # feats_ndim = x_train.shape[1] # from sklearn.preprocessing import StandardScaler # scaler = StandardScaler() # print "Scaling overlap features" # x_train = scaler.fit_transform(x_train) # x_dev = scaler.transform(x_dev) # x_test = scaler.transform(x_test) print 'y_train', numpy.unique(y_train, return_counts=True) print 'y_dev', numpy.unique(y_dev, return_counts=True) print 'y_test', numpy.unique(y_test, return_counts=True) print 'q_train', q_train.shape print 'q_dev', q_dev.shape print 'q_test', q_test.shape print 'a_train', a_train.shape print 'a_dev', a_dev.shape print 'a_test', a_test.shape ## Get the word embeddings from the nnet trained on SemEval # ndim = 40 # nnet_outdir = 'exp/ndim=60;batch=100;max_norm=0;learning_rate=0.1;2014-12-02-15:53:14' # nnet_fname = os.path.join(nnet_outdir, 'nnet.dat') # params_fname = os.path.join(nnet_outdir, 'best_dev_params.epoch=00;batch=14640;dev_f1=83.12;test_acc=85.00.dat') # train_nnet, test_nnet = nn_layers.load_nnet(nnet_fname, params_fname) numpy_rng = numpy.random.RandomState(123) q_max_sent_size = q_train.shape[1] a_max_sent_size = a_train.shape[1] # print 'max', numpy.max(a_train) # print 'min', numpy.min(a_train) ndim = 5 print "Generating random vocabulary for word overlap indicator features with dim:", ndim dummy_word_id = numpy.max(a_overlap_train) # vocab_emb_overlap = numpy_rng.uniform(-0.25, 0.25, size=(dummy_word_id+1, ndim)) print "Gaussian" vocab_emb_overlap = numpy_rng.randn(dummy_word_id+1, ndim) * 0.25 # vocab_emb_overlap = numpy_rng.randn(dummy_word_id+1, ndim) * 0.05 # vocab_emb_overlap = numpy_rng.uniform(-0.25, 0.25, size=(dummy_word_id+1, ndim)) vocab_emb_overlap[-1] = 0 # Load word2vec embeddings fname = os.path.join(data_dir, 'emb_vec_50.bin.npy') print "Loading word embeddings from", fname vocab_emb = numpy.load(fname) ndim = vocab_emb.shape[1] dummpy_word_idx = numpy.max(a_train) print "Word embedding matrix size:", vocab_emb.shape x = T.dmatrix('x') x_q = T.lmatrix('q') x_q_overlap = T.lmatrix('q_overlap') x_a = T.lmatrix('a') x_a_overlap = T.lmatrix('a_overlap') y = T.ivector('y') ####### n_outs = 2 n_epochs = 25 batch_size = 50 learning_rate = 0.1 max_norm = 0 print 'batch_size', batch_size print 'n_epochs', n_epochs print 'learning_rate', learning_rate print 'max_norm', max_norm ## 1st conv layer. ndim = vocab_emb.shape[1] + vocab_emb_overlap.shape[1] ### Nonlinearity type # activation = nn_layers.relu_f activation = T.tanh dropout_rate = 0.5 nkernels = 50 q_k_max = 1 a_k_max = 1 # filter_widths = [3,4,5] q_filter_widths = [3] a_filter_widths = [3] ###### QUESTION ###### lookup_table_words = nn_layers.LookupTableFastStatic(W=vocab_emb, pad=max(q_filter_widths)-1) lookup_table_overlap = nn_layers.LookupTableFast(W=vocab_emb_overlap, pad=max(q_filter_widths)-1) lookup_table = nn_layers.ParallelLookupTable(layers=[lookup_table_words, lookup_table_overlap]) num_input_channels = 1 input_shape = (batch_size, num_input_channels, q_max_sent_size + 2*(max(q_filter_widths)-1), ndim) conv_layers = [] for filter_width in q_filter_widths: filter_shape = (nkernels, num_input_channels, filter_width, ndim) conv = nn_layers.Conv2dLayer(rng=numpy_rng, filter_shape=filter_shape, input_shape=input_shape) non_linearity = nn_layers.NonLinearityLayer(b_size=filter_shape[0], activation=activation) pooling = nn_layers.KMaxPoolLayer(k_max=q_k_max) conv2dNonLinearMaxPool = nn_layers.FeedForwardNet(layers=[conv, non_linearity, pooling]) conv_layers.append(conv2dNonLinearMaxPool) join_layer = nn_layers.ParallelLayer(layers=conv_layers) flatten_layer = nn_layers.FlattenLayer() nnet_q = nn_layers.FeedForwardNet(layers=[ lookup_table, join_layer, flatten_layer, ]) nnet_q.set_input((x_q, x_q_overlap)) ###### ###### ANSWER ###### lookup_table_words = nn_layers.LookupTableFastStatic(W=vocab_emb, pad=max(q_filter_widths)-1) lookup_table_overlap = nn_layers.LookupTableFast(W=vocab_emb_overlap, pad=max(q_filter_widths)-1) lookup_table = nn_layers.ParallelLookupTable(layers=[lookup_table_words, lookup_table_overlap]) # num_input_channels = len(lookup_table.layers) input_shape = (batch_size, num_input_channels, a_max_sent_size + 2*(max(a_filter_widths)-1), ndim) conv_layers = [] for filter_width in a_filter_widths: filter_shape = (nkernels, num_input_channels, filter_width, ndim) conv = nn_layers.Conv2dLayer(rng=numpy_rng, filter_shape=filter_shape, input_shape=input_shape) non_linearity = nn_layers.NonLinearityLayer(b_size=filter_shape[0], activation=activation) pooling = nn_layers.KMaxPoolLayer(k_max=a_k_max) conv2dNonLinearMaxPool = nn_layers.FeedForwardNet(layers=[conv, non_linearity, pooling]) conv_layers.append(conv2dNonLinearMaxPool) join_layer = nn_layers.ParallelLayer(layers=conv_layers) flatten_layer = nn_layers.FlattenLayer() nnet_a = nn_layers.FeedForwardNet(layers=[ lookup_table, join_layer, flatten_layer, ]) nnet_a.set_input((x_a, x_a_overlap)) ####### # print 'nnet_q.output', nnet_q.output.ndim q_logistic_n_in = nkernels * len(q_filter_widths) * q_k_max a_logistic_n_in = nkernels * len(a_filter_widths) * a_k_max # dropout_q = nn_layers.FastDropoutLayer(rng=numpy_rng) # dropout_a = nn_layers.FastDropoutLayer(rng=numpy_rng) # dropout_q.set_input(nnet_q.output) # dropout_a.set_input(nnet_a.output) # feats_nout = 10 # x_hidden_layer = nn_layers.LinearLayer(numpy_rng, n_in=feats_ndim, n_out=feats_nout, activation=activation) # x_hidden_layer.set_input(x) # feats_nout = feats_ndim ### Dropout # classifier = nn_layers.PairwiseLogisticWithFeatsRegression(q_in=logistic_n_in, # a_in=logistic_n_in, # n_in=feats_nout, # n_out=n_outs) # # classifier.set_input((dropout_q.output, dropout_a.output, x_hidden_layer.output)) # classifier.set_input((dropout_q.output, dropout_a.output, x)) # # train_nnet = nn_layers.FeedForwardNet(layers=[nnet_q, nnet_a, x_hidden_layer, dropout_q, dropout_a, classifier], # train_nnet = nn_layers.FeedForwardNet(layers=[nnet_q, nnet_a, dropout_q, dropout_a, classifier], # name="Training nnet") # test_classifier = nn_layers.PairwiseLogisticWithFeatsRegression(q_in=logistic_n_in, # a_in=logistic_n_in, # n_in=feats_nout, # n_out=n_outs, # W=classifier.W, # W_feats=classifier.W_feats, # b=classifier.b) # # test_classifier.set_input((nnet_q.output, nnet_a.output, x_hidden_layer.output)) # test_classifier.set_input((nnet_q.output, nnet_a.output, x)) # # test_nnet = nn_layers.FeedForwardNet(layers=[nnet_q, nnet_a, x_hidden_layer, test_classifier], # test_nnet = nn_layers.FeedForwardNet(layers=[nnet_q, nnet_a, test_classifier], # name="Test nnet") ######### # pairwise_layer = nn_layers.PairwiseMultiOnlySimWithFeatsLayer(q_in=q_logistic_n_in, pairwise_layer = nn_layers.PairwiseNoFeatsLayer(q_in=q_logistic_n_in, # pairwise_layer = nn_layers.PairwiseWithFeatsLayer(q_in=q_logistic_n_in, # pairwise_layer = nn_layers.PairwiseOnlySimWithFeatsLayer(q_in=q_logistic_n_in, a_in=a_logistic_n_in) pairwise_layer.set_input((nnet_q.output, nnet_a.output)) # n_in = q_logistic_n_in + a_logistic_n_in + feats_ndim + a_logistic_n_in # n_in = q_logistic_n_in + a_logistic_n_in + feats_ndim + 50 # n_in = q_logistic_n_in + a_logistic_n_in + feats_ndim + 1 n_in = q_logistic_n_in + a_logistic_n_in + 1 # n_in = feats_ndim + 1 # n_in = feats_ndim + 50 hidden_layer = nn_layers.LinearLayer(numpy_rng, n_in=n_in, n_out=n_in, activation=activation) hidden_layer.set_input(pairwise_layer.output) classifier = nn_layers.LogisticRegression(n_in=n_in, n_out=n_outs) classifier.set_input(hidden_layer.output) train_nnet = nn_layers.FeedForwardNet(layers=[nnet_q, nnet_a, pairwise_layer, hidden_layer, classifier], # train_nnet = nn_layers.FeedForwardNet(layers=[nnet_q, nnet_a, x_hidden_layer, classifier], name="Training nnet") test_nnet = train_nnet ####### print train_nnet params = train_nnet.params ts = datetime.now().strftime('%Y-%m-%d-%H.%M.%S') nnet_outdir = 'exp.out/ndim={};batch={};max_norm={};learning_rate={};{}'.format(ndim, batch_size, max_norm, learning_rate, ts) if not os.path.exists(nnet_outdir): os.makedirs(nnet_outdir) nnet_fname = os.path.join(nnet_outdir, 'nnet.dat') print "Saving to", nnet_fname cPickle.dump([train_nnet, test_nnet], open(nnet_fname, 'wb'), protocol=cPickle.HIGHEST_PROTOCOL) total_params = sum([numpy.prod(param.shape.eval()) for param in params]) print 'Total params number:', total_params cost = train_nnet.layers[-1].training_cost(y) # y_train_counts = numpy.unique(y_train, return_counts=True)[1].astype(numpy.float32) # weights_data = numpy.sum(y_train_counts) / y_train_counts # weights_data_norm = numpy.linalg.norm(weights_data) # weights_data /= weights_data_norm # print 'weights_data', weights_data # weights = theano.shared(weights_data, borrow=True) # cost = train_nnet.layers[-1].training_cost_weighted(y, weights=weights) predictions = test_nnet.layers[-1].y_pred predictions_prob = test_nnet.layers[-1].p_y_given_x[:,-1] ### L2 regularization # L2_word_emb = 1e-4 # L2_conv1d = 3e-5 # # L2_softmax = 1e-3 # L2_softmax = 1e-4 # print "Regularizing nnet weights" # for w in train_nnet.weights: # L2_reg = 0. # if w.name.startswith('W_emb'): # L2_reg = L2_word_emb # elif w.name.startswith('W_conv1d'): # L2_reg = L2_conv1d # elif w.name.startswith('W_softmax'): # L2_reg = L2_softmax # elif w.name == 'W': # L2_reg = L2_softmax # print w.name, L2_reg # cost += T.sum(w**2) * L2_reg # batch_x = T.dmatrix('batch_x') batch_x_q = T.lmatrix('batch_x_q') batch_x_a = T.lmatrix('batch_x_a') batch_x_q_overlap = T.lmatrix('batch_x_q_overlap') batch_x_a_overlap = T.lmatrix('batch_x_a_overlap') batch_y = T.ivector('batch_y') # updates = sgd_trainer.get_adagrad_updates(cost, params, learning_rate=learning_rate, max_norm=max_norm, _eps=1e-6) updates = sgd_trainer.get_adadelta_updates(cost, params, rho=0.95, eps=1e-6, max_norm=max_norm, word_vec_name='W_emb') inputs_pred = [batch_x_q, batch_x_a, batch_x_q_overlap, batch_x_a_overlap, # batch_x, ] givens_pred = {x_q: batch_x_q, x_a: batch_x_a, x_q_overlap: batch_x_q_overlap, x_a_overlap: batch_x_a_overlap, # x: batch_x } inputs_train = [batch_x_q, batch_x_a, batch_x_q_overlap, batch_x_a_overlap, # batch_x, batch_y, ] givens_train = {x_q: batch_x_q, x_a: batch_x_a, x_q_overlap: batch_x_q_overlap, x_a_overlap: batch_x_a_overlap, # x: batch_x, y: batch_y} train_fn = theano.function(inputs=inputs_train, outputs=cost, updates=updates, givens=givens_train) pred_fn = theano.function(inputs=inputs_pred, outputs=predictions, givens=givens_pred) pred_prob_fn = theano.function(inputs=inputs_pred, outputs=predictions_prob, givens=givens_pred) def predict_batch(batch_iterator): preds = numpy.hstack([pred_fn(batch_x_q, batch_x_a, batch_x_q_overlap, batch_x_a_overlap) for batch_x_q, batch_x_a, batch_x_q_overlap, batch_x_a_overlap, _ in batch_iterator]) return preds[:batch_iterator.n_samples] def predict_prob_batch(batch_iterator): preds = numpy.hstack([pred_prob_fn(batch_x_q, batch_x_a, batch_x_q_overlap, batch_x_a_overlap) for batch_x_q, batch_x_a, batch_x_q_overlap, batch_x_a_overlap, _ in batch_iterator]) return preds[:batch_iterator.n_samples] train_set_iterator = sgd_trainer.MiniBatchIteratorConstantBatchSize(numpy_rng, [q_train, a_train, q_overlap_train, a_overlap_train, y_train], batch_size=batch_size, randomize=True) dev_set_iterator = sgd_trainer.MiniBatchIteratorConstantBatchSize(numpy_rng, [q_dev, a_dev, q_overlap_dev, a_overlap_dev, y_dev], batch_size=batch_size, randomize=False) test_set_iterator = sgd_trainer.MiniBatchIteratorConstantBatchSize(numpy_rng, [q_test, a_test, q_overlap_test, a_overlap_test, y_test], batch_size=batch_size, randomize=False) labels = sorted(numpy.unique(y_test)) print 'labels', labels def map_score(qids, labels, preds): qid2cand = defaultdict(list) for qid, label, pred in zip(qids, labels, preds): qid2cand[qid].append((pred, label)) average_precs = [] for qid, candidates in qid2cand.iteritems(): average_prec = 0 running_correct_count = 0 for i, (score, label) in enumerate(sorted(candidates, reverse=True), 1): if label > 0: running_correct_count += 1 average_prec += float(running_correct_count) / i average_precs.append(average_prec / (running_correct_count + 1e-6)) map_score = sum(average_precs) / len(average_precs) return map_score print "Zero out dummy word:", ZEROUT_DUMMY_WORD if ZEROUT_DUMMY_WORD: W_emb_list = [w for
<filename>sumatra/launch.py """ The launch module handles launching of simulations/analyses as sub-processes, and obtaining information about the platform(s) on which the simulations are run. :copyright: Copyright 2006-2015 by the Sumatra team, see doc/authors.txt :license: BSD 2-clause, see LICENSE for details. """ from __future__ import print_function from __future__ import unicode_literals from builtins import range from builtins import object import platform import socket import subprocess import os from sumatra.programs import Executable, MatlabExecutable from sumatra.dependency_finder.matlab import save_dependencies import warnings from . import tee import logging from sumatra.core import have_internet_connection, component, component_type, get_registered_components logger = logging.getLogger("Sumatra") class PlatformInformation(object): """ A simple container for information about the machine and environment the computations are being performed on/in. """ def __init__(self, **kwargs): for k, v in kwargs.items(): setattr(self, k, v) #platform.mac_ver() #platform.win32_ver() #platform.dist() #platform.libc_ver() # Python compile options? distutils.sys_config? # some numpy information? # numpy.distutils.system_info import get_info # get_info('blas_opt') def check_files_exist(*paths): """ Check that the given paths exist and return the list of paths. parameter_file may be None, in which case it is not included in the list of paths. """ for path in paths: if not os.path.exists(path): raise IOError("%s does not exist." % path) @component_type class LaunchMode(object): """ Base class for launch modes (serial, distributed, batch, ...) """ required_attributes = ("check_files", "generate_command") def __init__(self, working_directory=None, options=None): self.working_directory = working_directory or os.getcwd() self.options = options def __getstate__(self): """ Since each subclass has different attributes, we provide this method as a standard way of obtaining these attributes, for database storage, etc. Returns a dict. """ return {'working_directory': self.working_directory, 'options': self.options} def pre_run(self, executable): """Run tasks before the simulation/analysis proper.""" # e.g. nrnivmodl # this implementation is a temporary hack. "pre_run" should probably be an Executable instance, not a string if hasattr(executable, "pre_run"): p = subprocess.Popen(executable.pre_run, shell=True, stdout=None, stderr=None, close_fds=True, cwd=self.working_directory) result = p.wait() def check_files(self, executable, main_file): """Check that all files exist and are accessible.""" raise NotImplementedError("must be impemented by sub-classes") def generate_command(self, paths): """Return a string containing the command to be launched.""" raise NotImplementedError("must be impemented by sub-classes") def run(self, executable, main_file, arguments, append_label=None): """ Run a computation in a shell, with the given executable, script and arguments. If `append_label` is provided, it is appended to the command line. Return resultcode. """ self.check_files(executable, main_file) cmd = self.generate_command(executable, main_file, arguments) if append_label: cmd += " " + append_label if 'matlab' in executable.name.lower(): ''' we will be executing Matlab and at the same time saving the dependencies in order to avoid opening of Matlab shell two times ''' result, output = save_dependencies(cmd, main_file) else: result, output = tee.system2(cmd, cwd=self.working_directory, stdout=True) # cwd only relevant for local launch, not for MPI, for example self.stdout_stderr = "".join(output) return result def __key(self): state = self.__getstate__() return tuple([self.__class__] + [(k, state[k]) for k in sorted(state.keys())]) def __eq__(self, other): if type(self) == type(other): return self.__key() == other.__key() else: return False def __ne__(self, other): return not self.__eq__(other) def __hash__(self): return hash(self.__key()) def get_platform_information(self): """ Return a list of `PlatformInformation` objects, containing information about the machine(s) and environment(s) the computations are being performed on/in. """ network_name = platform.node() bits, linkage = platform.architecture() if have_internet_connection(): try: ip_addr = socket.gethostbyname(network_name) # any way to control the timeout? except socket.gaierror: # see http://stackoverflow.com/questions/166506/finding-local-ip-addresses-in-python ip_addr = "127.0.0.1" else: ip_addr = "127.0.0.1" return [PlatformInformation(architecture_bits=bits, architecture_linkage=linkage, machine=platform.machine(), network_name=network_name, ip_addr=ip_addr, processor=platform.processor(), release=platform.release(), system_name=platform.system(), version=platform.version())] # maybe add system time? def get_type(self): return self.__class__.__name__ @component class SerialLaunchMode(LaunchMode): """ Enable running serial computations. """ name = "serial" def __str__(self): return "serial" def check_files(self, executable, main_file): if main_file is not None: check_files_exist(executable.path, *main_file.split()) else: check_files_exist(executable.path) def generate_command(self, executable, main_file, arguments): if main_file is not None: if isinstance(executable, MatlabExecutable): #if sys.platform == 'win32' or sys.platform == 'win64': cmd = "%s -nodesktop -r \"%s('%s')\"" % (executable.name, main_file.split('.')[0], arguments) # only for Windows # cmd = "%s -nodesktop -r \"%s('%s')\"" %(executable.name, main_file.split('.')[0], 'in.param') # only for Windows else: cmd = "%s %s %s %s" % (executable.path, executable.options, main_file, arguments) else: if executable.path == executable.name: # temporary hack cmd = "./%s %s %s" % (executable.path, executable.options, arguments) else: cmd = "%s %s %s" % (executable.path, executable.options, arguments) return cmd generate_command.__doc__ = LaunchMode.generate_command.__doc__ @component class DistributedLaunchMode(LaunchMode): """ Enable running distributed computations using MPI. The current implementation is specific to MPICH2, but this will be generalised in future releases. """ name = "distributed" def __init__(self, n=1, mpirun="mpiexec", hosts=[], options=None, pfi_path="/usr/local/bin/pfi.py", working_directory=None): """ `n` - the number of hosts to run on. `mpirun` - the path to the mpirun or mpiexec executable. If a full path is not given, the user's PATH will be searched. `hosts` - a list of host names to run on. **Currently not used.** `options` - extra command line options for mpirun/mpiexec `pfi_path` - the path to the pfi.py script provided with Sumatra, which should be installed on every node and is used to obtain platform information. `working_directory` - directory in which to run on the hosts """ LaunchMode.__init__(self, working_directory, options) class MPI(Executable): name = mpirun default_executable_name = mpirun if os.path.exists(mpirun): # mpirun is a full path mpi_cmd = MPI(path=mpirun) else: mpi_cmd = MPI(path=None) self.mpirun = mpi_cmd.path # should warn if mpirun not found self.hosts = hosts self.n = n self.mpi_info = {} self.pfi_path = pfi_path def __str__(self): return "distributed (n=%d, mpiexec=%s, hosts=%s)" % (self.n, self.mpirun, self.hosts) def check_files(self, executable, main_file): if main_file is not None: check_files_exist(self.mpirun, executable.path, *main_file.split()) else: check_files_exist(self.mpirun, executable.path) def generate_command(self, executable, main_file, arguments): if hasattr(executable, "mpi_options"): mpi_options = executable.mpi_options else: mpi_options = self.options or "" #cmd = "%s -np %d -host %s %s %s %s" % (self.mpirun, # self.n, # ",".join(hosts), # executable.path, # main_file, # parameter_file) cmd = "%s -n %d --wdir %s" % ( # MPICH2-specific - need to generalize self.mpirun, self.n, self.working_directory ) if main_file is not None: cmd += " %s %s %s %s %s" % (executable.path, mpi_options, executable.options, main_file, arguments) else: cmd += " %s %s %s %s" % (executable.path, mpi_options, executable.options, arguments) return cmd generate_command.__doc__ = LaunchMode.generate_command.__doc__ def get_platform_information(self): try: import mpi4py.MPI MPI = mpi4py.MPI except ImportError: MPI = None warnings.warn("mpi4py is not available, so Sumatra is not able to obtain platform information for remote nodes.") platform_information = LaunchMode.get_platform_information() if MPI: import sys comm = MPI.COMM_SELF.Spawn(sys.executable, args=[self.pfi_path], maxprocs=self.n) platform_information = [] for rank in range(self.n): platform_information.append(PlatformInformation(**comm.recv(source=rank, tag=rank).values()[0])) comm.Disconnect() return platform_information get_platform_information.__doc__ = LaunchMode.get_platform_information.__doc__ + """ Requires the script :file:`pfi.py` to be placed on the user's path on each node of the machine. This is currently not useful, as I don't think there is any guarantee that we get the same *n* nodes that the command is run on. Need to look more into this. """ def __getstate__(self): """Return a dict containing the values needed to recreate this instance.""" return {'mpirun': self.mpirun, 'n': self.n, 'hosts': self.hosts, 'pfi_path': self.pfi_path, 'options': self.options, 'working_directory': self.working_directory} @component class SlurmMPILaunchMode(LaunchMode): """ Enable launching MPI computations with SLURM (https://computing.llnl.gov/linux/slurm/) """ name = "slurm-mpi" def __init__(self, n=1, mpirun="mpiexec", working_directory=None, options=None): """ `n` - the number of hosts to run on. `mpirun` - the path to the mpirun or mpiexec executable. If a full path is not given, the user's PATH will be searched. `options` - extra options for SLURM `working_directory` - directory in which to run on the hosts """ LaunchMode.__init__(self, working_directory, options) class MPI(Executable): name = mpirun default_executable_name = mpirun if os.path.exists(mpirun): # mpirun is a full path mpi_cmd = MPI(path=mpirun) else: mpi_cmd = MPI(path=None) self.mpirun = mpi_cmd.path # should warn if mpirun not found assert n > 0 self.n = int(n) def __str__(self): return "slurm-mpi" def check_files(self, executable, main_file): # should really check that files exist on whatever system SLURM sends the job to if main_file is not None: check_files_exist(executable.path, *main_file.split()) else: check_files_exist(executable.path) def generate_command(self, executable, main_file, arguments): if hasattr(executable, "mpi_options"): mpi_options = executable.mpi_options else: mpi_options = "" cmd = "salloc -n %d %s %s --wdir %s" % ( self.n, self.options or "", self.mpirun, self.working_directory ) if main_file is not None: cmd += " %s %s %s %s %s" % (executable.path, mpi_options, executable.options, main_file, arguments) else: cmd += " %s %s %s %s" % (executable.path, mpi_options, executable.options,
slug="not existing" ) } } } ), ( [ collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", ""), ("Assignees", "<EMAIL>"), ("Creators", "<EMAIL>"), ("Title", "Some title"), ("State", "Open") ]) ], { "Assessment": { "row_warnings": { errors.WRONG_VALUE_DEFAULT.format( line=3, column_name="State", value="open", ) } } } ), ( [ collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", ""), ("Title", "New Assessment"), ("Creators", "<EMAIL>"), ("Assignees", "<EMAIL>"), ("Verifiers", "<EMAIL>"), ("Finished Date", "7/3/2015"), ("Verified Date", "5/14/2016"), ]), collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", ""), ("Verified Date", "5/15/2016"), ]) ], { "Assessment": { "row_warnings": { errors.UNMODIFIABLE_COLUMN.format( line=3, column_name="Verified Date" ) } } } ), ) @ddt.unpack def test_assessment_warnings_errors(self, assessment_data, expected_errors): """ Test full assessment import with warnings and errors CSV sheet: https://docs.google.com/spreadsheets/d/1Jg8jum2eQfvR3kZNVYbVKizWIGZXvfqv3yQpo2rIiD8/edit#gid=889865936 """ if len(assessment_data) == 1: if "Audit*" not in assessment_data[0]: audit = factories.AuditFactory() assessment_data[0]["Audit*"] = audit.slug response = self.import_data(*assessment_data) else: audit = factories.AuditFactory() assessment_data[0]["Audit*"] = audit.slug self.import_data(assessment_data[0]) assessment = all_models.Assessment.query.filter_by( title="New Assessment").first() assessment_data[1]["Code*"] = assessment.slug assessment_data[1]["Audit*"] = audit.slug response = self.import_data(assessment_data[1]) self._check_csv_response(response, expected_errors) def test_blank_optional_field(self): """Test warnings while import assessment with blank IssueTracker fields""" audit = factories.AuditFactory() resp = self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", ""), ("Audit*", audit.slug), ("Title*", "ass1"), ("Creators*", "<EMAIL>"), ("Assignees*", "<EMAIL>"), ("Component ID", ""), ("Hotlist ID", ""), ("Priority", ""), ("Severity", ""), ("Issue Type", ""), ("Ticket Title", ""), ("Ticket Tracker Integration", ""), ])) self._check_csv_response(resp, {}) def test_mapping_control_through_snapshot(self): "Test for add mapping control on assessment" with factories.single_commit(): audit = factories.AuditFactory() assessment = factories.AssessmentFactory(audit=audit) factories.RelationshipFactory(source=audit, destination=assessment) control = factories.ControlFactory() revision = all_models.Revision.query.filter( all_models.Revision.resource_id == control.id, all_models.Revision.resource_type == control.__class__.__name__ ).order_by( all_models.Revision.id.desc() ).first() factories.SnapshotFactory( parent=audit, child_id=control.id, child_type=control.__class__.__name__, revision_id=revision.id ) db.session.commit() self.assertFalse(db.session.query( all_models.Relationship.get_related_query( assessment, all_models.Snapshot() ).exists()).first()[0]) self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", assessment.slug), ("map:Control versions", control.slug), ])) self.assertTrue(db.session.query( all_models.Relationship.get_related_query( assessment, all_models.Snapshot() ).exists()).first()[0]) @ddt.data( ("yes", True), ("no", True), ("invalid_data", False), ) @ddt.unpack def test_import_view_only_field(self, value, is_valid): "Test import view only fields" with factories.single_commit(): audit = factories.AuditFactory() assessment = factories.AssessmentFactory(audit=audit) factories.RelationshipFactory(source=audit, destination=assessment) resp = self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", assessment.slug), ("archived", value), ])) row_warnings = [] if not is_valid: row_warnings.append(u"Line 3: Field 'Archived' contains invalid data. " u"The value will be ignored.") self.assertEqual( [{ u'ignored': 0, u'updated': 1, u'block_errors': [], u'name': u'Assessment', u'created': 0, u'deleted': 0, u'deprecated': 0, u'row_warnings': row_warnings, u'rows': 1, u'block_warnings': [], u'row_errors': [], }], resp) @ddt.data((False, "no", 0, 1, []), (True, "yes", 1, 0, [u'Line 3: Importing archived instance is ' u'prohibited. The line will be ignored.'])) @ddt.unpack # pylint: disable=too-many-arguments def test_import_archived_assessment(self, is_archived, value, ignored, updated, row_errors): """Test archived assessment import procedure""" with factories.single_commit(): audit = factories.AuditFactory(archived=is_archived) assessment = factories.AssessmentFactory(audit=audit) factories.RelationshipFactory(source=audit, destination=assessment) resp = self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", assessment.slug), ("archived", value), ("description", "archived assessment description") ])) self.assertEqual([{ u'ignored': ignored, u'updated': updated, u'block_errors': [], u'name': u'Assessment', u'created': 0, u'deleted': 0, u'deprecated': 0, u'row_warnings': [], u'rows': 1, u'block_warnings': [], u'row_errors': row_errors }], resp) def test_create_new_assessment_with_mapped_control(self): "Test for creation assessment with mapped controls" with factories.single_commit(): audit = factories.AuditFactory() control = factories.ControlFactory() revision = all_models.Revision.query.filter( all_models.Revision.resource_id == control.id, all_models.Revision.resource_type == control.__class__.__name__ ).order_by( all_models.Revision.id.desc() ).first() factories.SnapshotFactory( parent=audit, child_id=control.id, child_type=control.__class__.__name__, revision_id=revision.id ) db.session.commit() self.assertFalse(db.session.query( all_models.Relationship.get_related_query( all_models.Assessment(), all_models.Snapshot() ).exists()).first()[0]) response = self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", ""), ("Audit*", audit.slug), ("Assignees*", all_models.Person.query.all()[0].email), ("Creators", all_models.Person.query.all()[0].email), ("Title", "Strange title"), ("map:Control versions", control.slug), ])) self._check_csv_response(response, {}) assessment = all_models.Assessment.query.filter( all_models.Assessment.title == "Strange title" ).first() self.assertTrue(db.session.query(all_models.Relationship.get_related_query( assessment, all_models.Snapshot()).exists()).first()[0] ) def test_create_import_assignee(self): "Test for creation assessment with mapped assignees" name = "test_name" email = "<EMAIL>" with factories.single_commit(): audit = factories.AuditFactory() assignee_id = factories.PersonFactory(name=name, email=email).id self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", ""), ("Audit*", audit.slug), ("Assignees*", email), ("Creators", all_models.Person.query.all()[0].email), ("Title", "Strange title"), ])) assessment = all_models.Assessment.query.filter( all_models.Assessment.title == "Strange title" ).first() self._test_assigned_user(assessment, assignee_id, "Assignees") def test_create_import_creators(self): "Test for creation assessment with mapped creator" name = "test_name" email = "<EMAIL>" with factories.single_commit(): audit = factories.AuditFactory() creator_id = factories.PersonFactory(name=name, email=email).id self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", ""), ("Audit*", audit.slug), ("Assignees*", all_models.Person.query.all()[0].email), ("Creators", email), ("Title", "Strange title"), ])) assessment = all_models.Assessment.query.filter( all_models.Assessment.title == "Strange title" ).first() self._test_assigned_user(assessment, creator_id, "Creators") def test_update_import_creators(self): "Test for creation assessment with mapped creator" slug = "TestAssessment" name = "test_name" email = "<EMAIL>" with factories.single_commit(): assessment = factories.AssessmentFactory(slug=slug) creator_id = factories.PersonFactory(name=name, email=email).id self._test_assigned_user(assessment, None, "Creators") self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", slug), ("Creators", email), ])) assessment = all_models.Assessment.query.filter( all_models.Assessment.slug == slug ).first() self._test_assigned_user(assessment, creator_id, "Creators") def test_update_import_assignee(self): "Test for creation assessment with mapped creator" slug = "TestAssessment" name = "test_name" email = "<EMAIL>" with factories.single_commit(): assessment = factories.AssessmentFactory(slug=slug) assignee_id = factories.PersonFactory(name=name, email=email).id self._test_assigned_user(assessment, None, "Assignees") self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", slug), ("Assignees", email), ])) assessment = all_models.Assessment.query.filter( all_models.Assessment.slug == slug ).first() self._test_assigned_user(assessment, assignee_id, "Assignees") def test_update_import_verifiers(self): """Test import does not delete verifiers if empty value imported""" slug = "TestAssessment" assessment = factories.AssessmentFactory(slug=slug) name = "test_name" email = "<EMAIL>" verifier = factories.PersonFactory(name=name, email=email) verifier_id = verifier.id self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", slug), ("Verifiers", email), ])) assessment = all_models.Assessment.query.filter( all_models.Assessment.slug == slug ).first() self._test_assigned_user(assessment, verifier_id, "Verifiers") self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", slug), ("Verifiers", ""), ])) assessment = all_models.Assessment.query.filter( all_models.Assessment.slug == slug ).first() self._test_assigned_user(assessment, verifier_id, "Verifiers") @ddt.data( ( "Created Date", lambda: datetime.date.today() - datetime.timedelta(7), ), ) @ddt.unpack def test_update_non_changeable_field(self, field, value_creator): """Test importing Assessment's "Created Date" field""" slug = "TestAssessment" with factories.single_commit(): value = value_creator() factories.AssessmentFactory( slug=slug, modified_by=factories.PersonFactory(email="<EMAIL>"), ) data = [{ "object_name": "Assessment", "fields": "all", "filters": { "expression": { "left": "code", "op": {"name": "="}, "right": slug }, } }] before_update = self.export_parsed_csv(data)["Assessment"][0][field] with freezegun.freeze_time("2017-9-10"): self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", slug), (field, value) ])) self.assertEqual(before_update, self.export_parsed_csv(data)["Assessment"][0][field]) @ddt.data( ("Last Updated By", "<EMAIL>"), ) @ddt.unpack def test_exportable_only_updated_by(self, field, value): """Test exportable only "Last Updated By" field""" slug = "TestAssessment" with factories.single_commit(): factories.AssessmentFactory( slug=slug, modified_by=factories.PersonFactory(email="<EMAIL>"), ) data = [{ "object_name": "Assessment", "fields": "all", "filters": { "expression": { "left": "code", "op": {"name": "="}, "right": slug }, } }] before_update = self.export_parsed_csv(data)["Assessment"][0][field] self.assertEqual(before_update, "<EMAIL>") self.import_data(collections.OrderedDict( [ ("object_type", "Assessment"), ("Code*", slug), (field, value) ] )) after_update = self.export_parsed_csv(data)["Assessment"][0][field] self.assertEqual(after_update, "<EMAIL>") def test_import_last_deprecated_date(self): """Last Deprecated Date on assessment should be non editable.""" with factories.single_commit(): with freezegun.freeze_time("2017-01-01"): assessment = factories.AssessmentFactory(status="Deprecated") resp = self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("code", assessment.slug), ("Last Deprecated Date", "02/02/2017"), ])) result = all_models.Assessment.query.get(assessment.id) self.assertEqual(1, len(resp)) self.assertEqual(1, resp[0]["updated"]) self.assertEqual(result.end_date, datetime.date(2017, 1, 1)) @ddt.data(*all_models.Assessment.VALID_STATES) def test_import_set_up_deprecated(self, start_state): """Update assessment from {0} to Deprecated.""" with factories.single_commit(): assessment = factories.AssessmentFactory(status=start_state) resp = self.import_data( collections.OrderedDict([ ("object_type", "Assessment"), ("code", assessment.slug), ("State", all_models.Assessment.DEPRECATED), ])) self.assertEqual(1, len(resp)) self.assertEqual(1, resp[0]["updated"]) self.assertEqual( all_models.Assessment.query.get(assessment.id).status, all_models.Assessment.DEPRECATED) def test_asmnt_cads_update_completed(self): """Test update of assessment without cads.""" with factories.single_commit(): audit = factories.AuditFactory() asmnt = factories.AssessmentFactory(audit=audit) factories.CustomAttributeDefinitionFactory( title="CAD", definition_type="assessment", definition_id=asmnt.id, attribute_type="Text", mandatory=True, ) data = collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", asmnt.slug), ("Audit", audit.slug), ("Title", "Test title"), ("State", "Completed"), ("CAD", "Some value"), ]) response = self.import_data(data) self._check_csv_response(response, {}) def test_import_complete_missing_answers_warnings(self): """Test complete assessment with missing mandatory CAD comments.""" with factories.single_commit(): audit = factories.AuditFactory() asmnt = factories.AssessmentFactory(audit=audit) factories.CustomAttributeDefinitionFactory( title="CAD", definition_type="assessment", definition_id=asmnt.id, attribute_type="Dropdown", multi_choice_options="no,yes", multi_choice_mandatory="0,1" ) data = collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", asmnt.slug), ("Audit", audit.slug), ("Title", "Test title"), ("State", "Completed"), ("CAD", "yes"), ]) expected_response = { "Assessment": { "row_warnings": { errors.NO_REQUIRED_ANSWERS_WARNING.format(line=3), } } } response = self.import_data(data) self._check_csv_response(response, expected_response) def test_import_asmnt_rev_query_count(self): """Test only one revisions insert query should occur while importing.""" with factories.single_commit(): audit = factories.AuditFactory() asmnt = factories.AssessmentFactory(audit=audit) cad_names = ("CAD1", "CAD2", "CAD3") for name in cad_names: factories.CustomAttributeDefinitionFactory( title=name, definition_type="assessment", definition_id=asmnt.id, attribute_type="Text", mandatory=True, ) data = collections.OrderedDict([ ("object_type", "Assessment"), ("Code*", asmnt.slug), ("Audit", audit.slug), ("Title", "Test title"), ("State", "Completed"), ("CAD1", "Some value 1"), ("CAD2", "Some value 2"), ("CAD3", "Some value 3"), ]) with utils.QueryCounter() as counter: response = self.import_data(data) self._check_csv_response(response, {}) rev_insert_queries = [query for query in counter.queries if 'INSERT INTO revisions' in query] self.assertEqual(len(rev_insert_queries), 1) def test_asmt_verified_date_update_from_none(self): """Test that we able to set Verified Date if it is empty""" audit = factories.AuditFactory() assessment = factories.AssessmentFactory(audit=audit) response = self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("Code", assessment.slug), ("Verifiers", "<EMAIL>"), ("Verified Date", "01/22/2019"), ])) self._check_csv_response(response, {}) self.assertEqual( all_models.Assessment.query.get(assessment.id).verified_date, datetime.datetime(2019, 1, 22)) def test_asmt_complete_verified(self): """Test assessment moved to Complete and Verified state""" with factories.single_commit(): audit = factories.AuditFactory() assessment = factories.AssessmentFactory(audit=audit) slug = assessment.slug user = all_models.Person.query.first() assessment.add_person_with_role_name(user, "Verifiers") response = self.import_data(collections.OrderedDict([ ("object_type", "Assessment"), ("Code", slug), ("State", "Completed"), ("Verified Date", "01/22/2019"), ])) self._check_csv_response(response, {}) assmt = all_models.Assessment.query.one() self.assertTrue(assmt.verified) self.assertEqual(assmt.status, "Completed") def test_asmt_verified_date_readonly(self): """Test that Verified Date is readonly""" audit = factories.AuditFactory() date = datetime.datetime(2019, 05, 22) assessment = \ factories.AssessmentFactory(audit=audit, verified_date=date) expected_warnings =
<filename>ate_asc_run.py from __future__ import absolute_import, division, print_function import argparse import logging import os import random import time import numpy as np import torch import torch.nn.functional as F from file_utils import PYTORCH_PRETRAINED_BERT_CACHE from ate_asc_modeling import BertForSequenceLabeling from optimization import BertAdam from tokenization import BertTokenizer from torch.utils.data import (DataLoader, RandomSampler, SequentialSampler, TensorDataset) from torch.utils.data.distributed import DistributedSampler from ate_asc_features import ATEASCProcessor, convert_examples_to_features, get_labels from utils import get_logger, get_aspect_chunks, get_polaity_chunks def warmup_linear(x, warmup=0.002): if x < warmup: return x / warmup return max(0, (1.0 - x) / (1.0 - warmup)) def str2bool(v): if v.lower() in ('yes', 'true', 't', 'y', '1'): return True elif v.lower() in ('no', 'false', 'f', 'n', '0'): return False else: raise argparse.ArgumentTypeError('Unsupported value encountered.') def parse_input_parameter(): global logger parser = argparse.ArgumentParser() ## Required parameters parser.add_argument("--data_dir", default=None, type=str, required=True, help="The input data dir. Should contain the .tsv files (or other data files) for the task.") parser.add_argument("--bert_model", default=None, type=str, required=True, help="Bert pre-trained model selected in the list: bert-base-uncased, bert-large-uncased.") parser.add_argument("--init_model", default=None, type=str, required=False, help="Initial model.") parser.add_argument("--task_name", default="ate_asc", type=str, required=False, help="The name of the task to train.") parser.add_argument("--data_name", default="", type=str, required=False, help="The name of the task to train.") parser.add_argument("--train_file", default=None, type=str, required=False) parser.add_argument("--valid_file", default=None, type=str, required=False) parser.add_argument("--test_file", default=None, type=str, required=False) parser.add_argument("--output_dir", default=None, type=str, required=True, help="The output directory where the model predictions and checkpoints will be written.") ## Other parameters parser.add_argument("--cache_dir", default="", type=str, help="Where do you want to store the pre-trained models downloaded from s3") parser.add_argument("--max_seq_length", default=128, type=int, help="The maximum total input sequence length after WordPiece tokenization. \nSequences longer than this will be truncated, and sequences shorter \nthan this will be padded.") parser.add_argument("--do_train", action='store_true', help="Whether to run training.") parser.add_argument("--do_eval", action='store_true', help="Whether to run eval on the dev set.") parser.add_argument("--do_lower_case", action='store_true', help="Set this flag if you are using an uncased model.") parser.add_argument("--train_batch_size", default=32, type=int, help="Total batch size for training.") parser.add_argument('--gradient_accumulation_steps', type=int, default=1, help="Number of updates steps to accumulate before performing a backward/update pass.") parser.add_argument("--eval_batch_size", default=32, type=int, help="Total batch size for eval.") parser.add_argument("--learning_rate", default=5e-5, type=float, help="The initial learning rate for Adam.") parser.add_argument("--num_train_epochs", default=3, type=int, help="Total number of training epochs to perform.") parser.add_argument("--warmup_proportion", default=0.1, type=float, help="Proportion of training to perform linear learning rate warmup for. E.g., 0.1 = 10%% of training.") parser.add_argument('--num_thread_reader', type=int, default=0, help='') parser.add_argument("--no_cuda", action='store_true', help="Whether not to use CUDA when available") parser.add_argument("--local_rank", type=int, default=-1, help="local_rank for distributed training on gpus") parser.add_argument('--seed', type=int, default=42, help="random seed for initialization") parser.add_argument('--fp16', action='store_true', help="Whether to use 16-bit float precision instead of 32-bit") parser.add_argument('--loss_scale', type=float, default=0, help="Loss scaling to improve fp16 numeric stability. Only used when fp16 set to True.\n0 (default value): dynamic loss scaling.\nPositive power of 2: static loss scaling value.\n") parser.add_argument("--verbose_logging", default=False, action='store_true', help="If true, all of the warnings related to data processing will be printed. A number of warnings are expected for a normal CoQA evaluation.") parser.add_argument('--server_ip', type=str, default='', help="Can be used for distant debugging."); parser.add_argument('--server_port', type=str, default='', help="Can be used for distant debugging.") parser.add_argument("--use_ghl", action='store_true', help="Whether use weighted cross entropy to decoder.") parser.add_argument("--use_vat", action='store_true', help="Whether use vat to encoder.") parser.add_argument("--use_decoder", default=True, type=str2bool, help="Whether use decoder to asc.") parser.add_argument("--num_decoder_layer", default=2, type=int, help="When `use_decoder' is True, set the number of decoder.") parser.add_argument("--decoder_shared_layer", default=3, type=int, help="When `use_decoder' is True, set the number of shared encoder.") args = parser.parse_args() if args.gradient_accumulation_steps < 1: raise ValueError("Invalid gradient_accumulation_steps parameter: {}, should be >= 1".format( args.gradient_accumulation_steps)) if not args.do_train and not args.do_eval: raise ValueError("At least one of `do_train` or `do_eval` must be True.") if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) logger = get_logger(os.path.join(args.output_dir, "log.txt")) logger.info("Effective parameters:") for key in sorted(args.__dict__): logger.info(" {}: {}".format(key, args.__dict__[key])) args.train_batch_size = args.train_batch_size // args.gradient_accumulation_steps task_config = { "use_ghl": args.use_ghl, "use_vat": args.use_vat, "num_decoder_layer": args.num_decoder_layer, "decoder_shared_layer": args.decoder_shared_layer, } return args, task_config def init_device(args): if args.server_ip and args.server_port: # Distant debugging - see https://code.visualstudio.com/docs/python/debugging#_attach-to-a-local-script import ptvsd print("Waiting for debugger attach") ptvsd.enable_attach(address=(args.server_ip, args.server_port), redirect_output=True) ptvsd.wait_for_attach() if args.local_rank == -1 or args.no_cuda: device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu") n_gpu = torch.cuda.device_count() else: torch.cuda.set_device(args.local_rank) device = torch.device("cuda", args.local_rank) n_gpu = 1 # Initializes the distributed backend which will take care of sychronizing nodes/GPUs torch.distributed.init_process_group(backend='nccl') logger.info("device: {} n_gpu: {}, distributed training: {}, 16-bits training: {}".format( device, n_gpu, bool(args.local_rank != -1), args.fp16)) return device, n_gpu def init_model(args, num_tp_labels, task_config, device, n_gpu): if args.init_model: model_state_dict = torch.load(args.init_model, map_location='cpu') if args.num_decoder_layer != 0: layer_num_list = [layer_num for layer_num in range(args.num_decoder_layer)] new_model_state_dict = {} model_state_dict_exsit_keys = model_state_dict.keys() max_bert_layer = max([int(k_str.split(".")[3]) for k_str in model_state_dict_exsit_keys if "bert.encoder.layer" in k_str]) for k_str in model_state_dict_exsit_keys: new_model_state_dict[k_str] = model_state_dict[k_str] for layer_num in layer_num_list: bert_key_name = "bert.encoder.layer.{}".format(max_bert_layer - args.num_decoder_layer + 1 + layer_num) mirror_key_name = "bert.encoder.layer.{}".format(layer_num) if k_str.find(bert_key_name) == 0: new_key_name = k_str.replace(bert_key_name, mirror_key_name).replace("bert.encoder", "decoder.decoder") if "attention.self" in new_key_name: new_key_name_sufx = new_key_name.replace("attention.self", "slf_attn.att") new_model_state_dict[new_key_name_sufx] = model_state_dict[k_str].clone() new_key_name_sufx = new_key_name.replace("attention.self", "enc_attn.att") new_model_state_dict[new_key_name_sufx] = model_state_dict[k_str].clone() elif "attention.output" in new_key_name: new_key_name_sufx = new_key_name.replace("attention.output", "slf_attn.output") new_model_state_dict[new_key_name_sufx] = model_state_dict[k_str].clone() new_key_name_sufx = new_key_name.replace("attention.output", "enc_attn.output") new_model_state_dict[new_key_name_sufx] = model_state_dict[k_str].clone() else: new_model_state_dict[new_key_name] = model_state_dict[k_str].clone() if k_str.find("bert.embeddings") == 0: new_key_name = k_str.replace("bert.embeddings", "decoder.embeddings") new_model_state_dict[new_key_name] = model_state_dict[k_str].clone() model_state_dict = new_model_state_dict else: model_state_dict = None # Prepare model cache_dir = args.cache_dir if args.cache_dir else \ os.path.join(str(PYTORCH_PRETRAINED_BERT_CACHE), 'distributed_{}'.format(args.local_rank)) model = BertForSequenceLabeling.from_pretrained(args.bert_model, cache_dir=cache_dir, state_dict=model_state_dict, num_tp_labels=num_tp_labels, task_config=task_config) if args.fp16: model.half() model.to(device) if args.local_rank != -1: try: from apex.parallel import DistributedDataParallel as DDP except ImportError: raise ImportError( "Please install apex from https://www.github.com/nvidia/apex to use distributed and fp16 training.") model = DDP(model) elif n_gpu > 1: model = torch.nn.DataParallel(model) return model def prep_optimizer(args, model, num_train_optimization_steps): param_optimizer = list(model.named_parameters()) no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] if args.use_decoder: no_decay_param_tp = [(n, p) for n, p in param_optimizer if not any(nd in n for nd in no_decay)] decay_param_tp = [(n, p) for n, p in param_optimizer if any(nd in n for nd in no_decay)] no_decay_bert_param_tp = [(n, p) for n, p in no_decay_param_tp if "bert." in n] no_decay_nobert_param_tp = [(n, p) for n, p in no_decay_param_tp if "bert." not in n] decay_bert_param_tp = [(n, p) for n, p in decay_param_tp if "bert." in n] decay_nobert_param_tp = [(n, p) for n, p in decay_param_tp if "bert." not in n] coef_lr = 10. optimizer_grouped_parameters = [ {'params': [p for n, p in no_decay_bert_param_tp], 'weight_decay': 0.01}, {'params': [p for n, p in no_decay_nobert_param_tp], 'weight_decay': 0.01, 'lr': args.learning_rate * coef_lr}, {'params': [p for n, p in decay_bert_param_tp], 'weight_decay': 0.0}, {'params': [p for n, p in decay_nobert_param_tp], 'weight_decay': 0.0, 'lr': args.learning_rate * coef_lr} ] else: optimizer_grouped_parameters = [ {'params': [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)], 'weight_decay': 0.01}, {'params': [p for n, p in param_optimizer if any(nd in n for nd in no_decay)], 'weight_decay': 0.0} ] if args.fp16: try: from apex.optimizers import FP16_Optimizer from apex.optimizers import FusedAdam except ImportError: raise ImportError( "Please install apex from https://www.github.com/nvidia/apex to use distributed and fp16 training.") optimizer = FusedAdam(optimizer_grouped_parameters, lr=args.learning_rate, bias_correction=False, max_grad_norm=1.0) if args.loss_scale == 0: optimizer = FP16_Optimizer(optimizer, dynamic_loss_scale=True) else: optimizer = FP16_Optimizer(optimizer, static_loss_scale=args.loss_scale) else: optimizer = BertAdam(optimizer_grouped_parameters, lr=args.learning_rate, warmup=args.warmup_proportion, t_total=num_train_optimization_steps) return optimizer def dataloader_train(args, tokenizer, file_path): dataset = ATEASCProcessor(file_path=file_path, set_type="train") logger.info("Loaded train file: {}".format(file_path)) at_labels, as_labels = get_labels(dataset.label_tp_list) features = convert_examples_to_features(dataset.examples, (at_labels, as_labels), args.max_seq_length, tokenizer, verbose_logging=args.verbose_logging) all_input_ids = torch.tensor([f.input_ids for f in features], dtype=torch.long) all_input_mask = torch.tensor([f.input_mask for f in features], dtype=torch.long) all_segment_ids = torch.tensor([f.segment_ids for f in features], dtype=torch.long) all_at_label_ids = torch.tensor([f.at_label_id for f in features], dtype=torch.long) all_as_label_ids = torch.tensor([f.as_label_id for f in features], dtype=torch.long) all_label_mask = torch.tensor([f.label_mask for f in features], dtype=torch.long) all_label_mask_X = torch.tensor([f.label_mask_X for f in features], dtype=torch.long) train_data = TensorDataset(all_input_ids, all_input_mask, all_segment_ids, all_at_label_ids, all_as_label_ids, all_label_mask, all_label_mask_X) if args.local_rank == -1: train_sampler = RandomSampler(train_data) else: train_sampler = DistributedSampler(train_data) dataloader = DataLoader(train_data, sampler=train_sampler, batch_size=args.train_batch_size, num_workers=args.num_thread_reader) return dataloader, train_data, (at_labels, as_labels) def dataloader_val(args, tokenizer, file_path, label_tp_list, set_type="val"): dataset = ATEASCProcessor(file_path=file_path, set_type=set_type) logger.info("Loaded val file: {}".format(file_path)) eval_features = convert_examples_to_features(dataset.examples, label_tp_list, args.max_seq_length, tokenizer, verbose_logging=args.verbose_logging) all_input_ids = torch.tensor([f.input_ids for f in eval_features], dtype=torch.long) all_input_mask = torch.tensor([f.input_mask for f in eval_features], dtype=torch.long) all_segment_ids = torch.tensor([f.segment_ids for f in eval_features], dtype=torch.long) all_at_label_ids = torch.tensor([f.at_label_id for f in eval_features], dtype=torch.long) all_as_label_ids = torch.tensor([f.as_label_id for f in eval_features], dtype=torch.long) all_label_mask = torch.tensor([f.label_mask for f in eval_features], dtype=torch.long) all_label_mask_X = torch.tensor([f.label_mask_X for f in eval_features], dtype=torch.long) eval_data = TensorDataset(all_input_ids, all_input_mask, all_segment_ids, all_at_label_ids, all_as_label_ids, all_label_mask,
if 'quiet' not in self.params.keys(): RuntimeUtils.info("Tunnel is %s." % (self.is_tunnel_enabled and 'enabled' or 'disabled'), format=self.params.get('output-format', 'text')) # Register, if requested if 'activation-keys' in self.params.keys(): self._do_register_at_sm(force=('override' in self.params.keys())) # Execute some command, if any if self.params.get('command'): self._do_command() # Performing tasks def _do_register_at_sm(self, force=False): """ Register remote node at SUSE Manager. """ ssl_certificate = "/srv/www/htdocs/pub/RHN-ORG-TRUSTED-SSL-CERT" # Point of configuration in a future. if self.environ.target_os.lower() == 'linux': # Register remote against SUSE Manager if self.ssh.execute("rpm -qa | grep sm-client-tools || echo 'absent'") == 'absent': RuntimeUtils.info('Installing SM Client on target machine', format=self.params.get('output-format', 'text')) remote_pkg_pth = '/tmp/sm-client-tools.%s.%s.rpm' % (time.time(), random.randint(0xff, 0xffff)) # Temporary unique (hopefully) name on remote filesystem. local_pkg_pth = "/srv/www/htdocs/pub/bootstrap/sm-client-tools.rpm" if not os.path.exists(local_pkg_pth): raise Exception('SUSE Manager Client package does not exists.') self.ssh.push_file(local_pkg_pth, remote_pkg_pth) self.ssh.execute('/bin/rpm -ivh %s; rm %s' % (remote_pkg_pth, remote_pkg_pth)) if self.ssh.execute('test -e /usr/bin/sm-client && echo "installed" || echo "failed"') == 'failed': raise Exception("SM Client installation failed. :-(") else: if 'quiet' not in self.params.keys(): RuntimeUtils.info("SM Client has been installed", format=self.params.get('output-format', 'text')) else: if 'quiet' not in self.params.keys(): RuntimeUtils.info('SM Client is already installed', format=self.params.get('output-format', 'text')) # Get SSL certificate fingerprint ssl_fp = os.popen("/usr/bin/openssl x509 -noout -in %s -fingerprint" % ssl_certificate).read().split('=')[-1].strip() if not 'quiet' in self.params.keys(): RuntimeUtils.info("SSL certificate: %s" % ssl_fp, format=self.params.get('output-format', 'text')) # If we need sudo, we need to know it is there if getpass.getuser() != 'root': if self.ssh.execute("test -e /usr/bin/sudo && echo 'OK'") != 'OK': raise Exception("You cannot run anything on \"%s\" as \"%s\" without sudo installed!" % (self.hostname, getpass.getuser())) # Check if we have permissions if self.ssh.execute("/usr/bin/sudo -S true < /dev/null &>/dev/null && echo 'OK'") != 'OK': raise Exception("Not enough privileges for user \"%s\" on \"%s\" node." % (getpass.getuser(), self.hostname)) # Register machine remote_tmp_logfile = '/tmp/.sm-client-tools.%s.%s.log' % (time.strftime('%Y%m%d.%H%M%S.backup', time.localtime()), random.randint(0xff, 0xffff)) overrides = [] if self.is_tunnel_enabled: overrides.append('--cfg=noSSLServerURL,http://%s:%s/' % (self.localhostname, self.tunnel.http_port)) overrides.append('--cfg=serverURL,https://%s:%s/XMLRPC' % (self.localhostname, self.tunnel.https_port)) prefix = getpass.getuser() != 'root' and "/usr/bin/sudo -n " or "" self.ssh.execute("%s/usr/bin/sm-client --output-format=xml --hostname=%s --activation-keys=%s --ssl-fingerprint=%s %s > %s" % (prefix, self.localhostname, self.params['activation-keys'], ssl_fp, ' '.join(overrides), remote_tmp_logfile)) smc_out = SMClientOutput(self.ssh.execute("test -e %s && /bin/cat %s && rm %s || echo '<?xml version=\"1.0\" encoding=\"UTF-8\"?><log/>'" % (remote_tmp_logfile, remote_tmp_logfile, remote_tmp_logfile))) if smc_out.events.get(SMClientOutput.ERROR): RuntimeUtils.warning("Remote machine was not happy:", format=self.params.get('output-format', 'text')) for error_message in smc_out.events.get(SMClientOutput.ERROR): RuntimeUtils.error(error_message, format=self.params.get('output-format', 'text')) raise Exception("Registration failed. Please login to the %s and find out why." % self.hostname) elif smc_out.events.get(SMClientOutput.WARNING) and not 'quiet' in self.params.keys(): for warning_message in smc_out.events.get(SMClientOutput.WARNING): RuntimeUtils.warning(self.hostname + ": " + warning_message, format=self.params.get('output-format', 'text')) # No success blah-blah-blah here. else: # Solaris fans, do it yourself. :-) raise Exception('I cannot register %s against SUSE Manager as of today.' % self.environ.target_os) if 'quiet' not in self.params.keys(): RuntimeUtils.info("Remote machine %s has been registered successfully." % self.hostname, format=self.params.get('output-format', 'text')) def _do_tunneling(self, check_only=False): """ Enable or disable tunnel. """ if not self.ssh: raise Exception("SSH link was not initialized.") # Get content of the /etc/hosts on the remote machine random.seed() token = '# <PASSWORD>' % (time.<PASSWORD>(), random.randint(0xff, 0xffff)) etc_hosts = self.ssh.execute("test -e /etc/hosts && cat /etc/hosts || echo '%s'" % token) + "" self.is_tunnel_enabled = False if etc_hosts.find(token) > -1: raise Exception('Tunneling cannot be enabled on this system.') else: for line in map(lambda item:item.strip().lower(), etc_hosts.split("\n")): if not line.startswith('#') and line.find(self.localhostname) > -1: self.is_tunnel_enabled = True break # Setup SSH if tunneling around if self.is_tunnel_enabled: self.ssh.set_tunneling(((self.tunnel.http_port, 80, self.localhostname), (self.tunnel.https_port, 443, self.localhostname),)) # Exit if this is only check/setup if check_only: return # Skip procedure if nothing needed to do. enable = self.params.get('tunneling', '') == 'yes' RuntimeUtils.info('%s tunneling on %s node.' % ((enable and 'Enabling' or 'Disabling'), self.hostname), format=self.params.get('output-format', 'text')) if enable: if self.is_tunnel_enabled: RuntimeUtils.warning('Tunelling on the node "%s" is already enabled.' % self.hostname, format=self.params.get('output-format', 'text')) return else: if not self.is_tunnel_enabled: RuntimeUtils.warning('Tunelling on the node "%s" is already disabled.' % self.hostname, format=self.params.get('output-format', 'text')) return self.is_tunnel_enabled = enable hosts = [] for line in etc_hosts.split("\n"): if not line.strip().startswith('#'): if enable and line.lower().find('localhost') + 1: line = map(lambda item:item.strip(), filter(None, line.split(' '))) line.append(self.localhostname) line = ' '.join(line) else: line = ' '.join(filter(None, line.replace(self.localhostname, '').split(' '))).strip() hosts.append(line) etc_hosts = '\n'.join(hosts) # Save to tempfile tmpfd, tmppth = tempfile.mkstemp(prefix='sm-push-hosts-%s-' % self.hostname) tmpfh = os.fdopen(tmpfd, "w") tmpfh.write(etc_hosts + "\n") tmpfh.close() # Push the file to the remote remote_hosts_pth = '/tmp/.sm-push-hosts-%s.%s' % (time.time(), random.randint(0xff, 0xffff)) self.ssh.push_file(tmppth, remote_hosts_pth) # Push failed? if (self.ssh.execute("test -e %s && echo 'OK' || echo '%s'" % (remote_hosts_pth, token)) + "").strip() != 'OK': raise Exception('Unable to send new configuration to "%s" node.' % self.hostname) # Replace remote file if 'safe' in self.params.keys(): backup_suffix = time.strftime('%Y%m%d.%H%M%S.backup', time.localtime()) res = self.ssh.execute('mv /etc/hosts /etc/hosts.%s' % backup_suffix) if res: RuntimeUtils.error(res, format=self.params.get('output-format', 'text')) self._cleanup(tmppth) raise Exception('Remote node error.') if not 'quiet' in self.params.keys(): RuntimeUtils.info('Previous file "/etc/hosts" has been saved as "/etc/hosts.%s"' % backup_suffix, format=self.params.get('output-format', 'text')) res = self.ssh.execute('mv %s /etc/hosts; chmod 0644 /etc/hosts' % remote_hosts_pth) if res: RuntimeUtils.error(res, format=self.params.get('output-format', 'text')) self._cleanup(tmppth) raise Exception('Remote node error.') # Restart DNS cache self._restart_dns_cache() # Enable or disable 3rd party services self._enable_services(not enable) def _enable_services(self, enable): """ Enable or disable various 3rd party services that should not run when SSH tunneling is around. """ if self.environ.target_os.lower() == 'linux': for service_name, service_exec in [('OSAD client-side', '/etc/init.d/osad'), ('Red Hat Network update query', '/etc/init.d/rhnsd'),]: if self.ssh.execute('test -e %s && %s %s;chkconfig %s %s || echo "absent"' %(service_exec, service_exec, (enable and 'start' or 'stop'), (enable and '-a' or '-d'), service_exec.split('/')[-1])) != 'absent': RuntimeUtils.info('%s %s service' % ((enable and 'Enabling' or 'Stopping'), service_name), format=self.params.get('output-format', 'text')) else: RuntimeUtils.warning('Additional service operations are not supported for %s on %s.' % (self.environ.target_os, self.environ.target_arch), format=self.params.get('output-format', 'text')) def _restart_dns_cache(self): """ Restart DNS cache. On Linux it is nscd. """ if self.environ.target_os.lower() == 'linux': if self.ssh.execute("test -e /etc/init.d/nscd && echo 'exists' || echo 'absent'") == 'exists': RuntimeUtils.info('Restarting name service cache daemon on remote node.', format=self.params.get('output-format', 'text')) self.ssh.execute('/etc/init.d/nscd') else: RuntimeUtils.warning('DNS cache operations are not supported for %s on %s.' % (self.environ.target_os, self.environ.target_arch), format=self.params.get('output-format', 'text')) def _cleanup(self, *fpth): """ Cleanup all given file paths. """ for fp in fpth: if os.path.exists(fp): try: os.unlink(fp) except Exception, ex: RuntimeUtils.warning('Could not remove local temporary file "%s"' % fp, format=self.params.get('output-format', 'text')) RuntimeUtils.error(str(ex), format=self.params.get('output-format', 'text')) def _do_command(self): """ Execute a custom command on the remote machine. """ if not self.ssh: raise Exception("SSH link was not initialized.") if not 'quiet' in self.params.keys(): RuntimeUtils.info('Executing command: "' + self.params.get('command') + '"', format=self.params.get('output-format', 'text')) RuntimeUtils.info('Remote response below as follows:', format=self.params.get('output-format', 'text')) response = self.ssh.execute(self.params.get('command')) # Output "frame" only during verbose mode (default) if not 'quiet' in self.params.keys() and self.params.get('output-format', 'text') == 'text': print >> sys.stdout, "-" * 80 if self.params.get('output-format', 'text') == 'xml': RuntimeUtils.info(response or "", format='xml') else: print >> sys.stdout, response if not 'quiet' in self.params.keys() and self.params.get('output-format', 'text') == 'text': print >> sys.stdout, "-" * 80 class RuntimeUtils: """ All 'orphan' functions are here. :) """ @classmethod def is_root(self): """ Returns True if user is root. """ return getpass.getuser() == 'root' @classmethod def get_event_time(self): """ Format a time for an event, usually used in XML messages. """ return time.strftime('%Y.%m.%d %T', time.localtime()) @classmethod def header(self): """ Displays header. """ print >> sys.stdout, "SUSE Manager Task Push. Version 0.1\n" \ + "Copyright (c) 2013 by SUSE Linux Products GmbH\n" @classmethod def usage(self): """ Displays usage and exits. """ print >> sys.stderr, "Usage:\n\tsm-push <options>\n" print >> sys.stderr, "Options:" print >> sys.stderr, "\t--hostname=<DNS name>\t\tSpecify target hostname." print >> sys.stderr, "\t--activation-keys=<list>\tComma separated list of activation keys.\n" \ + "\t\t\t\t\tIf parameter specified, machine will be registered against SUSE Manager." print >> sys.stderr, "\t--override\t\t\tIgnore conditional request of an operation and always perform it." print >> sys.stderr, "\t--command=\"<command>\"\t\tCustom command to be executed on the target machine.\n" \ + "\t\t\t\t\tPlease escape quote and/or double-quote inside, if required." print >> sys.stderr, "\t--tunneling=<yes|no>\t\tEnable or disable tunneling." print >> sys.stderr, "\t--output-format=<xml|text>\tOutput format. Default is \"text\"." print >> sys.stderr, "\t--safe\t\t\t\tMake a backup copy of previous configuration." print >> sys.stderr, "\t--quiet\t\t\t\tProduce no output at all except occurred errors and command result." print >> sys.stderr, "\t--help\t\t\t\tDisplays this message.\n\n" print >> sys.stderr, "Environment variables:" print
token_pedido_ssr = "" def ssr_estoque(): return{ "cep_destino": "07929050", "url": "https://ssr.e-peca.com.br/checkout/pagamento", "produtos": [ { "id": "78", "id_produto_variacao": "78", "preco_final": 78.99, "quantidade": 2, "codigosoriginais": [ "43957-86E", "43957-86C", "43957-86B", "43957-86D", "43957-86A", "43957-86" ] }, { "id": "101", "id_produto_variacao": "101", "preco_final": 220.89, "quantidade": 1, "codigosoriginais": [ "46127-04" ] } ] } def ssr_verifica_frete_1(): return{ "cep_destino": "07929050", "url": "https://ssr.e-peca.com.br/checkout/carrinho", "produtos": [ { "id": "101", "id_produto_variacao": "101", "preco_final": 220.89, "quantidade": 1, "codigosoriginais": [ "46127-04" ] } ] } def ssr_pedido_valido_visa_1(): return{ "cliente": { "id_identificador": "45368311850", "email": "<EMAIL>", "nome_razao": "<NAME>", "endereco_cobranca": { "uf": "SP", "cep": "07929050", "nro": "159", "obs": None, "bairro": "Jardim", "cidade": "Francisco Morato", "logradouro": "Rua das Palmeiras", "complemento": "Próximo a escola" }, "endereco_entrega": { "uf": "SP", "cep": "07929050", "nro": "159", "obs": None, "bairro": "Jardim", "cidade": "Francisco Morato", "logradouro": "Rua das Palmeiras", "complemento": "Próximo a escola" } }, "forma_pagamento": { "id": 1, "nome": "Visa Crédito", "n_parcelas": 1, "detalhes_pagamento": { "hash_cartao": "c8773dbc4625366b5d3a499298feeadf939c86aefa42e4472ae8dffba70027f3b7304c77c25452274e8d3d09a376b9841997d99a8c0a1e76af1a5c77a79ee4dd", "pagador": { "nome": "<NAME>", "identificador": "45368311850", "dt_nascimento": "29/09/1994", "telefone": { "ddd": "11", "numero": "994757788" } } } }, "cupom_desconto": { "nome": "", "valor_total_produtos": 220.89 }, "origens": [ { "cep_origem": "80740000", "cep_destino": "07929050", "url": "", "produtos": [ { "id": "101", "id_produto_variacao": 101, "preco_final": 220.89, "quantidade": 1, "codigosoriginais": [ "46127-04" ], "subgrupo":"Mesas de Garfo", "segmento":"Motocicleta", "descricao":"Mesa de Garfo", "largura":20.5, "altura":25, "profundidade":19, "peso":2.01, "foto":"101/360/Lv1/img01.jpg", "INFO_BOUTIQUE":True, "id_produto":101, "id_produto_pai":101, "id_loja":4, "id_empresa":4, "pn_produto":"46127-04", "preco":220.89, "preco_desconto":220.89, "preco_original":220.89, "desconto":0, "estoque":3, "estoque_minimo":0, "info_boutique":True, "info_gerais":{ "segmento": "Motocicleta", "foto": "101/360/Lv1/img01.jpg", "largura": 20.5, "peso": 2.01, "altura": 25, "subgrupo": "Mesas de Garfo", "tamanho_unico": "", "profundidade": 19, "descricao": "Mesa de Garfo" }, "categoria": [ ], "cep_origem":"80740000", "vendido_por":"The One Harley-Davidson - Curitiba/PR", "alias":"PR-CWB-01", "status":"ATIVO", "vitrine":{ "peso": 2.01, "altura": 25, "largura": 20.5, "produto": 101, "descricao": "Mesa de Garfo", "profundidade": 19, "segmento": "Motocicleta", "foto": "101/360/Lv1/img01.jpg", "subgrupo": "Mesas de Garfo" }, "data_atualizacao": "" } ], "embalagem": [ { "id": 2, "nome": "<NAME>", "largura": 55, "altura": 36, "profundidade": 28, "peso_max_embalagem": 10, "peso_max": 10, "peso_itens": 2.111, "volume_embalagem": 55440, "volume_max": 55440, "volume_itens": 9737.5, "volume_utilizado": 9737.5, "itens_embalagem": 1, "itens_volume": 1, "peso_utilizado": 21.11, "peso_utilizado_percentual": 21.11, "volume_utilizado_percentual": 17.56, "produtos": [ { "id": "101", "id_produto_variacao": "101", "segmento": "Motocicleta", "subgrupo": "Mesas de Garfo", "descricao": "Mesa de Garfo", "codigosoriginais": [ "46127-04" ], "foto":"101/360/Lv1/img01.jpg", "vendido_por":"<NAME> - Curitiba/PR", "id_loja":4, "cep_origem":"80740000", "INFO_BOUTIQUE":True, "quantidade":1, "preco_final":220.89, "estoque":3, "largura":20.5, "altura":25, "profundidade":19, "peso":2.01, "volume":9737.5, "embalagem":[ ], "posicao":[ "altura", "largura", "profundidade" ] } ], "unidade":"cm cubicos", "preco_final":220.89 } ], "vendido_por":"<NAME>-Davidson - Curitiba/PR", "frete":[ { "empresa": "Correios", "entrega_metodo_tipo": "EXPRESS", "entrega_metodo_nome": "Correios Sedex", "entrega_metodo_id": "2", "entrega_custo_final": 100.47, "entrega_estimada_dias": 6 } ] } ] } def ssr_calculo_frete_1(): return{ "cliente": { "id_identificador": "45368311850", "email": "<EMAIL>", "nome_razao": "<NAME>", "endereco_cobranca": { "uf": "SP", "cep": "07929050", "nro": "159", "obs": None, "bairro": "Jardim", "cidade": "Francisco Morato", "logradouro": "Rua das Palmeiras", "complemento": "Próximo a escola" }, "endereco_entrega": { "uf": "SP", "cep": "07929050", "nro": "159", "obs": None, "bairro": "Jardim", "cidade": "<NAME>", "logradouro": "Rua das Palmeiras", "complemento": "Próximo a escola" } }, "cupom_desconto": { "nome": "", "valor_total_produtos": 220.89 }, "origens": [ { "cep_origem": "80740000", "cep_destino": "07929050", "url": "", "produtos": [ { "id": "101", "id_produto_variacao": 101, "preco_final": 220.89, "quantidade": 1, "codigosoriginais": [ "46127-04" ], "subgrupo":"Mesas de Garfo", "segmento":"Motocicleta", "descricao":"Mesa de Garfo", "largura":20.5, "altura":25, "profundidade":19, "peso":2.01, "foto":"101/360/Lv1/img01.jpg", "INFO_BOUTIQUE":True, "id_produto":101, "id_produto_pai":101, "id_loja":4, "id_empresa":4, "pn_produto":"46127-04", "preco":220.89, "preco_desconto":220.89, "preco_original":220.89, "desconto":0, "estoque":3, "estoque_minimo":0, "info_boutique":True, "info_gerais":{ "segmento": "Motocicleta", "foto": "101/360/Lv1/img01.jpg", "largura": 20.5, "peso": 2.01, "altura": 25, "subgrupo": "Mesas de Garfo", "tamanho_unico": "", "profundidade": 19, "descricao": "Mesa de Garfo" }, "categoria": [ ], "cep_origem":"80740000", "vendido_por":"<NAME> - Curitiba/PR", "alias":"PR-CWB-01", "status":"ATIVO", "vitrine":{ "peso": 2.01, "altura": 25, "largura": 20.5, "produto": 101, "descricao": "Mesa de Garfo", "profundidade": 19, "segmento": "Motocicleta", "foto": "101/360/Lv1/img01.jpg", "subgrupo": "Mesas de Garfo" }, "data_atualizacao": "" } ], "embalagem": [ { "id": 2, "nome": "<NAME>", "largura": 55, "altura": 36, "profundidade": 28, "peso_max_embalagem": 10, "peso_max": 10, "peso_itens": 2.111, "volume_embalagem": 55440, "volume_max": 55440, "volume_itens": 9737.5, "volume_utilizado": 9737.5, "itens_embalagem": 1, "itens_volume": 1, "peso_utilizado": 21.11, "peso_utilizado_percentual": 21.11, "volume_utilizado_percentual": 17.56, "produtos": [ { "id": "101", "id_produto_variacao": "101", "segmento": "Motocicleta", "subgrupo": "Mesas de Garfo", "descricao": "<NAME>", "codigosoriginais": [ "46127-04" ], "foto":"101/360/Lv1/img01.jpg", "vendido_por":"The One Harley-Davidson - Curitiba/PR", "id_loja":4, "cep_origem":"80740000", "INFO_BOUTIQUE":True, "quantidade":1, "preco_final":220.89, "estoque":3, "largura":20.5, "altura":25, "profundidade":19, "peso":2.01, "volume":9737.5, "embalagem":[ ], "posicao":[ "altura", "largura", "profundidade" ] } ], "unidade":"cm cubicos", "preco_final":220.89 } ], "vendido_por":"The One Harley-Davidson - Curitiba/PR", "frete":[ { "empresa": "Correios", "entrega_metodo_tipo": "EXPRESS", "entrega_metodo_nome": "Correios Sedex", "entrega_metodo_id": "2", "entrega_custo_final": 100.47, "entrega_estimada_dias": 6 } ] } ] } def ssr_calculo_frete_2(): return{ "cliente": { "id_identificador": "45368311850", "email": "<EMAIL>", "nome_razao": "<NAME>", "endereco_cobranca": { "uf": "SP", "cep": "07929050", "nro": "159", "obs": None, "bairro": "Jardim", "cidade": "<NAME>", "logradouro": "Rua das Palmeiras", "complemento": "Próximo a escola" }, "endereco_entrega": { "uf": "SP", "cep": "07929050", "nro": "159", "obs": None, "bairro": "Jardim", "cidade": "<NAME>", "logradouro": "Rua das Palmeiras", "complemento": "Próximo a escola" } }, "cupom_desconto": { "nome": "", "valor_total_produtos": 119.25 }, "origens": [ { "cep_origem": "80740000", "cep_destino": "07929050", "url": "", "produtos": [ { "id": "924", "id_produto_variacao": 924, "preco_final": 119.25, "quantidade": 1, "codigosoriginais": [ "67700043", "67700043A", "67700145", "67700145A" ], "subgrupo":"Faróis", "segmento":"Motocicleta", "descricao":"Farol", "largura":19, "altura":30, "profundidade":11.5, "peso":1.1, "foto":"924/360/Lv1/img01.jpg", "INFO_BOUTIQUE":True, "id_produto":924, "id_produto_pai":924, "id_loja":4, "id_empresa":4, "pn_produto":"67700043", "preco":119.25, "preco_desconto":119.25, "preco_original":119.25, "desconto":0, "estoque":5, "estoque_minimo":0, "info_boutique":True, "info_gerais":{ "segmento": "Motocicleta", "foto": "924/360/Lv1/img01.jpg", "largura": 19, "peso": 1.1, "altura": 30, "subgrupo": "Faróis", "tamanho_unico": "", "profundidade": 11.5, "descricao": "Farol" }, "categoria": [ ], "cep_origem":"80740000", "vendido_por":"<NAME> - Curitiba/PR", "alias":"PR-CWB-01", "status":"ATIVO", "vitrine":{ "peso": 1.1, "altura": 30, "largura": 19, "produto": 924, "descricao": "Farol", "profundidade": 11.5, "segmento": "Motocicleta", "foto": "924/360/Lv1/img01.jpg", "subgrupo": "Faróis" }, "data_atualizacao": "" } ], "embalagem": [ { "id": 2, "nome": "<NAME>", "largura": 55, "altura": 36, "profundidade": 28, "peso_max_embalagem": 10, "peso_max": 10, "peso_itens": 1.155, "volume_embalagem": 55440, "volume_max": 55440, "volume_itens": 6555, "volume_utilizado": 6555, "itens_embalagem": 1, "itens_volume": 1, "peso_utilizado": 11.55, "peso_utilizado_percentual": 11.55, "volume_utilizado_percentual": 11.82, "produtos": [ { "id": "924", "id_produto_variacao": "924", "segmento": "Motocicleta", "subgrupo": "Faróis", "descricao": "Farol", "codigosoriginais": [ "67700043", "67700043A", "67700145", "67700145A" ], "foto":"924/360/Lv1/img01.jpg", "vendido_por":"<NAME> - Curitiba/PR", "id_loja":4, "cep_origem":"80740000", "INFO_BOUTIQUE":True, "quantidade":1, "preco_final":119.25, "estoque":5, "largura":19, "altura":30, "profundidade":11.5, "peso":1.1, "volume":6555, "embalagem":[ ], "posicao":[ "altura", "largura", "profundidade" ] } ], "unidade":"cm cubicos", "preco_final":119.25 } ], "vendido_por":"<NAME> - Curitiba/PR", "frete":[ { "empresa": "Retirada Na Loja", "entrega_custo_final": 0, "entrega_estimada_dias": 1, "entrega_metodo_id": 195, "entrega_metodo_nome": "Retirada na Loja", "entrega_metodo_tipo": "PICKUP" } ] } ] } def ssr_verifica_frete_2(): return{ "cep_destino": "07929050", "url": "https://ssr.e-peca.com.br/checkout/pagamento", "produtos": [ { "id": "924", "id_produto_variacao": "924", "preco_final": 119.25, "quantidade": 1, "codigosoriginais": [ "67700043", "67700043A", "67700145", "67700145A" ] } ] } def ssr_pedido_valido_master_card_1(): return{ "cliente": { "id_identificador": "45368311850", "email": "<EMAIL>", "nome_razao": "<NAME>", "endereco_cobranca": { "uf": "SP", "cep": "07929050", "nro": "159", "obs": None, "bairro": "Jardim", "cidade": "Francisco Morato", "logradouro": "Rua das Palmeiras", "complemento": "Próximo a escola" }, "endereco_entrega": { "uf": "SP", "cep": "07929050", "nro": "159", "obs": None, "bairro": "Jardim", "cidade": "Francisco Morato", "logradouro": "Rua das Palmeiras", "complemento": "Próximo a escola" } }, "forma_pagamento": { "id": 7, "nome": "Mastercard Crédito", "n_parcelas": 1, "detalhes_pagamento": { "hash_cartao": "9bbcb515c1bf24fb4b27f7a89a65d2dff89d6a6aeeb82a1fdce84bafa7fc688b791ffb2bc1fb6f38d4d5331f75ddd0008b0b4af76923f112cc7a47f6a9fcfc0d", "pagador": { "nome": "<NAME>", "identificador": "45368311850", "dt_nascimento": "29/09/1994", "telefone": { "ddd": "11", "numero": "994757788" } } } }, "cupom_desconto": { "nome": "", "valor_total_produtos": 119.25 }, "origens": [ { "cep_origem": "80740000", "cep_destino": "07929050", "url": "", "produtos": [ { "id": "924", "id_produto_variacao": 924, "preco_final": 119.25, "quantidade": 1, "codigosoriginais": [ "67700043", "67700043A", "67700145", "67700145A" ], "subgrupo":"Faróis", "segmento":"Motocicleta", "descricao":"Farol", "largura":19, "altura":30, "profundidade":11.5, "peso":1.1, "foto":"924/360/Lv1/img01.jpg", "INFO_BOUTIQUE":True, "id_produto":924, "id_produto_pai":924, "id_loja":4, "id_empresa":4, "pn_produto":"67700043", "preco":119.25, "preco_desconto":119.25, "preco_original":119.25, "desconto":0, "estoque":5, "estoque_minimo":0, "info_boutique":True, "info_gerais":{ "segmento": "Motocicleta", "foto": "924/360/Lv1/img01.jpg", "largura": 19, "peso": 1.1, "altura": 30, "subgrupo": "Faróis", "tamanho_unico": "", "profundidade": 11.5, "descricao": "Farol" }, "categoria": [ ], "cep_origem":"80740000", "vendido_por":"<NAME> - Curitiba/PR", "alias":"PR-CWB-01", "status":"ATIVO", "vitrine":{ "peso": 1.1, "altura": 30, "largura": 19, "produto": 924, "descricao": "Farol", "profundidade": 11.5, "segmento": "Motocicleta", "foto": "924/360/Lv1/img01.jpg", "subgrupo": "Faróis" }, "data_atualizacao": "" } ], "embalagem": [ { "id": 2, "nome": "<NAME>", "largura": 55, "altura": 36, "profundidade": 28, "peso_max_embalagem": 10, "peso_max": 10, "peso_itens": 1.155, "volume_embalagem": 55440, "volume_max": 55440, "volume_itens": 6555, "volume_utilizado": 6555, "itens_embalagem": 1, "itens_volume": 1, "peso_utilizado": 11.55, "peso_utilizado_percentual": 11.55, "volume_utilizado_percentual": 11.82, "produtos": [ { "id": "924", "id_produto_variacao": "924", "segmento": "Motocicleta", "subgrupo": "Faróis", "descricao": "Farol", "codigosoriginais": [ "67700043", "67700043A", "67700145", "67700145A" ], "foto":"924/360/Lv1/img01.jpg", "vendido_por":"The One Harley-Davidson - Curitiba/PR", "id_loja":4, "cep_origem":"80740000", "INFO_BOUTIQUE":True, "quantidade":1, "preco_final":119.25, "estoque":5, "largura":19, "altura":30, "profundidade":11.5, "peso":1.1, "volume":6555, "embalagem":[ ], "posicao":[ "altura", "largura", "profundidade" ] } ], "unidade":"cm cubicos", "preco_final":119.25 } ], "vendido_por":"The One Harley-Davidson - Curitiba/PR", "frete":[ { "empresa": "Retirada Na Loja", "entrega_custo_final": 0, "entrega_estimada_dias":
ConfigurationException( 'Expected training_main_memory_chunksize > training_chunk') if self.guessing_secondary_training: if ((not self.secondary_training) or (not self.secondary_training_save_freqs)): raise ConfigurationException( 'Expected secondary_training and secondary_training_save_freqs') if self.sequence_model != Sequence.MANY_TO_MANY and\ self.sequence_model != Sequence.MANY_TO_ONE: raise ConfigurationException( "Configuration parameter 'sequence_model' can only be " "'many_to_many' or 'many_to_one'") def as_dict(self): answer = dict(vars(ModelDefaults).copy()) answer.update(self.adict) return { key: value for key, value in answer.items() if ( key[0] != '_' and not hasattr(value, '__call__') and not isinstance(value, staticmethod))} def set_intermediate_info(self, key, value): self._intermediate_data[key] = value self._write_intermediate_data() def get_intermediate_info(self, key): self._check_if_should_reload() try: return self._intermediate_data[key] except KeyError as e: logging.error('Cannot find intermediate data %s. Looking in %s', str(e), self.intermediate_fname) raise def override_from_commandline(self, cmdline): answer = {} for keyval in cmdline.split(';'): if not keyval: continue key, _, value = keyval.partition('=') answer[key] = type(getattr(self, key))(value) self.adict.update(answer) def sequence_model_updates(self): if self.sequence_model == Sequence.MANY_TO_MANY: self.char_bag += PASSWORD_START class BasePreprocessor(): def __init__(self, config=ModelDefaults()): self.config = config def begin(self, pwd_list): raise NotImplementedError() def begin_resetable(self, resetable): self.begin(resetable.create_new()) def next_chunk(self): raise NotImplementedError() def reset(self): raise NotImplementedError() def stats(self): self.reset() x_vec, _, _ = self.next_chunk() count_instances = 0 while len(x_vec) != 0: count_instances += len(x_vec) x_vec, _, _ = self.next_chunk() logging.info('Number of training instances %s', count_instances) return count_instances @staticmethod def fromConfig(config): if config.sequence_model == Sequence.MANY_TO_MANY: return ManyToManyPreprocessor(config) if config.sequence_model == Sequence.MANY_TO_ONE: return Preprocessor(config) raise ValueError('unknown sequence model: %s' % config.sequence_model) class Preprocessor(BasePreprocessor): def __init__(self, config=ModelDefaults()): super().__init__(config) self.chunk = 0 self.resetable_pwd_list = None self.pwd_whole_list = None self.pwd_freqs = None self.chunked_pwd_list = None def begin(self, pwd_list): self.pwd_whole_list = list(pwd_list) def begin_resetable(self, resetable): self.resetable_pwd_list = resetable self.reset() def all_prefixes(self, pwd): return [pwd[:i] for i in range(len(pwd))] + [pwd] def all_suffixes(self, pwd): return [pwd[i] for i in range(len(pwd))] + [PASSWORD_END] def repeat_weight(self, pwd): return [self.password_weight(pwd) for _ in range(len(pwd) + 1)] def train_from_pwds(self, pwd_tuples): self.pwd_freqs = dict(pwd_tuples) pwds = list(map(lambda x: x[0], pwd_tuples)) return (itertools.chain.from_iterable(map(self.all_prefixes, pwds)), itertools.chain.from_iterable(map(self.all_suffixes, pwds)), itertools.chain.from_iterable(map(self.repeat_weight, pwds))) def next_chunk(self): if self.chunk * self.config.training_chunk >= len(self.pwd_whole_list): if self.resetable_pwd_list is None: return [], [], [] try: new_iterator = self.chunked_pwd_list.__next__() except StopIteration: return [], [], [] self.begin(new_iterator) self.reset_subiterator() return self.next_chunk() pwd_list = self.pwd_whole_list[ self.chunk * self.config.training_chunk: min((self.chunk + 1) * self.config.training_chunk, len(self.pwd_whole_list))] self.chunk += 1 pwd_input, output, weight = self.train_from_pwds(pwd_list) return (list(pwd_input), list(output), list(weight)) def password_weight(self, pwd): if isinstance(pwd, tuple): pwd = ''.join(pwd) if pwd in self.pwd_freqs: return self.pwd_freqs[pwd] assert False, 'Cannot find frequency for password' return 0.0 def reset(self): if self.resetable_pwd_list is None: self.reset_subiterator() return self.chunked_pwd_list = iter(grouper( self.resetable_pwd_list.as_iterator(), self.config.training_main_memory_chunksize)) try: self.begin(self.chunked_pwd_list.__next__()) except StopIteration: logging.warning('Password list has no passwords?') self.pwd_whole_list = [] self.reset_subiterator() def reset_subiterator(self): self.chunk = 0 if self.config.randomize_training_order: random.shuffle(self.pwd_whole_list) class Trainer(): def __init__(self, pwd_list, config=ModelDefaults(), multi_gpu=1): self.config = config self.chunk = 0 self.generation = 0 self.model = None self.model_to_save = None self.multi_gpu = multi_gpu self.pwd_list = pwd_list self.cumulative_chunks = 0 self.min_loss_early_stopping = float("inf") self.poor_batches_early_stopping = 0 self.smoothened_loss = collections.deque(maxlen=int(config.chunk_print_interval)) if config.tensorboard: self.callback = TensorBoard(config.tensorboard_dir) self.train_log_names = [] self.test_log_names = [] else: self.callback = None self.train_log_names = None self.test_log_names = None self.ctable = CharacterTable.fromConfig(self.config) self.feature_layers = [] self.classification_layers = [] def next_train_set_as_np(self): x_strs, y_str_list, weight_list = self.pwd_list.next_chunk() x_vec = self.prepare_x_data(x_strs) y_vec = self.prepare_y_data(y_str_list) weight_vec = np.zeros((len(weight_list))) for i, weight in enumerate(weight_list): weight_vec[i] = weight return shuffle(x_vec, y_vec, weight_vec) def prepare_x_data(self, x_strs): return self.ctable.encode_many(x_strs) def prepare_y_data(self, y_str_list): y_vec = np.zeros((len(y_str_list), self.ctable.vocab_size), dtype=np.bool) self.ctable.y_encode_into(y_vec, y_str_list) return y_vec def _make_layer(self, **kwargs): recurrent_train_backwards = self.config.train_backwards model_type = self.config.model_type hidden_size = self.config.hidden_size if model_type == 'GRU': return recurrent.GRU( hidden_size, return_sequences=True, go_backwards=recurrent_train_backwards, **kwargs) if model_type == 'LSTM': return recurrent.LSTM( hidden_size, return_sequences=True, go_backwards=recurrent_train_backwards, **kwargs) if model_type == 'Conv1D': return Conv1D( hidden_size, self.config.convolutional_kernel_size, **kwargs) raise ConfigurationException('Unknown model_type: %s' % model_type) def _return_model(self): model = Sequential() # Add the first input layer. If embedding is enabled, we add a different # layer which does not have the input_shape defined if self.config.embedding_layer: self.feature_layers.append( Embedding( self.ctable.vocab_size, self.config.embedding_size, input_length=self.config.context_length)) self.feature_layers.append(self._make_layer()) else: self.feature_layers.append( self._make_layer( input_shape=( self.config.context_length, self.ctable.vocab_size))) # Add the main model layers. These layers will not be trainable during # secondary training. for _ in range(self.config.layers): if self.config.dropouts: self.feature_layers.append(Dropout(self.config.dropout_ratio)) self.feature_layers.append(self._make_layer()) self.feature_layers.append(Flatten()) # Add any additional classification layers. These layers may be # trainable during secondary training. for _ in range(self.config.dense_layers): self.classification_layers.append( Dense(self.config.dense_hidden_size)) # Append the final layer which has the correct dimensions for the output self.classification_layers.append( Dense(self.ctable.vocab_size, activation='softmax')) # Actually build the model for layer in self.feature_layers + self.classification_layers: try: model.add(layer) except Exception as e: logging.error('Error when adding layer %s: %s', layer, e) raise return model def build_model(self, model=None): if self.multi_gpu >= 2: with tf.device('/cpu:0'): if model is None: model = self._return_model() self.model_to_save = model model = keras.utils.multi_gpu_model(model, gpus=self.multi_gpu) else: if model is None: model = self._return_model() self.model_to_save = model metrics = ['accuracy'] if self.config.tensorboard: tensorboard_metrics = ['loss'] + metrics self.train_log_names = ['train_' + name for name in tensorboard_metrics] self.test_log_names = ['test_' + name for name in tensorboard_metrics] model.compile(loss='categorical_crossentropy', optimizer=self.config.model_optimizer, metrics=metrics) self.model = model def init_layers(self): assert self.model is not None assert len(self.classification_layers) == 0 assert len(self.feature_layers) == 0 for layer in self.model.layers: if isinstance(layer, (TimeDistributed, Activation, Dense)): self.classification_layers.append(layer) else: self.feature_layers.append(layer) def train_model(self, serializer): prev_accuracy = 0 max_accuracy = 0 if self.config.tensorboard: self.callback.set_model(self.model) for gen in range(self.config.generations): self.generation = gen + 1 logging.info('Generation %d', gen + 1) accuracy, early_stop = self.train_model_generation(serializer) logging.info('Generation accuracy: %s', accuracy) if early_stop: break if not self.config.early_stopping and \ (accuracy > max_accuracy or self.config.save_always): max_accuracy = accuracy serializer.save_model(self.model_to_save) if ((accuracy - prev_accuracy) < self.config.training_accuracy_threshold): logging.info('Accuracy diff of %s is less than threshold.', accuracy - prev_accuracy) break prev_accuracy = accuracy def test_set(self, x_all, y_all, w_all): split_at = len(x_all) - max( int(len(x_all) / self.config.train_test_ratio), 1) x_train = x_all[0:split_at, :] x_val = x_all[split_at:, :] y_train, y_val = (y_all[:split_at], y_all[split_at:]) w_train, w_val = (w_all[:split_at], w_all[split_at:]) return x_train, x_val, y_train, y_val, w_train, w_val def training_step(self, x_all, y_all, w_all): x_train, x_val, y_train, y_val, w_train, w_val = self.test_set( x_all, y_all, w_all) train_loss, train_accuracy = self.model.train_on_batch( x_train, y_train, sample_weight=w_train) test_loss, test_accuracy = self.model.test_on_batch( x_val, y_val, sample_weight=w_val) return (train_loss, train_accuracy, test_loss, test_accuracy) def early_stopping(self, smooth_loss, serializer): stop = False if self.min_loss_early_stopping > smooth_loss: self.min_loss_early_stopping = smooth_loss serializer.save_model(self.model_to_save) self.poor_batches_early_stopping = 0 elif self.poor_batches_early_stopping < self.config.early_stopping_patience: self.poor_batches_early_stopping += 1 else: stop = True return stop def train_model_generation(self, serializer=None): if self.config.early_stopping: assert serializer, "Need to specify serializer with early_stopping" self.chunk = 0 self.pwd_list.reset() accuracy_accum = [] x_all, y_all, w_all = self.next_train_set_as_np() chunk = 0 early_stop = False while len(x_all) != 0: assert len(x_all) == len(y_all) tr_loss, tr_acc, te_loss, te_acc = self.training_step( x_all, y_all, w_all) accuracy_accum += [(len(x_all), te_acc)] self.smoothened_loss.append((len(x_all), te_loss)) if self.config.tensorboard: self.write_log(self.train_log_names, [tr_loss, tr_acc], self.cumulative_chunks) self.write_log(self.test_log_names, [te_loss, te_acc], self.cumulative_chunks) if chunk % self.config.chunk_print_interval == 0: #Finding weighted average to get the right loss value over batches # of unequal sizes instances_smoothened = map(lambda x: x[0], self.smoothened_loss) loss_smoothened = sum(map(lambda x: x[0] * x[1], self.smoothened_loss) ) / sum(instances_smoothened) logging.info('Chunk %s. Each chunk is size %s', chunk, len(x_all)) logging.info('Train loss %s. Test loss %s. Test accuracy %s. Averaged loss %s', tr_loss, te_loss, te_acc, loss_smoothened) if self.config.tensorboard: self.callback.writer.flush() if self.config.early_stopping and \ self.cumulative_chunks >= self.config.early_stopping_patience and \ self.cumulative_chunks % self.config.chunk_print_interval == 0: #Second condition so that the model doesn't start saving \ # very early in the training process #Third condition to prevent evaluation of accuracy too frequently instances_smoothened = map(lambda x: x[0], self.smoothened_loss) loss_smoothened = sum(map(lambda x: x[0] * x[1], self.smoothened_loss) ) / sum(instances_smoothened) early_stop = self.early_stopping(loss_smoothened, serializer) if early_stop: instances = map(lambda x: x[0], accuracy_accum) return sum(map(lambda x: x[0] * x[1], accuracy_accum) ) / sum(instances), early_stop x_all, y_all, w_all = self.next_train_set_as_np() chunk += 1 self.cumulative_chunks += 1 instances = map(lambda x: x[0], accuracy_accum) return sum(map(lambda x: x[0] * x[1], accuracy_accum)) / sum(instances), early_stop def train(self, serializer): logging.info('Building model...') self.build_model(self.model) logging.info('Done compiling model. Beginning training...') self.train_model(serializer) def freeze_feature_layers(self): for layer in self.feature_layers: layer.trainable = False def retrain_classification(self, preprocessor, serializer): assert self.model is not None assert len(self.feature_layers) != 0 if self.config.freeze_feature_layers_during_secondary_training: logging.info('Freezing feature layers...') self.freeze_feature_layers() logging.info('Retraining...') self.pwd_list = preprocessor self.train(serializer) def write_log(self, names, logs, batch_no): assert self.callback for name, value in zip(names, logs): summary = tf.Summary() summary_value = summary.value.add() summary_value.simple_value = value summary_value.tag = name self.callback.writer.add_summary(summary, batch_no) class ManyToManyTrainer(Trainer): def
fr.write('\t name = "' + name + '"\n') fr.write('\t virtual_network_name = "' + vnetname + '"\n') fr.write('\t resource_group_name = "' + rgs + '"\n') sprefix=subs[j]["properties"]["addressPrefix"] fr.write('\t address_prefix = "' + sprefix + '"\n') rtbid="null" try: seps=subs[j]["properties"]["serviceEndpoints"] kcount=len(seps) #print (json.dumps(seps, indent=4, separators=(',', ': '))) #print kcount lseps='[' for k in range(0, kcount): x=seps[k]["service"] lseps=lseps+'"'+x+'",' lseps=lseps+']' fr.write('\t service_endpoints = '+ lseps + '\n') except KeyError: pass try: snsgid=subs[j]["properties"]["networkSecurityGroup"]["id"].split("/")[8].replace(".","-") snsgrg=subs[j]["properties"]["networkSecurityGroup"]["id"].split("/")[4].replace(".","-").lower() fr.write('\t network_security_group_id = "${azurerm_network_security_group.' + snsgrg + '__' + snsgid +'.id}"' + '\n') except KeyError: pass try: rtbid=subs[j]["properties"]["routeTable"]["id"].split("/")[8].replace(".","-") rtrg=subs[j]["properties"]["routeTable"]["id"].split("/")[4].replace(".","-").lower() fr.write('\t route_table_id = "${azurerm_route_table.' + rtrg + '__' + rtbid +'.id}"' + '\n') except KeyError: pass try: delegn=subs[j]["properties"]["delegations"] kcount=len(delegn) for k in range(0, kcount): delegn=subs[j]["properties"]["delegations"][k]["name"] fr.write('delegation {\n') fr.write('\t name = "' + delegn + '"\n') try: sdn=subs[j]["properties"]["delegations"][k]["properties"]["serviceName"] sdact=str(ast.literal_eval(json.dumps(subs[j]["properties"]["delegations"][k]["properties"]["actions"]))) sdact=sdact.replace("'",'"') fr.write('\t service_delegation {\n') fr.write('\t name = "' + sdn + '"\n') #fr.write('\t actions = ' + sdact + '\n') fr.write('\t} \n') except KeyError: pass fr.write('} \n') # end k loop except KeyError: pass fr.write('}' + ' \n') # azurerm_subnet_network_security_group_association r1="skip" try: snsgid=subs[j]["properties"]["networkSecurityGroup"]["id"].split("/")[8].replace(".","-") r1="azurerm_subnet_network_security_group_association" fr.write('resource ' + r1 + ' ' + rg + '__' + rname + '__' + snsgid + ' {\n') fr.write('\tsubnet_id = "${azurerm_subnet.' + rg + '__' + rname + '.id}"' + '\n') fr.write('\tnetwork_security_group_id = "${azurerm_network_security_group.' + snsgrg + '__' + snsgid +'.id}"' + '\n') fr.write('}' + ' \n') except KeyError: pass # azurerm_subnet_route_table_association r2="skip" try: rtbid=subs[j]["properties"]["routeTable"]["id"].split("/")[8].replace(".","-") r2="azurerm_subnet_route_table_association" fr.write('resource ' + r2 + ' ' + rg + '__' + rname + '__' + rtbid + ' {\n') fr.write('\tsubnet_id = "${azurerm_subnet.' + rg + '__' + rname + '.id}"' + '\n') fr.write('\troute_table_id = "${azurerm_route_table.' + rtrg + '__' + rtbid +'.id}"' + '\n') fr.write('}' + ' \n') except KeyError: pass #fr.write('}\n') fr.close() # close .tf file # azurerm_subnet tfrm.write('terraform state rm '+tfp+'.'+rg+'__'+rname + '\n') tfim.write('echo "importing ' + str(j) + ' of ' + str(jcount-1) + '"' + '\n') tfcomm='terraform import '+tfp+'.'+rg+'__'+rname+' '+id+'\n' tfim.write(tfcomm) # azurerm_subnet_network_security_group_association if "skip" not in r1: tfrm.write('terraform state rm ' + r1 + '.' + rg + '__' + rname + '__' + snsgid + '\n') tfcomm='terraform import '+r1 +'.'+rg+'__'+rname+'__'+snsgid+' '+id+'\n' tfim.write(tfcomm) # azurerm_subnet_route_table_association if "skip" not in r2: tfrm.write('terraform state rm ' + r2 + '.' + rg + '__' + rname + '__' + rtbid + '\n') tfcomm='terraform import '+r2 +'.'+rg+'__'+rname+'__'+rtbid+' '+id+'\n' tfim.write(tfcomm) # end j ############### # specific code end ############### # end for i loop tfrm.close() tfim.close() #end subnet # # azurerm_virtual_network_peering # def azurerm_virtual_network_peering(crf,cde,crg,headers,requests,sub,json,az2tfmess): ############# # 080 vnet peering tfp="azurerm_virtual_network_peering" if crf in tfp: # peering in vnet url="https://management.azure.com/subscriptions/" + sub + "/providers/Microsoft.Network/virtualNetworks" params = {'api-version': '2018-07-01'} r = requests.get(url, headers=headers, params=params) azr= r.json()["value"] tfrmf="080-"+tfp+"-staterm.sh" tfimf="080-"+tfp+"-stateimp.sh" tfrm=open(tfrmf, 'a') tfim=open(tfimf, 'a') print "# " + tfp, count=len(azr) print count for i in range(0, count): peers=azr[i]["properties"]["virtualNetworkPeerings"] vnetname=azr[i]["name"] jcount=len(peers) for j in range(0, jcount): name=peers[j]["name"] #loc=peers[j]["location"] peers don't have a location id=peers[j]["id"] rg=id.split("/")[4].replace(".","-").lower() rgs=id.split("/")[4] if crg is not None: if rgs.lower() != crg.lower(): continue # back to for if cde: print(json.dumps(peers[j], indent=4, separators=(',', ': '))) rname=name.replace(".","-") prefix=tfp+"."+rg+'__'+rname rfilename=prefix+".tf" fr=open(rfilename, 'w') fr.write("") fr.write('resource ' + tfp + ' ' + rg + '__' + rname + ' {\n') fr.write('\t name = "' + name + '"\n') fr.write('\t resource_group_name = "'+ rgs + '"\n') fr.write('\t virtual_network_name = "' + vnetname + '"\n') rvnid=peers[j]["properties"]["remoteVirtualNetwork"]["id"] aft=str(peers[j]["properties"]["allowForwardedTraffic"]).lower() agt=str(peers[j]["properties"]["allowGatewayTransit"]).lower() avna=str(peers[j]["properties"]["allowVirtualNetworkAccess"]).lower() urg=str(peers[j]["properties"]["useRemoteGateways"]).lower() fr.write('\t remote_virtual_network_id = "' + rvnid + '"\n') fr.write('\t allow_forwarded_traffic = ' + aft + '\n') fr.write('\t allow_gateway_transit = ' + agt + '\n') fr.write('\t allow_virtual_network_access = ' + avna + '\n') fr.write('\t use_remote_gateways = ' + urg + '\n') fr.write('}\n') fr.close() # close .tf file tfrm.write('terraform state rm '+tfp+'.'+rg+'__'+rname + '\n') tfim.write('echo "importing ' + str(j) + ' of ' + str(jcount-1) + '"' + '\n') tfcomm='terraform import '+tfp+'.'+rg+'__'+rname+' '+id+'\n' tfim.write(tfcomm) # end for j loop # end for i loop tfrm.close() tfim.close() #end peering # # azurerm_managed_disk # def azurerm_managed_disk(crf,cde,crg,headers,requests,sub,json,az2tfmess): tfp="azurerm_managed_disk" azr="" if crf in tfp: # REST or cli url="https://management.azure.com/subscriptions/" + sub + "/providers/Microsoft.Compute/disks" params = {'api-version': '2017-03-30'} r = requests.get(url, headers=headers, params=params) azr= r.json()["value"] tfrmf="100-"+tfp+"-staterm.sh" tfimf="100-"+tfp+"-stateimp.sh" tfrm=open(tfrmf, 'a') tfim=open(tfimf, 'a') print "# " + tfp, count=len(azr) print count for i in range(0, count): oname=azr[i]["name"] name=oname.replace("/.vhd","/_vhd") loc=azr[i]["location"] id=azr[i]["id"] rg=id.split("/")[4].replace(".","-").lower() rgs=id.split("/")[4] if crg is not None: if rgs.lower() != crg.lower(): continue # back to for if cde: print(json.dumps(azr[i], indent=4, separators=(',', ': '))) rname=name.replace(".","-") prefix=tfp+"."+rg+'__'+rname rfilename=prefix+".tf" fr=open(rfilename, 'w') fr.write(az2tfmess) fr.write('resource ' + tfp + ' ' + rg + '__' + rname + ' {\n') fr.write('\t name = "' + name + '"\n') fr.write('\t location = "'+ loc + '"\n') fr.write('\t resource_group_name = "'+ rgs + '"\n') try: ostyp=azr[i]["properties"]["osType"] fr.write('\t os_type = "' + ostyp + '"\n') except KeyError: pass try: creopt=azr[i]["properties"]["creationData"]["createOption"] fr.write('\t create_option = "' + creopt + '"\n') except KeyError: pass try: creopt=azr[i]["properties"]["creationData"]["sourceResourceId"] fr.write('\t source_resource_id = "' + creopt + '"\n') except KeyError: pass try: imid=azr[i]["properties"]["creationData"]["imageReference"]["id"] fr.write('\t image_reference_id = "' + imid + '"\n') except KeyError: pass """ try: creid=azr[i]["properties"]["creationData"]["imageReference"]["id"] fr.write('\t source_resource_id = "' + creid + '"\n') except KeyError: pass """ try: enc=azr[i]["properties"]["encryptionSettings"]["enabled"] fr.write('\t encryption_settings { \n') fr.write('\t\t enabled = ' + str(enc).lower() + '\n') try: kekurl=azr[i]["properties"]["encryptionSettings"]["keyEncryptionKey"]["keyUrl"] kekvltid=azr[i]["properties"]["encryptionSettings"]["keyEncryptionKey"]["sourceVault"]["id"] fr.write('\t\t key_encryption_key { \n') fr.write('\t\t\t key_url = "' + kekurl + '"\n') fr.write('\t\t\t source_vault_id = "' + kekvltid + '"\n') fr.write('\t\t } \n') except KeyError: pass try: dekurl=azr[i]["properties"]["encryptionSettings"]["diskEncryptionKey"]["secretUrl"] dekvltid=azr[i]["properties"]["encryptionSettings"]["diskEncryptionKey"]["sourceVault"]["id"] fr.write('\t\t disk_encryption_key { \n') fr.write('\t\t\t secret_url = "' + dekurl + '"\n') fr.write('\t\t\t source_vault_id = "' + dekvltid + '"\n') fr.write('\t\t } \n') except KeyError: pass fr.write('\t } \n') except KeyError: pass try: stopt=azr[i]["sku"]["name"] fr.write('\t storage_account_type = "' + stopt + '"\n') except KeyError: fr.write('\t storage_account_type = "' + "StandardSSD_LRS" + '"\n') pass try: dsize=str(azr[i]["properties"]["diskSizeGB"]) fr.write('\t disk_size_gb = "' + dsize + '"\n') except KeyError: pass try: zones=azr[i]["zones"] fr.write('zones = ') fr.write(json.dumps(zones, indent=4, separators=(',', ': '))) fr.write('\n') except KeyError: pass # tags block try: mtags=azr[i]["tags"] fr.write('tags = { \n') for key in mtags.keys(): tval=mtags[key] fr.write('\t "' + key + '"="' + tval + '"\n') fr.write('}\n') except KeyError: pass fr.write('}\n') fr.close() # close .tf file if cde: with open(rfilename) as f: print f.read() tfrm.write('terraform state rm '+tfp+'.'+rg+'__'+rname + '\n') tfim.write('echo "importing ' + str(i) + ' of ' + str(count-1) + '"' + '\n') tfcomm='terraform import '+tfp+'.'+rg+'__'+rname+' '+id+'\n' tfim.write(tfcomm) # end for i loop tfrm.close() tfim.close() #end managed disk # # azurerm_storage_account # import ast def azurerm_storage_account(crf,cde,crg,headers,requests,sub,json,az2tfmess): # 110 storage account tfp="azurerm_storage_account" azr="" if crf in tfp: # REST or cli # print "REST Storage Acc" url="https://management.azure.com/subscriptions/" + sub + "/providers/Microsoft.Storage/storageAccounts" params = {'api-version': '2019-04-01'} r = requests.get(url, headers=headers, params=params) azr= r.json()["value"] tfrmf="110-"+tfp+"-staterm.sh" tfimf="110-"+tfp+"-stateimp.sh" tfrm=open(tfrmf, 'a') tfim=open(tfimf, 'a') print '# '+tfp, count=len(azr) print count for i in range(0, count): name=azr[i]["name"] loc=azr[i]["location"] id=azr[i]["id"] rg=id.split("/")[4].replace(".","-").lower() rgs=id.split("/")[4] if crg is not None: if rgs.lower() != crg.lower(): continue # back to for if cde: print(json.dumps(azr[i], indent=4, separators=(',', ': '))) rname=name.replace(".","-") prefix=tfp+"."+rg+'__'+rname #print prefix rfilename=prefix+".tf" fr=open(rfilename, 'w') fr.write("") fr.write('resource ' + tfp + ' ' + rg + '__' + rname + ' {\n') fr.write('\t name = "' + name + '"\n') fr.write('\t location = "'+ loc + '"\n') fr.write('\t resource_group_name = "'+ rgs + '"\n') satier=azr[i]["sku"]["tier"] sakind=azr[i]["kind"] sartype=azr[i]["sku"]["name"].split("_")[1] saencrypt=str(azr[i]["properties"]["encryption"]["services"]["blob"]["enabled"]).lower() fiencrypt=str(azr[i]["properties"]["encryption"]["services"]["file"]["enabled"]).lower() sahttps=str(azr[i]["properties"]["supportsHttpsTrafficOnly"]).lower() #nrs=azr[i]["properties"]["networkAcls"] saencs=azr[i]["properties"]["encryption"]["keySource"] fr.write('\t account_tier = "' + satier + '"\n') fr.write('\t account_kind = "' + sakind + '"\n') fr.write('\t account_replication_type = "' + sartype + '"\n') fr.write('\t enable_blob_encryption = ' + saencrypt + '\n') fr.write('\t enable_file_encryption = ' + fiencrypt + '\n') fr.write('\t enable_https_traffic_only = ' + sahttps + '\n') fr.write('\t account_encryption_source = "' + saencs + '"\n') try: ishns=str(azr[i]["properties"]["isHnsEnabled"]).lower() fr.write('\t is_hns_enabled = ' + ishns + '\n') except KeyError: pass try: byp=str(ast.literal_eval(json.dumps(azr[i]["properties"]["networkAcls"]["bypass"]))) byp=byp.replace("'",'"') byp=byp.replace(", ",'", "') ipr=azr[i]["properties"]["networkAcls"]["ipRules"] #print(json.dumps(ipr, indent=4, separators=(',', ': ')))
return _gui.GuiPushButton_set_style(self, style) def get_content_size(self, w, h): return _gui.GuiPushButton_get_content_size(self, w, h) def set_roundness(self, roundness): return _gui.GuiPushButton_set_roundness(self, roundness) def get_roundness(self): return _gui.GuiPushButton_get_roundness(self) def set_ellipsis(self, value): return _gui.GuiPushButton_set_ellipsis(self, value) def get_ellipsis(self): return _gui.GuiPushButton_get_ellipsis(self) def set_action(self, action): return _gui.GuiPushButton_set_action(self, action) def enable_state_button_behavior(self, press): return _gui.GuiPushButton_enable_state_button_behavior(self, press) def release(self): return _gui.GuiPushButton_release(self) if _newclass: class_info = staticmethod(_gui.GuiPushButton_class_info) else: class_info = _gui.GuiPushButton_class_info if _newclass: ___class_destructor__ = staticmethod(_gui.GuiPushButton____class_destructor__) else: ___class_destructor__ = _gui.GuiPushButton____class_destructor__ def get_class_info(self): return _gui.GuiPushButton_get_class_info(self) def __gui_destroy__(self): return _gui.GuiPushButton___gui_destroy__(self) def __collect__(self): return _gui.GuiPushButton___collect__(self) def __uncollect__(self): return _gui.GuiPushButton___uncollect__(self) def is_created_by_python(self): if hasattr(self, '__pycreated__'): return self.__pycreated__ else: return False def destroy(self): if self.is_created_by_python(): self.__disown__() self.__gui_destroy__() self.__uncollect__() def __del__(self): if not self.is_created_by_python(): return if self.is_shown(): self.hide() if self.is_destroyed(): if self.thisown: self.__disown__() else: self.destroy() def __disown__(self): self.this.disown() _gui.disown_GuiPushButton(self) return weakref_proxy(self) GuiPushButton_swigregister = _gui.GuiPushButton_swigregister GuiPushButton_swigregister(GuiPushButton) EVT_ID_PUSH_BUTTON_CLICK = cvar.EVT_ID_PUSH_BUTTON_CLICK EVT_ID_PUSH_BUTTON_UNCLICK = cvar.EVT_ID_PUSH_BUTTON_UNCLICK def GuiPushButton_get_style_name(style): return _gui.GuiPushButton_get_style_name(style) GuiPushButton_get_style_name = _gui.GuiPushButton_get_style_name def GuiPushButton_class_info(): return _gui.GuiPushButton_class_info() GuiPushButton_class_info = _gui.GuiPushButton_class_info def GuiPushButton____class_destructor__(instance, is_array): return _gui.GuiPushButton____class_destructor__(instance, is_array) GuiPushButton____class_destructor__ = _gui.GuiPushButton____class_destructor__ class GuiCheckButton(GuiWidget): __swig_setmethods__ = {} for _s in [GuiWidget]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, GuiCheckButton, name, value) __swig_getmethods__ = {} for _s in [GuiWidget]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, GuiCheckButton, name) __repr__ = _swig_repr STYLE_FLAT = _gui.GuiCheckButton_STYLE_FLAT STYLE_BUTTON = _gui.GuiCheckButton_STYLE_BUTTON STYLE_ROUND = _gui.GuiCheckButton_STYLE_ROUND STYLE_COUNT = _gui.GuiCheckButton_STYLE_COUNT if _newclass: get_style_name = staticmethod(_gui.GuiCheckButton_get_style_name) else: get_style_name = _gui.GuiCheckButton_get_style_name def __init__(self, *args): if self.__class__ == GuiCheckButton: _self = None else: _self = self this = _gui.new_GuiCheckButton(_self, *args) try: self.this.append(this) except __builtin__.Exception: self.this = this self.__pycreated__ = True self.__collect__() def draw(self, dc): return _gui.GuiCheckButton_draw(self, dc) def get_label(self): return _gui.GuiCheckButton_get_label(self) def set_label(self, label): return _gui.GuiCheckButton_set_label(self, label) def get_value(self): return _gui.GuiCheckButton_get_value(self) def set_value(self, value): return _gui.GuiCheckButton_set_value(self, value) def process_event(self, event_id): return _gui.GuiCheckButton_process_event(self, event_id) def get_justification(self): return _gui.GuiCheckButton_get_justification(self) def set_justification(self, justification): return _gui.GuiCheckButton_set_justification(self, justification) def get_icon(self): return _gui.GuiCheckButton_get_icon(self) def set_icon(self, *args): return _gui.GuiCheckButton_set_icon(self, *args) def get_pushed_icon(self): return _gui.GuiCheckButton_get_pushed_icon(self) def set_pushed_icon(self, *args): return _gui.GuiCheckButton_set_pushed_icon(self, *args) def get_icon_position(self): return _gui.GuiCheckButton_get_icon_position(self) def set_icon_position(self, position): return _gui.GuiCheckButton_set_icon_position(self, position) def get_style(self): return _gui.GuiCheckButton_get_style(self) def set_style(self, style): return _gui.GuiCheckButton_set_style(self, style) def get_content_size(self, w, h): return _gui.GuiCheckButton_get_content_size(self, w, h) def set_roundness(self, roundness): return _gui.GuiCheckButton_set_roundness(self, roundness) def get_roundness(self): return _gui.GuiCheckButton_get_roundness(self) def set_edge_selection(self, b): return _gui.GuiCheckButton_set_edge_selection(self, b) def is_use_option(self): return _gui.GuiCheckButton_is_use_option(self) def set_use_option(self, use_option): return _gui.GuiCheckButton_set_use_option(self, use_option) if _newclass: class_info = staticmethod(_gui.GuiCheckButton_class_info) else: class_info = _gui.GuiCheckButton_class_info if _newclass: ___class_destructor__ = staticmethod(_gui.GuiCheckButton____class_destructor__) else: ___class_destructor__ = _gui.GuiCheckButton____class_destructor__ def get_class_info(self): return _gui.GuiCheckButton_get_class_info(self) def __gui_destroy__(self): return _gui.GuiCheckButton___gui_destroy__(self) def __collect__(self): return _gui.GuiCheckButton___collect__(self) def __uncollect__(self): return _gui.GuiCheckButton___uncollect__(self) def is_created_by_python(self): if hasattr(self, '__pycreated__'): return self.__pycreated__ else: return False def destroy(self): if self.is_created_by_python(): self.__disown__() self.__gui_destroy__() self.__uncollect__() def __del__(self): if not self.is_created_by_python(): return if self.is_shown(): self.hide() if self.is_destroyed(): if self.thisown: self.__disown__() else: self.destroy() def __disown__(self): self.this.disown() _gui.disown_GuiCheckButton(self) return weakref_proxy(self) GuiCheckButton_swigregister = _gui.GuiCheckButton_swigregister GuiCheckButton_swigregister(GuiCheckButton) EVT_ID_CHECK_BUTTON_CLICK = cvar.EVT_ID_CHECK_BUTTON_CLICK EVT_ID_CHECK_OPTION_BUTTON_CLICK = cvar.EVT_ID_CHECK_OPTION_BUTTON_CLICK def GuiCheckButton_get_style_name(style): return _gui.GuiCheckButton_get_style_name(style) GuiCheckButton_get_style_name = _gui.GuiCheckButton_get_style_name def GuiCheckButton_class_info(): return _gui.GuiCheckButton_class_info() GuiCheckButton_class_info = _gui.GuiCheckButton_class_info def GuiCheckButton____class_destructor__(instance, is_array): return _gui.GuiCheckButton____class_destructor__(instance, is_array) GuiCheckButton____class_destructor__ = _gui.GuiCheckButton____class_destructor__ class GuiCheckbox(GuiWidget): __swig_setmethods__ = {} for _s in [GuiWidget]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, GuiCheckbox, name, value) __swig_getmethods__ = {} for _s in [GuiWidget]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, GuiCheckbox, name) __repr__ = _swig_repr def __init__(self, *args): if self.__class__ == GuiCheckbox: _self = None else: _self = self this = _gui.new_GuiCheckbox(_self, *args) try: self.this.append(this) except __builtin__.Exception: self.this = this self.__pycreated__ = True self.__collect__() def draw(self, dc): return _gui.GuiCheckbox_draw(self, dc) def get_label(self): return _gui.GuiCheckbox_get_label(self) def set_label(self, label): return _gui.GuiCheckbox_set_label(self, label) def get_value(self): return _gui.GuiCheckbox_get_value(self) def set_value(self, value): return _gui.GuiCheckbox_set_value(self, value) def process_event(self, event_id): return _gui.GuiCheckbox_process_event(self, event_id) if _newclass: class_info = staticmethod(_gui.GuiCheckbox_class_info) else: class_info = _gui.GuiCheckbox_class_info if _newclass: ___class_destructor__ = staticmethod(_gui.GuiCheckbox____class_destructor__) else: ___class_destructor__ = _gui.GuiCheckbox____class_destructor__ def get_class_info(self): return _gui.GuiCheckbox_get_class_info(self) def __gui_destroy__(self): return _gui.GuiCheckbox___gui_destroy__(self) def __collect__(self): return _gui.GuiCheckbox___collect__(self) def __uncollect__(self): return _gui.GuiCheckbox___uncollect__(self) def is_created_by_python(self): if hasattr(self, '__pycreated__'): return self.__pycreated__ else: return False def destroy(self): if self.is_created_by_python(): self.__disown__() self.__gui_destroy__() self.__uncollect__() def __del__(self): if not self.is_created_by_python(): return if self.is_shown(): self.hide() if self.is_destroyed(): if self.thisown: self.__disown__() else: self.destroy() def __disown__(self): self.this.disown() _gui.disown_GuiCheckbox(self) return weakref_proxy(self) GuiCheckbox_swigregister = _gui.GuiCheckbox_swigregister GuiCheckbox_swigregister(GuiCheckbox) EVT_ID_CHECKBOX_CLICK = cvar.EVT_ID_CHECKBOX_CLICK def GuiCheckbox_class_info(): return _gui.GuiCheckbox_class_info() GuiCheckbox_class_info = _gui.GuiCheckbox_class_info def GuiCheckbox____class_destructor__(instance, is_array): return _gui.GuiCheckbox____class_destructor__(instance, is_array) GuiCheckbox____class_destructor__ = _gui.GuiCheckbox____class_destructor__ class GuiListView(GuiWidget): __swig_setmethods__ = {} for _s in [GuiWidget]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, GuiListView, name, value) __swig_getmethods__ = {} for _s in [GuiWidget]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, GuiListView, name) __repr__ = _swig_repr def __init__(self, parent, x, y, w, h): if self.__class__ == GuiListView: _self = None else: _self = self this = _gui.new_GuiListView(_self, parent, x, y, w, h) try: self.this.append(this) except __builtin__.Exception: self.this = this self.__pycreated__ = True self.__collect__() def draw(self, dc): return _gui.GuiListView_draw(self, dc) def show(self): return _gui.GuiListView_show(self) def hide(self): return _gui.GuiListView_hide(self) def resize(self, x, y, w, h): return _gui.GuiListView_resize(self, x, y, w, h) def process_event(self, event_id): return _gui.GuiListView_process_event(self, event_id) def get_selected_index(self): return _gui.GuiListView_get_selected_index(self) def set_selected_index(self, index): return _gui.GuiListView_set_selected_index(self, index) def add_item(self, *args): return _gui.GuiListView_add_item(self, *args) def get_item_name(self, index): return _gui.GuiListView_get_item_name(self, index) def set_item_name(self, index, name): return _gui.GuiListView_set_item_name(self, index, name) def get_item_data(self, index): return _gui.GuiListView_get_item_data(self, index) def set_item_data(self, index, data): return _gui.GuiListView_set_item_data(self, index, data) def set_item_enabled(self, *args): return _gui.GuiListView_set_item_enabled(self, *args) def make_item_title(self, name): return _gui.GuiListView_make_item_title(self, name) def is_item_enabled(self, *args): return _gui.GuiListView_is_item_enabled(self, *args) def is_item_disabled(self, *args): return _gui.GuiListView_is_item_disabled(self, *args) def get_item_count(self): return _gui.GuiListView_get_item_count(self) def get_item_icon(self, index): return _gui.GuiListView_get_item_icon(self, index) def get_item_icons(self, index): return _gui.GuiListView_get_item_icons(self, index) def remove_all_items(self): return _gui.GuiListView_remove_all_items(self) def remove_item(self, index): return _gui.GuiListView_remove_item(self, index) def find_item_by_name(self, name): return _gui.GuiListView_find_item_by_name(self, name) def set_mouse_over_selection(self, over): return _gui.GuiListView_set_mouse_over_selection(self, over) def get_mouse_over_selection(self): return _gui.GuiListView_get_mouse_over_selection(self) def scroll(self): return _gui.GuiListView_scroll(self) def set_cell_height(self, height): return _gui.GuiListView_set_cell_height(self, height) def set_icons_width(self, width): return _gui.GuiListView_set_icons_width(self, width) def get_item_y_position(self, index, y): return _gui.GuiListView_get_item_y_position(self, index, y) def set_highlight_case_sensitive(self, case_sensitive): return _gui.GuiListView_set_highlight_case_sensitive(self, case_sensitive) def set_highlight_words(self, keyword_list): return _gui.GuiListView_set_highlight_words(self, keyword_list) def is_item_readonly(self, name, readonly): return _gui.GuiListView_is_item_readonly(self, name, readonly) def set_item_readonly(self, name, enabled): return _gui.GuiListView_set_item_readonly(self, name, enabled) def get_scrollbar_width(self): return _gui.GuiListView_get_scrollbar_width(self) if _newclass: class_info = staticmethod(_gui.GuiListView_class_info) else: class_info = _gui.GuiListView_class_info if _newclass: ___class_destructor__ = staticmethod(_gui.GuiListView____class_destructor__) else: ___class_destructor__ = _gui.GuiListView____class_destructor__ def get_class_info(self): return _gui.GuiListView_get_class_info(self) def __gui_destroy__(self): return _gui.GuiListView___gui_destroy__(self) def __collect__(self): return _gui.GuiListView___collect__(self) def __uncollect__(self): return _gui.GuiListView___uncollect__(self) def is_created_by_python(self): if hasattr(self, '__pycreated__'): return self.__pycreated__ else: return False def destroy(self): if self.is_created_by_python(): self.__disown__() self.__gui_destroy__() self.__uncollect__() def __del__(self): if not self.is_created_by_python(): return if self.is_shown(): self.hide() if self.is_destroyed(): if self.thisown: self.__disown__() else: self.destroy() def __disown__(self): self.this.disown() _gui.disown_GuiListView(self) return weakref_proxy(self) GuiListView_swigregister = _gui.GuiListView_swigregister GuiListView_swigregister(GuiListView) EVT_ID_LIST_VIEW_SELECT = cvar.EVT_ID_LIST_VIEW_SELECT EVT_ID_LIST_VIEW_VALIDATE = cvar.EVT_ID_LIST_VIEW_VALIDATE def GuiListView_class_info(): return _gui.GuiListView_class_info() GuiListView_class_info = _gui.GuiListView_class_info def GuiListView____class_destructor__(instance, is_array): return _gui.GuiListView____class_destructor__(instance, is_array) GuiListView____class_destructor__ = _gui.GuiListView____class_destructor__ class GuiListViewItem(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, GuiListViewItem, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, GuiListViewItem, name) __repr__ = _swig_repr def __init__(self): this = _gui.new_GuiListViewItem() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_setmethods__["data"] = _gui.GuiListViewItem_data_set __swig_getmethods__["data"] = _gui.GuiListViewItem_data_get if _newclass: data = _swig_property(_gui.GuiListViewItem_data_get, _gui.GuiListViewItem_data_set) __swig_setmethods__["enabled"] = _gui.GuiListViewItem_enabled_set __swig_getmethods__["enabled"] = _gui.GuiListViewItem_enabled_get if _newclass: enabled = _swig_property(_gui.GuiListViewItem_enabled_get, _gui.GuiListViewItem_enabled_set) __swig_setmethods__["readonly"] = _gui.GuiListViewItem_readonly_set __swig_getmethods__["readonly"] = _gui.GuiListViewItem_readonly_get if _newclass: readonly = _swig_property(_gui.GuiListViewItem_readonly_get, _gui.GuiListViewItem_readonly_set) __swig_setmethods__["bold"] = _gui.GuiListViewItem_bold_set __swig_getmethods__["bold"] = _gui.GuiListViewItem_bold_get if _newclass: bold = _swig_property(_gui.GuiListViewItem_bold_get, _gui.GuiListViewItem_bold_set) __swig_setmethods__["name"] = _gui.GuiListViewItem_name_set __swig_getmethods__["name"] = _gui.GuiListViewItem_name_get if _newclass: name = _swig_property(_gui.GuiListViewItem_name_get, _gui.GuiListViewItem_name_set) __swig_setmethods__["icons"] = _gui.GuiListViewItem_icons_set __swig_getmethods__["icons"] = _gui.GuiListViewItem_icons_get if _newclass: icons = _swig_property(_gui.GuiListViewItem_icons_get, _gui.GuiListViewItem_icons_set) __swig_destroy__ = _gui.delete_GuiListViewItem __del__ = lambda self: None GuiListViewItem_swigregister = _gui.GuiListViewItem_swigregister GuiListViewItem_swigregister(GuiListViewItem) class GuiPanel(GuiWidget): __swig_setmethods__ = {} for _s in [GuiWidget]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, GuiPanel, name, value) __swig_getmethods__ = {} for _s in [GuiWidget]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, GuiPanel, name) __repr__ = _swig_repr def __init__(self, parent, x, y, w, h): if self.__class__ == GuiPanel: _self = None else: _self = self this = _gui.new_GuiPanel(_self, parent, x, y, w, h) try: self.this.append(this) except __builtin__.Exception: self.this = this self.__pycreated__ = True self.__collect__() def draw(self, dc): return _gui.GuiPanel_draw(self, dc) def show(self): return _gui.GuiPanel_show(self) def hide(self): return _gui.GuiPanel_hide(self) def get_background_color(self): return _gui.GuiPanel_get_background_color(self) def set_background_color(self, *args): return _gui.GuiPanel_set_background_color(self, *args) def set_top_toolbar_visible(self, visible): return _gui.GuiPanel_set_top_toolbar_visible(self, visible) def is_top_toolbar_visible(self): return _gui.GuiPanel_is_top_toolbar_visible(self) def set_bottom_toolbar_visible(self, visible): return _gui.GuiPanel_set_bottom_toolbar_visible(self, visible) def is_bottom_toolbar_visible(self): return _gui.GuiPanel_is_bottom_toolbar_visible(self) def get_top_toolbar(self): return _gui.GuiPanel_get_top_toolbar(self) def get_bottom_toolbar(self): return _gui.GuiPanel_get_bottom_toolbar(self) def is_scroll_enabled(self): return _gui.GuiPanel_is_scroll_enabled(self) def set_scroll_enabled(self, enable): return _gui.GuiPanel_set_scroll_enabled(self, enable) def is_horizontal_bar_visible(self): return _gui.GuiPanel_is_horizontal_bar_visible(self) def is_vertical_bar_visible(self): return _gui.GuiPanel_is_vertical_bar_visible(self) def reinit_scrollbars_offset(self):
<reponame>Stienvdh/statrick #!/usr/bin/python # -*- coding: utf-8 -*- # # Dell EMC OpenManage Ansible Modules # Version 3.0.0 # Copyright (C) 2019-2021 Dell Inc. or its subsidiaries. All Rights Reserved. # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) # from __future__ import (absolute_import, division, print_function) __metaclass__ = type DOCUMENTATION = r''' --- module: ome_firmware short_description: Firmware update of PowerEdge devices and its components through OpenManage Enterprise version_added: "2.0.0" description: "This module updates the firmware of PowerEdge devices and all its components through OpenManage Enterprise." extends_documentation_fragment: - dellemc.openmanage.ome_auth_options options: device_service_tag: description: - List of targeted device service tags. - Either I(device_id) or I(device_service_tag) can be used individually or together. - I(device_service_tag) is mutually exclusive with I(device_group_names). type: list elements: str device_id: description: - List of targeted device ids. - Either I(device_id) or I(device_service_tag) can be used individually or together. - I(device_id) is mutually exclusive with I(device_group_names). type: list elements: int device_group_names: description: - Enter the name of the group to update the firmware of all the devices within the group. - I(device_group_names) is mutually exclusive with I(device_id) and I(device_service_tag). type: list elements: str baseline_name: description: - Enter the baseline name to update the firmware of all the devices or groups of devices against the available compliance report. - The firmware update can also be done by providing the baseline name and the path to the single DUP file. To update multiple baselines at once, provide the baseline names separated by commas. - I(baseline_names) is mutually exclusive with I(device_group_names), I(device_id) and I(device_service_tag). type: str dup_file: description: "Executable file to apply on the targets." type: str requirements: - "python >= 2.7.5" author: - "<NAME> (@felixs88)" notes: - Run this module from a system that has direct access to DellEMC OpenManage Enterprise. - This module does not support C(check_mode). ''' EXAMPLES = r''' --- - name: Update firmware from DUP file using device ids dellemc.openmanage.ome_firmware: hostname: "192.168.0.1" username: "username" password: "password" device_id: - 11111 - 22222 dup_file: "/path/Chassis-System-Management_Firmware_6N9WN_WN64_1.00.01_A00.EXE" - name: Update firmware from a DUP file using a device service tags dellemc.openmanage.ome_firmware: hostname: "192.168.0.1" username: "username" password: "password" device_service_tag: - KLBR111 - KLBR222 dup_file: "/path/Network_Firmware_NTRW0_WN64_14.07.07_A00-00_01.EXE" - name: Update firmware from a DUP file using a device group names dellemc.openmanage.ome_firmware: hostname: "192.168.0.1" username: "username" password: "password" device_group_names: - servers dup_file: "/path/BIOS_87V69_WN64_2.4.7.EXE" - name: Update firmware using baseline name dellemc.openmanage.ome_firmware: hostname: "192.168.0.1" username: "username" password: "password" baseline_name: baseline_devices - name: Update firmware from a DUP file using a baseline names dellemc.openmanage.ome_firmware: hostname: "192.168.0.1" username: "username" password: "password" baseline_name: "baseline_devices, baseline_groups" dup_file: "/path/BIOS_87V69_WN64_2.4.7.EXE" ''' RETURN = r''' --- msg: type: str description: "Overall firmware update status." returned: always sample: "Successfully submitted the firmware update job." update_status: type: dict description: "Firmware Update job and progress details from the OME." returned: success sample: { 'LastRun': None, 'CreatedBy': 'user', 'Schedule': 'startnow', 'LastRunStatus': { 'Id': 1111, 'Name': 'NotRun' }, 'Builtin': False, 'Editable': True, 'NextRun': None, 'JobStatus': { 'Id': 1111, 'Name': 'New' }, 'JobName': 'Firmware Update Task', 'Visible': True, 'State': 'Enabled', 'JobDescription': 'dup test', 'Params': [{ 'Value': 'true', 'Key': 'signVerify', 'JobId': 11111}, { 'Value': 'false', 'Key': 'stagingValue', 'JobId': 11112}, { 'Value': 'false', 'Key': 'complianceUpdate', 'JobId': 11113}, { 'Value': 'INSTALL_FIRMWARE', 'Key': 'operationName', 'JobId': 11114}], 'Targets': [{ 'TargetType': { 'Id': 1000, 'Name': 'DEVICE'}, 'Data': 'DCIM:INSTALLED#701__NIC.Mezzanine.1A-1-1=1111111111111', 'Id': 11115, 'JobId': 11116}], 'StartTime': None, 'UpdatedBy': None, 'EndTime': None, 'Id': 11117, 'JobType': { 'Internal': False, 'Id': 5, 'Name': 'Update_Task'} } error_info: description: Details of the HTTP Error. returned: on HTTP error type: dict sample: { "error": { "code": "Base.1.0.GeneralError", "message": "A general error has occurred. See ExtendedInfo for more information.", "@Message.ExtendedInfo": [ { "MessageId": "GEN1234", "RelatedProperties": [], "Message": "Unable to process the request because an error occurred.", "MessageArgs": [], "Severity": "Critical", "Resolution": "Retry the operation. If the issue persists, contact your system administrator." } ] } } ''' import json from ssl import SSLError from ansible.module_utils.basic import AnsibleModule from ansible_collections.dellemc.openmanage.plugins.module_utils.ome import RestOME from ansible.module_utils.urls import open_url, ConnectionError, SSLValidationError from ansible.module_utils.six.moves.urllib.error import URLError, HTTPError def spawn_update_job(rest_obj, job_payload): """Spawns an update job and tracks it to completion.""" job_uri, job_details = "JobService/Jobs", {} job_resp = rest_obj.invoke_request("POST", job_uri, data=job_payload) if job_resp.status_code == 201: job_details = job_resp.json_data return job_details def job_payload_for_update(rest_obj, module, target_data, baseline=None): """Formulate the payload to initiate a firmware update job.""" resp = rest_obj.get_job_type_id("Update_Task") if resp is None: module.fail_json(msg="Unable to fetch the job type Id.") payload = { "Id": 0, "JobName": "Firmware Update Task", "JobDescription": "Firmware Update Task", "Schedule": "startnow", "State": "Enabled", "JobType": {"Id": resp, "Name": "Update_Task"}, "Targets": target_data, "Params": [{"Key": "operationName", "Value": "INSTALL_FIRMWARE"}, {"Key": "stagingValue", "Value": "false"}, {"Key": "signVerify", "Value": "true"}] } if baseline is not None: payload["Params"].append({"Key": "complianceReportId", "Value": "{0}".format(baseline["baseline_id"])}) payload["Params"].append({"Key": "repositoryId", "Value": "{0}".format(baseline["repo_id"])}) payload["Params"].append({"Key": "catalogId", "Value": "{0}".format(baseline["catalog_id"])}) payload["Params"].append({"Key": "complianceUpdate", "Value": "true"}) else: payload["Params"].append({"JobId": 0, "Key": "complianceUpdate", "Value": "false"}) return payload def get_applicable_components(rest_obj, dup_payload, module): """Get the target array to be used in spawning jobs for update.""" target_data = [] dup_url = "UpdateService/Actions/UpdateService.GetSingleDupReport" headers = {"Content-Type": "application/json", "Accept": "application/json"} dup_resp = rest_obj.invoke_request("POST", dup_url, data=dup_payload, headers=headers, api_timeout=60) if dup_resp.status_code == 200: dup_data = dup_resp.json_data file_token = str(dup_payload['SingleUpdateReportFileToken']) for device in dup_data: for component in device['DeviceReport']['Components']: temp_map = {} temp_map['Id'] = device['DeviceId'] temp_map['Data'] = "{0}={1}".format(component['ComponentSourceName'], file_token) temp_map['TargetType'] = {} temp_map['TargetType']['Id'] = int(device['DeviceReport']['DeviceTypeId']) temp_map['TargetType']['Name'] = str(device['DeviceReport']['DeviceTypeName']) target_data.append(temp_map) else: module.fail_json(msg="Unable to get components DUP applies.") return target_data def get_dup_applicability_payload(file_token, device_ids=None, group_ids=None, baseline_ids=None): """Returns the DUP applicability JSON payload.""" dup_applicability_payload = {'SingleUpdateReportBaseline': [], 'SingleUpdateReportGroup': [], 'SingleUpdateReportTargets': [], 'SingleUpdateReportFileToken': file_token} if device_ids is not None: dup_applicability_payload.update( {"SingleUpdateReportTargets": list(map(int, device_ids))} ) elif group_ids is not None: dup_applicability_payload.update( {"SingleUpdateReportGroup": list(map(int, group_ids))} ) elif baseline_ids is not None: dup_applicability_payload.update( {"SingleUpdateReportBaseline": list(map(int, baseline_ids))} ) return dup_applicability_payload def upload_dup_file(rest_obj, module): """Upload DUP file to OME and get a file token.""" upload_uri = "UpdateService/Actions/UpdateService.UploadFile" headers = {"Content-Type": "application/octet-stream", "Accept": "application/octet-stream"} upload_success, token = False, None dup_file = module.params['dup_file'] if not isinstance(dup_file, str): module.fail_json( msg="argument {0} is type of {1} and we were unable to convert to string: {1} cannot be " "converted to a string".format("dup_file", type(dup_file))) with open(module.params['dup_file'], 'rb') as payload: payload = payload.read() response = rest_obj.invoke_request("POST", upload_uri, data=payload, headers=headers, api_timeout=100, dump=False) if response.status_code == 200: upload_success = True token = str(response.json_data) else: module.fail_json(msg="Unable to upload {0} to {1}".format(module.params['dup_file'], module.params['hostname'])) return upload_success, token def get_device_ids(rest_obj, module, device_id_tags): """Getting the list of device ids filtered from the device inventory.""" device_id = [] resp = rest_obj.get_all_report_details("DeviceService/Devices") if resp["report_list"]: device_resp = dict([(str(device['Id']), device['DeviceServiceTag']) for device in resp["report_list"]]) device_tags = map(str, device_id_tags) invalid_tags = [] for tag in device_tags: if tag in device_resp.keys() or tag.isdigit(): device_id.append(tag) elif tag in device_resp.values(): ids = list(device_resp.keys())[list(device_resp.values()).index(tag)] device_id.append(ids) else: invalid_tags.append(tag) if invalid_tags: module.fail_json( msg="Unable to complete the operation because the entered target device service" " tag(s) or device id(s) '{0}' are invalid.".format(",".join(set(invalid_tags)))) else: module.fail_json(msg="Failed to fetch the device facts.") return device_id def get_dup_baseline(rest_obj, module): """Getting the list of baseline ids filtered from the baselines.""" resp = rest_obj.get_all_report_details("UpdateService/Baselines") baseline = module.params.get('baseline_name').split(",") if resp["report_list"]: baseline_ids = [bse['Id'] for bse in resp["report_list"] for name in baseline if bse['Name'] == name] if len(set(baseline)) != len(set(baseline_ids)): module.fail_json( msg="Unable to complete the operation because the entered target baseline name(s)" " '{0}' are invalid.".format(",".join(set(baseline)))) else: module.fail_json(msg="Unable to complete the operation because the entered" "target baseline name(s) does not exists.") return baseline_ids def get_group_ids(rest_obj, module): """Getting the list of group ids filtered from the groups.""" resp = rest_obj.get_all_report_details("GroupService/Groups") group_name = module.params.get('device_group_names') if resp["report_list"]: grp_ids = [grp['Id'] for grp in resp["report_list"] for grpname in group_name if grp['Name'] == grpname] if len(set(group_name)) != len(set(grp_ids)): module.fail_json( msg="Unable to complete the operation because the entered target device group name(s)" " '{0}' are invalid.".format(",".join(set(group_name)))) return grp_ids def get_baseline_ids(rest_obj, module): """Getting the list of group ids filtered from the groups.""" resp = rest_obj.get_all_report_details("UpdateService/Baselines") baseline, baseline_details = module.params.get('baseline_name'), {} if resp["report_list"]: for bse in resp["report_list"]: if bse['Name'] == baseline: baseline_details["baseline_id"] = bse["Id"] baseline_details["repo_id"] = bse["RepositoryId"] baseline_details["catalog_id"] = bse["CatalogId"] if not baseline_details: module.fail_json( msg="Unable to complete the operation because the entered target baseline name" " '{0}' is invalid.".format(baseline)) else: module.fail_json(msg="Unable to complete the operation because the entered" "target baseline name does not exist.") return baseline_details def single_dup_update(rest_obj, module): target_data, device_ids, group_ids, baseline_ids = None, None, None, None if module.params.get("device_group_names") is not None: group_ids = get_group_ids(rest_obj, module) elif module.params.get("baseline_name") is not None \ and module.params.get("dup_file") is not None: baseline_ids
<filename>src/sage/schemes/elliptic_curves/ell_number_field.py # -*- coding: utf-8 -*- r""" Elliptic curves over number fields An elliptic curve `E` over a number field `K` can be given by a Weierstrass equation whose coefficients lie in `K` or by using ``base_extend`` on an elliptic curve defined over a subfield. One major difference to elliptic curves over `\QQ` is that there might not exist a global minimal equation over `K`, when `K` does not have class number one. Another difference is the lack of understanding of modularity for general elliptic curves over general number fields. Currently Sage can obtain local information about `E/K_v` for finite places `v`, it has an interface to Denis Simon's script for 2-descent, it can compute the torsion subgroup of the Mordell-Weil group `E(K)`, and it can work with isogenies defined over `K`. EXAMPLE:: sage: K.<i> = NumberField(x^2+1) sage: E = EllipticCurve([0,4+i]) sage: E.discriminant() -3456*i - 6480 sage: P= E([i,2]) sage: P+P (-2*i + 9/16 : -9/4*i - 101/64 : 1) :: sage: E.has_good_reduction(2+i) True sage: E.local_data(4+i) Local data at Fractional ideal (i + 4): Reduction type: bad additive Local minimal model: Elliptic Curve defined by y^2 = x^3 + (i+4) over Number Field in i with defining polynomial x^2 + 1 Minimal discriminant valuation: 2 Conductor exponent: 2 Kodaira Symbol: II Tamagawa Number: 1 sage: E.tamagawa_product_bsd() 1 :: sage: E.simon_two_descent() (1, 1, [(i : 2 : 1)]) :: sage: E.torsion_order() 1 :: sage: E.isogenies_prime_degree(3) [Isogeny of degree 3 from Elliptic Curve defined by y^2 = x^3 + (i+4) over Number Field in i with defining polynomial x^2 + 1 to Elliptic Curve defined by y^2 = x^3 + (-27*i-108) over Number Field in i with defining polynomial x^2 + 1] AUTHORS: - <NAME> 2007 - <NAME> - <NAME> REFERENCE: - [Sil] Silverman, <NAME>. The arithmetic of elliptic curves. Second edition. Graduate Texts in Mathematics, 106. Springer, 2009. - [Sil2] Silverman, <NAME>. Advanced topics in the arithmetic of elliptic curves. Graduate Texts in Mathematics, 151. Springer, 1994. """ #***************************************************************************** # Copyright (C) 2007 <NAME> <<EMAIL>> # <NAME> <<EMAIL>> # # Distributed under the terms of the GNU General Public License (GPL) # # This code 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. # # The full text of the GPL is available at: # # http://www.gnu.org/licenses/ #***************************************************************************** from ell_field import EllipticCurve_field import ell_point import sage.matrix.all as matrix from sage.rings.ring import Ring from sage.rings.arith import gcd, prime_divisors from sage.misc.all import prod import ell_torsion from ell_generic import is_EllipticCurve from gp_simon import simon_two_descent from constructor import EllipticCurve from sage.rings.all import PolynomialRing, ZZ, QQ, RealField import sage.misc.misc from sage.misc.misc import verbose, forall from sage.rings.integer import Integer from sage.rings.arith import valuation import gal_reps_number_field class EllipticCurve_number_field(EllipticCurve_field): r""" Elliptic curve over a number field. EXAMPLES:: sage: K.<i>=NumberField(x^2+1) sage: EllipticCurve([i, i - 1, i + 1, 24*i + 15, 14*i + 35]) Elliptic Curve defined by y^2 + i*x*y + (i+1)*y = x^3 + (i-1)*x^2 + (24*i+15)*x + (14*i+35) over Number Field in i with defining polynomial x^2 + 1 """ def __init__(self, K, ainvs): r""" EXAMPLES: A curve from the database of curves over `\QQ`, but over a larger field: sage: K.<i>=NumberField(x^2+1) sage: EllipticCurve(K,'389a1') Elliptic Curve defined by y^2 + y = x^3 + x^2 + (-2)*x over Number Field in i with defining polynomial x^2 + 1 Making the field of definition explicitly larger:: sage: EllipticCurve(K,[0,-1,1,0,0]) Elliptic Curve defined by y^2 + y = x^3 + (-1)*x^2 over Number Field in i with defining polynomial x^2 + 1 """ self._known_points = [] EllipticCurve_field.__init__(self, K, ainvs) _point = ell_point.EllipticCurvePoint_number_field def base_extend(self, R): """ Return the base extension of ``self`` to `R`. EXAMPLES:: sage: E = EllipticCurve('11a3') sage: K = QuadraticField(-5, 'a') sage: E.base_extend(K) Elliptic Curve defined by y^2 + y = x^3 + (-1)*x^2 over Number Field in a with defining polynomial x^2 + 5 Check that non-torsion points are remembered when extending the base field (see :trac:`16034`):: sage: E = EllipticCurve([1, 0, 1, -1751, -31352]) sage: K.<d> = QuadraticField(5) sage: E.gens() [(52 : 111 : 1)] sage: EK = E.base_extend(K) sage: EK.gens() [(52 : 111 : 1)] """ E = super(EllipticCurve_number_field, self).base_extend(R) if isinstance(E, EllipticCurve_number_field): E._known_points = [E([R(_) for _ in P.xy()]) for P in self._known_points if not P.is_zero()] return E def simon_two_descent(self, verbose=0, lim1=2, lim3=4, limtriv=2, maxprob=20, limbigprime=30, known_points=None): r""" Return lower and upper bounds on the rank of the Mordell-Weil group `E(K)` and a list of points. This method is used internally by the :meth:`~rank`, :meth:`~rank_bounds` and :meth:`~gens` methods. INPUT: - ``self`` -- an elliptic curve `E` over a number field `K` - ``verbose`` -- 0, 1, 2, or 3 (default: 0), the verbosity level - ``lim1`` -- (default: 2) limit on trivial points on quartics - ``lim3`` -- (default: 4) limit on points on ELS quartics - ``limtriv`` -- (default: 2) limit on trivial points on `E` - ``maxprob`` -- (default: 20) - ``limbigprime`` -- (default: 30) to distinguish between small and large prime numbers. Use probabilistic tests for large primes. If 0, don't use probabilistic tests. - ``known_points`` -- (default: None) list of known points on the curve OUTPUT: a triple ``(lower, upper, list)`` consisting of - ``lower`` (integer) -- lower bound on the rank - ``upper`` (integer) -- upper bound on the rank - ``list`` -- list of points in `E(K)` The integer ``upper`` is in fact an upper bound on the dimension of the 2-Selmer group, hence on the dimension of `E(K)/2E(K)`. It is equal to the dimension of the 2-Selmer group except possibly if `E(K)[2]` has dimension 1. In that case, ``upper`` may exceed the dimension of the 2-Selmer group by an even number, due to the fact that the algorithm does not perform a second descent. .. note:: For non-quadratic number fields, this code does return, but it takes a long time. ALGORITHM: Uses <NAME>'s PARI/GP scripts from http://www.math.unicaen.fr/~simon/. EXAMPLES:: sage: K.<a> = NumberField(x^2 + 23, 'a') sage: E = EllipticCurve(K, '37') sage: E == loads(dumps(E)) True sage: E.simon_two_descent() (2, 2, [(0 : 0 : 1), (1/8*a + 5/8 : -3/16*a - 7/16 : 1)]) sage: E.simon_two_descent(lim1=3, lim3=20, limtriv=5, maxprob=7, limbigprime=10) (2, 2, [(-1 : 0 : 1), (-1/8*a + 5/8 : -3/16*a - 9/16 : 1)]) :: sage: K.<a> = NumberField(x^2 + 7, 'a') sage: E = EllipticCurve(K, [0,0,0,1,a]); E Elliptic Curve defined by y^2 = x^3 + x + a over Number Field in a with defining polynomial x^2 + 7 sage: v = E.simon_two_descent(verbose=1); v elliptic curve: Y^2 = x^3 + Mod(1, y^2 + 7)*x + Mod(y, y^2 + 7) Trivial points on the curve = [[1, 1, 0], [Mod(1/2*y + 3/2, y^2 + 7), Mod(-y - 2, y^2 + 7), 1]] #S(E/K)[2] = 2 #E(K)/2E(K) = 2 #III(E/K)[2] = 1 rank(E/K) = 1 listpoints = [[Mod(1/2*y + 3/2, y^2 + 7), Mod(-y - 2, y^2 + 7), 1]] (1, 1, [(1/2*a + 3/2 : -a - 2 : 1)]) sage: v = E.simon_two_descent(verbose=2) K = bnfinit(y^2 + 7); a = Mod(y,K.pol); bnfellrank(K, [0, 0, 0, 1, a], [[Mod(1/2*y + 3/2, y^2 + 7), Mod(-y - 2, y^2 + 7)]]); elliptic curve: Y^2 = x^3 + Mod(1, y^2 + 7)*x + Mod(y, y^2 + 7) A = Mod(0, y^2 + 7) B = Mod(1, y^2 + 7) C = Mod(y, y^2 + 7) <BLANKLINE> Computing L(S,2) L(S,2) = [Mod(Mod(-1, y^2 + 7)*x^2 + Mod(-1/2*y + 1/2, y^2 + 7)*x + 1, x^3 + Mod(1, y^2 + 7)*x + Mod(y, y^2 + 7)), Mod(Mod(-1, y^2 + 7)*x^2 + Mod(-1/2*y - 1/2, y^2 + 7)*x + 1, x^3 + Mod(1, y^2 + 7)*x + Mod(y, y^2 + 7)), Mod(-1, x^3 + Mod(1, y^2 + 7)*x + Mod(y, y^2 + 7)), Mod(x^2 + 2, x^3 + Mod(1, y^2 + 7)*x + Mod(y, y^2 + 7)), Mod(Mod(1, y^2 + 7)*x + Mod(1/2*y + 3/2, y^2 + 7), x^3 + Mod(1, y^2 + 7)*x + Mod(y, y^2 + 7)), Mod(Mod(1, y^2 + 7)*x + Mod(1/2*y - 3/2, y^2 +
new %s[pInStruct->%s];\n' % (m_name, m_type, self.struct_dict[s][m]['array_size']) #construct_txt += ' std::copy (pInStruct->%s, pInStruct->%s+pInStruct->%s, %s);\n' % (m_name, m_name, self.struct_dict[s][m]['array_size'], m_name) construct_txt += ' memcpy ((void *)%s, (void *)pInStruct->%s, sizeof(%s)*pInStruct->%s);\n' % (m_name, m_name, m_type, self.struct_dict[s][m]['array_size']) construct_txt += ' }\n' destruct_txt += ' if (%s)\n' % (m_name) destruct_txt += ' delete[] %s;\n' % (m_name) elif self.struct_dict[s][m]['array']: # Init array ptr to NULL init_list += '\n\t%s(NULL),' % (m_name) init_func_txt += ' %s = NULL;\n' % (m_name) array_element = 'pInStruct->%s[i]' % (m_name) if is_type(self.struct_dict[s][m]['type'], 'struct') and self._hasSafeStruct(self.struct_dict[s][m]['type']): array_element = '%s(&pInStruct->%s[i])' % (self._getSafeStructName(self.struct_dict[s][m]['type']), m_name) construct_txt += ' if (%s && pInStruct->%s) {\n' % (self.struct_dict[s][m]['array_size'], m_name) construct_txt += ' %s = new %s[%s];\n' % (m_name, m_type, self.struct_dict[s][m]['array_size']) destruct_txt += ' if (%s)\n' % (m_name) destruct_txt += ' delete[] %s;\n' % (m_name) construct_txt += ' for (uint32_t i=0; i<%s; ++i) {\n' % (self.struct_dict[s][m]['array_size']) if 'safe_' in m_type: construct_txt += ' %s[i].initialize(&pInStruct->%s[i]);\n' % (m_name, m_name) else: construct_txt += ' %s[i] = %s;\n' % (m_name, array_element) construct_txt += ' }\n' construct_txt += ' }\n' elif self.struct_dict[s][m]['ptr']: construct_txt += ' if (pInStruct->%s)\n' % (m_name) construct_txt += ' %s = new %s(pInStruct->%s);\n' % (m_name, m_type, m_name) construct_txt += ' else\n' construct_txt += ' %s = NULL;\n' % (m_name) destruct_txt += ' if (%s)\n' % (m_name) destruct_txt += ' delete %s;\n' % (m_name) elif 'safe_' in m_type: # inline struct, need to pass in reference for constructor init_list += '\n\t%s(&pInStruct->%s),' % (m_name, m_name) init_func_txt += ' %s.initialize(&pInStruct->%s);\n' % (m_name, m_name) else: init_list += '\n\t%s(pInStruct->%s),' % (m_name, m_name) init_func_txt += ' %s = pInStruct->%s;\n' % (m_name, m_name) if '' != init_list: init_list = init_list[:-1] # hack off final comma if s in custom_construct_txt: construct_txt = custom_construct_txt[s] ss_src.append("\n%s::%s(const %s* pInStruct) : %s\n{\n%s}" % (ss_name, ss_name, s, init_list, construct_txt)) ss_src.append("\n%s::%s() {}" % (ss_name, ss_name)) # Create slight variation of init and construct txt for copy constructor that takes a src object reference vs. struct ptr copy_construct_init = init_func_txt.replace('pInStruct->', 'src.') copy_construct_txt = construct_txt.replace(' (pInStruct->', ' (src.') # Exclude 'if' blocks from next line copy_construct_txt = copy_construct_txt.replace('(pInStruct->', '(*src.') # Pass object to copy constructors copy_construct_txt = copy_construct_txt.replace('pInStruct->', 'src.') # Modify remaining struct refs for src object ss_src.append("\n%s::%s(const %s& src)\n{\n%s%s}" % (ss_name, ss_name, ss_name, copy_construct_init, copy_construct_txt)) # Copy constructor ss_src.append("\n%s::~%s()\n{\n%s}" % (ss_name, ss_name, destruct_txt)) ss_src.append("\nvoid %s::initialize(const %s* pInStruct)\n{\n%s%s}" % (ss_name, s, init_func_txt, construct_txt)) # Copy initializer uses same txt as copy constructor but has a ptr and not a reference init_copy = copy_construct_init.replace('src.', 'src->') init_construct = copy_construct_txt.replace('src.', 'src->') ss_src.append("\nvoid %s::initialize(const %s* src)\n{\n%s%s}" % (ss_name, ss_name, init_copy, init_construct)) if s in ifdef_dict: ss_src.append('#endif') return "\n".join(ss_src) class EnumCodeGen: def __init__(self, enum_type_dict=None, enum_val_dict=None, typedef_fwd_dict=None, in_file=None, out_sh_file=None, out_vh_file=None): self.et_dict = enum_type_dict self.ev_dict = enum_val_dict self.tf_dict = typedef_fwd_dict self.in_file = in_file self.out_sh_file = out_sh_file self.eshfg = CommonFileGen(self.out_sh_file) self.out_vh_file = out_vh_file self.evhfg = CommonFileGen(self.out_vh_file) def generateStringHelper(self): self.eshfg.setHeader(self._generateSHHeader()) self.eshfg.setBody(self._generateSHBody()) self.eshfg.generate() def generateEnumValidate(self): self.evhfg.setHeader(self._generateSHHeader()) self.evhfg.setBody(self._generateVHBody()) self.evhfg.generate() def _generateVHBody(self): body = [] for bet in sorted(self.et_dict): fet = self.tf_dict[bet] body.append("static inline uint32_t validate_%s(%s input_value)\n{" % (fet, fet)) # TODO : This is not ideal, but allows for flag combinations. Need more rigorous validation of realistic flag combinations if 'flagbits' in bet.lower(): body.append(' if (input_value > (%s))' % (' | '.join(self.et_dict[bet]))) body.append(' return 0;') body.append(' return 1;') body.append('}\n\n') else: body.append(' switch ((%s)input_value)\n {' % (fet)) for e in sorted(self.et_dict[bet]): if (self.ev_dict[e]['unique']): body.append(' case %s:' % (e)) body.append(' return 1;\n default:\n return 0;\n }\n}\n\n') return "\n".join(body) def _generateSHBody(self): body = [] # with open(self.out_file, "a") as hf: # bet == base_enum_type, fet == final_enum_type for bet in sorted(self.et_dict): fet = self.tf_dict[bet] body.append("static inline const char* string_%s(%s input_value)\n{\n switch ((%s)input_value)\n {" % (fet, fet, fet)) for e in sorted(self.et_dict[bet]): if (self.ev_dict[e]['unique']): body.append(' case %s:\n return "%s";' % (e, e)) body.append(' default:\n return "Unhandled %s";\n }\n}\n\n' % (fet)) return "\n".join(body) def _generateSHHeader(self): header = [] header.append('#pragma once\n') header.append('#ifdef _WIN32\n') header.append('#pragma warning( disable : 4065 )\n') header.append('#endif\n') header.append('#include <vulkan/%s>\n\n\n' % self.in_file) return "\n".join(header) class CMakeGen: def __init__(self, struct_wrapper=None, out_dir=None): self.sw = struct_wrapper self.include_headers = [] self.add_lib_file_list = self.sw.get_file_list() self.out_dir = out_dir self.out_file = os.path.join(self.out_dir, "CMakeLists.txt") self.cmg = CommonFileGen(self.out_file) def generate(self): self.cmg.setBody(self._generateBody()) self.cmg.generate() def _generateBody(self): body = [] body.append("project(%s)" % os.path.basename(self.out_dir)) body.append("cmake_minimum_required(VERSION 2.8)\n") body.append("add_library(${PROJECT_NAME} %s)\n" % " ".join(self.add_lib_file_list)) body.append('set(COMPILE_FLAGS "-fpermissive")') body.append('set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMPILE_FLAGS}")\n') body.append("include_directories(${SRC_DIR}/thirdparty/${GEN_API}/inc/)\n") body.append("target_include_directories (%s PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})\n" % os.path.basename(self.out_dir)) return "\n".join(body) class GraphVizGen: def __init__(self, struct_dict, prefix, out_dir): self.struct_dict = struct_dict self.api = prefix if prefix == "vulkan": self.api_prefix = "vk" else: self.api_prefix = prefix self.out_file = os.path.join(out_dir, self.api_prefix+"_struct_graphviz_helper.h") self.gvg = CommonFileGen(self.out_file) def generate(self): self.gvg.setCopyright("//This is the copyright\n") self.gvg.setHeader(self._generateHeader()) self.gvg.setBody(self._generateBody()) #self.gvg.setFooter('}') self.gvg.generate() def set_include_headers(self, include_headers): self.include_headers = include_headers def _generateHeader(self): header = [] header.append("//#includes, #defines, globals and such...\n") for f in self.include_headers: if 'vk_enum_string_helper' not in f: header.append("#include <%s>\n" % f) #header.append('#include "vk_enum_string_helper.h"\n\n// Function Prototypes\n') header.append("\nchar* dynamic_gv_display(const void* pStruct, const char* prefix);\n") return "".join(header) def _get_gv_func_name(self, struct): return "%s_gv_print_%s" % (self.api_prefix, struct.lower().strip("_")) # Return elements to create formatted string for given struct member def _get_struct_gv_print_formatted(self, struct_member, pre_var_name="", postfix = "\\n", struct_var_name="pStruct", struct_ptr=True, print_array=False, port_label=""): struct_op = "->" pre_var_name = '"%s "' % struct_member['full_type'] if not struct_ptr: struct_op = "." member_name = struct_member['name'] print_type = "p" cast_type = "" member_post = "" array_index = "" member_print_post = "" print_delimiter = "%" if struct_member['array'] and 'char' in struct_member['type'].lower(): # just print char array as string print_type = "p" print_array = False elif struct_member['array'] and not print_array: # Just print base address of array when not full print_array cast_type = "(void*)" elif is_type(struct_member['type'], 'enum'): if struct_member['ptr']: struct_var_name = "*" + struct_var_name cast_type = "string_%s" % struct_member['type'] print_type = "s" elif is_type(struct_member['type'], 'struct'): # print struct address for now cast_type = "(void*)" if not struct_member['ptr']: cast_type = "(void*)&" elif 'bool' in struct_member['type'].lower(): print_type = "s" member_post = ' ? "TRUE" : "FALSE"' elif 'float' in struct_member['type']: print_type = "f" elif 'uint64' in struct_member['type'] or 'gpusize' in struct_member['type'].lower(): print_type = '" PRId64 "' elif 'uint8' in struct_member['type']: print_type = "hu" elif 'size' in struct_member['type'].lower(): print_type = '" PRINTF_SIZE_T_SPECIFIER "' print_delimiter = "" elif True in [ui_str.lower() in struct_member['type'].lower() for ui_str in ['uint', 'flags', 'samplemask']]: print_type = "u" elif 'int' in struct_member['type']: print_type = "i" elif struct_member['ptr']: pass else: #print("Unhandled struct type: %s" % struct_member['type']) cast_type = "(void*)" if print_array and struct_member['array']: member_print_post = "[%u]" array_index = " i," member_post = "[i]" print_out = "<TR><TD>%%s%s%s</TD><TD%s>%s%s%s</TD></TR>" % (member_name, member_print_post, port_label, print_delimiter, print_type, postfix) # section of print that goes inside of quotes print_arg = ", %s,%s %s(%s%s%s)%s\n" % (pre_var_name, array_index, cast_type, struct_var_name, struct_op, member_name, member_post) # section of print passed to portion in quotes return (print_out, print_arg) def _generateBody(self): gv_funcs = [] array_func_list = [] # structs for which we'll generate an array version of their print function array_func_list.append('vkbufferviewattachinfo') array_func_list.append('vkimageviewattachinfo') array_func_list.append('vksamplerimageviewinfo') array_func_list.append('vkdescriptortypecount') # For first pass, generate prototype for s in sorted(self.struct_dict): gv_funcs.append('char* %s(const %s* pStruct, const char* myNodeName);\n' % (self._get_gv_func_name(s), typedef_fwd_dict[s])) if s.lower().strip("_") in array_func_list: if s.lower().strip("_") in ['vkbufferviewattachinfo', 'vkimageviewattachinfo']: gv_funcs.append('char* %s_array(uint32_t count, const %s* const* pStruct, const char* myNodeName);\n' % (self._get_gv_func_name(s), typedef_fwd_dict[s])) else: gv_funcs.append('char* %s_array(uint32_t count, const %s* pStruct, const char* myNodeName);\n' % (self._get_gv_func_name(s), typedef_fwd_dict[s])) gv_funcs.append('\n') for s in sorted(self.struct_dict): p_out = "" p_args = "" stp_list = [] # stp == "struct to print" a list of structs for this API call that should be printed as structs # the fields below are a super-hacky way for now to get port labels into GV output, TODO : Clean this up! pl_dict = {} struct_num = 0 # This isn't great but this pre-pass flags structs w/ pNext and other struct ptrs for m in sorted(self.struct_dict[s]): if 'pNext' == self.struct_dict[s][m]['name'] or is_type(self.struct_dict[s][m]['type'], 'struct'): stp_list.append(self.struct_dict[s][m]) if 'pNext' == self.struct_dict[s][m]['name']: pl_dict[m] = ' PORT=\\"pNext\\"' else: pl_dict[m] = ' PORT=\\"struct%i\\"' % struct_num struct_num += 1 gv_funcs.append('char* %s(const %s* pStruct, const char* myNodeName)\n{\n char* str;\n' % (self._get_gv_func_name(s), typedef_fwd_dict[s])) num_stps = len(stp_list); total_strlen_str = '' if 0 != num_stps: gv_funcs.append(" char* tmpStr;\n") gv_funcs.append(" char nodeName[100];\n") gv_funcs.append(' char* stp_strs[%i];\n' % num_stps) for index in range(num_stps): if (stp_list[index]['ptr']): if
ignore_missing: warnings.warn( "[GDSPY] Cell {0} not found; operations on this CellArray may not work.".format( self.ref_cell ), stacklevel=2, ) def __str__(self): if isinstance(self.ref_cell, Cell): name = self.ref_cell.name else: name = self.ref_cell return 'CellArray ("{0}", {1} x {2}, at ({3[0]}, {3[1]}), spacing {4[0]} x {4[1]}, rotation {5}, magnification {6}, reflection {7})'.format( name, self.columns, self.rows, self.origin, self.spacing, self.rotation, self.magnification, self.x_reflection, ) def __repr__(self): if isinstance(self.ref_cell, Cell): name = self.ref_cell.name else: name = self.ref_cell return 'CellArray("{0}", {1}, {2}, ({4[0]}, {4[1]}), ({3[0]}, {3[1]}), {5}, {6}, {7})'.format( name, self.columns, self.rows, self.origin, self.spacing, self.rotation, self.magnification, self.x_reflection, ) def to_gds(self, multiplier): """ Convert this object to a GDSII element. Parameters ---------- multiplier : number A number that multiplies all dimensions written in the GDSII element. Returns ------- out : string The GDSII binary string that represents this object. """ name = self.ref_cell.name if len(name) % 2 != 0: name = name + "\0" data = struct.pack(">4H", 4, 0x0B00, 4 + len(name), 0x1206) + name.encode( "ascii" ) x2 = self.origin[0] + self.columns * self.spacing[0] y2 = self.origin[1] x3 = self.origin[0] y3 = self.origin[1] + self.rows * self.spacing[1] if ( (self.rotation is not None) or (self.magnification is not None) or self.x_reflection ): word = 0 values = b"" if self.x_reflection: word += 0x8000 y3 = 2 * self.origin[1] - y3 if not (self.magnification is None): # This flag indicates that the magnification is absolute, not # relative (not supported). # word += 0x0004 values += struct.pack(">2H", 12, 0x1B05) + _eight_byte_real( self.magnification ) if not (self.rotation is None): # This flag indicates that the rotation is absolute, not # relative (not supported). # word += 0x0002 sa = numpy.sin(self.rotation * numpy.pi / 180.0) ca = numpy.cos(self.rotation * numpy.pi / 180.0) tmp = ( (x2 - self.origin[0]) * ca - (y2 - self.origin[1]) * sa + self.origin[0] ) y2 = ( (x2 - self.origin[0]) * sa + (y2 - self.origin[1]) * ca + self.origin[1] ) x2 = tmp tmp = ( (x3 - self.origin[0]) * ca - (y3 - self.origin[1]) * sa + self.origin[0] ) y3 = ( (x3 - self.origin[0]) * sa + (y3 - self.origin[1]) * ca + self.origin[1] ) x3 = tmp values += struct.pack(">2H", 12, 0x1C05) + _eight_byte_real( self.rotation ) data += struct.pack(">3H", 6, 0x1A01, word) + values return data + struct.pack( ">2H2h2H6l2H", 8, 0x1302, self.columns, self.rows, 28, 0x1003, int(round(self.origin[0] * multiplier)), int(round(self.origin[1] * multiplier)), int(round(x2 * multiplier)), int(round(y2 * multiplier)), int(round(x3 * multiplier)), int(round(y3 * multiplier)), 4, 0x1100, ) def area(self, by_spec=False): """ Calculate the total area of the cell array with the magnification factor included. Parameters ---------- by_spec : bool If True, the return value is a dictionary with the areas of each individual pair (layer, datatype). Returns ------- out : number, dictionary Area of this cell. """ if not isinstance(self.ref_cell, Cell): return dict() if by_spec else 0 if self.magnification is None: factor = self.columns * self.rows else: factor = self.columns * self.rows * self.magnification ** 2 if by_spec: cell_area = self.ref_cell.area(True) for kk in cell_area.keys(): cell_area[kk] *= factor return cell_area else: return self.ref_cell.area() * factor def get_polygons(self, by_spec=False, depth=None): """ Return the list of polygons created by this reference. Parameters ---------- by_spec : bool If True, the return value is a dictionary with the polygons of each individual pair (layer, datatype). depth : integer or None If not None, defines from how many reference levels to retrieve polygons. References below this level will result in a bounding box. If `by_spec` is True the key will be name of the referenced cell. Returns ------- out : list of array-like[N][2] or dictionary List containing the coordinates of the vertices of each polygon, or dictionary with the list of polygons (if `by_spec` is True). Note ---- Instances of `FlexPath` and `RobustPath` are also included in the result by computing their polygonal boundary. """ if not isinstance(self.ref_cell, Cell): return dict() if by_spec else [] if self.rotation is not None: ct = numpy.cos(self.rotation * numpy.pi / 180.0) st = numpy.sin(self.rotation * numpy.pi / 180.0) * _mpone if self.magnification is not None: mag = self.magnification * _one if self.origin is not None: orgn = numpy.array(self.origin) if self.x_reflection: xrefl = _pmone_int if by_spec: cell_polygons = self.ref_cell.get_polygons(True, depth) polygons = {} for kk in cell_polygons.keys(): polygons[kk] = [] for ii in range(self.columns): for jj in range(self.rows): spc = numpy.array([self.spacing[0] * ii, self.spacing[1] * jj]) for points in cell_polygons[kk]: if self.magnification: polygons[kk].append(points * mag + spc) else: polygons[kk].append(points + spc) if self.x_reflection: polygons[kk][-1] = polygons[kk][-1] * xrefl if self.rotation is not None: polygons[kk][-1] = ( polygons[kk][-1] * ct + polygons[kk][-1][:, ::-1] * st ) if self.origin is not None: polygons[kk][-1] = polygons[kk][-1] + orgn else: cell_polygons = self.ref_cell.get_polygons(depth=depth) polygons = [] for ii in range(self.columns): for jj in range(self.rows): spc = numpy.array([self.spacing[0] * ii, self.spacing[1] * jj]) for points in cell_polygons: if self.magnification is not None: polygons.append(points * mag + spc) else: polygons.append(points + spc) if self.x_reflection: polygons[-1] = polygons[-1] * xrefl if self.rotation is not None: polygons[-1] = ( polygons[-1] * ct + polygons[-1][:, ::-1] * st ) if self.origin is not None: polygons[-1] = polygons[-1] + orgn return polygons def get_polygonsets(self, depth=None): """ Return the list of polygons created by this reference. Parameters ---------- depth : integer or None If not None, defines from how many reference levels to retrieve polygons from. Returns ------- out : list of `PolygonSet` List containing the polygons in this cell and its references. """ if not isinstance(self.ref_cell, Cell): return [] if self.rotation is not None: ct = numpy.cos(self.rotation * numpy.pi / 180.0) st = numpy.sin(self.rotation * numpy.pi / 180.0) * _mpone if self.x_reflection: xrefl = _pmone_int if self.magnification is not None: mag = self.magnification * _one if self.origin is not None: orgn = numpy.array(self.origin) polygonsets = self.ref_cell.get_polygonsets(depth=depth) array = [] for i in range(self.columns): for j in range(self.rows): spc = numpy.array([self.spacing[0] * i, self.spacing[1] * j]) for polygonset in polygonsets: ps = libcopy.deepcopy(polygonset) for ii in range(len(ps.polygons)): if self.magnification is not None: ps.polygons[ii] = ps.polygons[ii] * mag + spc else: ps.polygons[ii] = ps.polygons[ii] + spc if self.x_reflection: ps.polygons[ii] = ps.polygons[ii] * xrefl if self.rotation is not None: ps.polygons[ii] = ( ps.polygons[ii] * ct + ps.polygons[ii][:, ::-1] * st ) if self.origin is not None: ps.polygons[ii] = ps.polygons[ii] + orgn array.append(ps) return array def get_paths(self, depth=None): """ Return the list of paths created by this reference. Parameters ---------- depth : integer or None If not None, defines from how many reference levels to retrieve paths from. Returns ------- out : list of `FlexPath` or `RobustPath` List containing the paths in this cell and its references. """ if not isinstance(self.ref_cell, Cell): return [] if self.origin is not None: trans = numpy.array(self.origin) else: trans = None if self.rotation is not None: rot = self.rotation * numpy.pi / 180.0 else: rot = None paths = self.ref_cell.get_paths(depth=depth) array = [] for i in range(self.columns): for j in range(self.rows): spc = numpy.array([self.spacing[0] * i, self.spacing[1] * j]) for path in paths: array.append( libcopy.deepcopy(path).transform( trans, rot, self.magnification, self.x_reflection, spc ) ) return array def get_labels(self, depth=None): """ Return the list of labels created by this reference. Parameters ---------- depth : integer or None If not None, defines from how many reference levels to retrieve labels from. Returns ------- out : list of `Label` List containing the labels in this cell and its references. """ if not isinstance(self.ref_cell, Cell): return [] if self.rotation is not None: ct = numpy.cos(self.rotation * numpy.pi / 180.0) st = numpy.sin(self.rotation * numpy.pi / 180.0) * _mpone if self.magnification is not None: mag = self.magnification * _one if self.origin is not None: orgn = numpy.array(self.origin) if self.x_reflection: xrefl = _pmone_int cell_labels = self.ref_cell.get_labels(depth=depth) labels = [] for ii in range(self.columns): for jj in range(self.rows): spc = numpy.array([self.spacing[0] * ii, self.spacing[1] * jj]) for clbl in cell_labels: lbl = libcopy.deepcopy(clbl)
the hw config 'rngi' and 'rngw' in " + str(self) + " class can't adopt temporal coding simultaneously." assert self.hwcfg["quantilei"] > 0 and self.hwcfg["quantilei"] <= 1, \ "Error: the hw config 'quantilei' of " + str(self) + " class needs to be within (0, 1]." assert self.hwcfg["quantilew"] > 0 and self.hwcfg["quantilew"] <= 1, \ "Error: the hw config 'quantilew' of " + str(self) + " class needs to be within (0, 1]." assert self.hwcfg["rounding"] in ["round", "ceil", "floor"], \ "Error: the hw config 'rounding' of " + str(self) + " class requires one of ['round', 'ceil', 'floor']." assert self.hwcfg["signmag"] is True, \ "Error: the hw config 'signmag' of " + str(self) + " class requires to be True, i.e., always computing on sign-magnitue data, for diverse architectures." # maximum possible run cycle self.cycle_max = 2**(max(hwcfg["widthi"], hwcfg["widthw"]) - hwcfg["signmag"]) # actual run cycle if self.hwcfg["cycle"] is None: self.cycle_act = self.cycle_max else: self.cycle_act = min(self.hwcfg["cycle"], self.cycle_max) self.hwcfg["cycle"] = self.cycle_act # weight and bias if weight_ext is not None: assert (weight_ext.size()[0], weight_ext.size()[1]) == (out_features, in_features), \ "Error: the hw config 'out_features, in_features' in " + str(self) + " class unmatches the binary weight shape." self.weight.data = weight_ext if bias and (bias_ext is not None): assert bias_ext.size()[0] == out_features, \ "Error: the hw config 'out_features' in " + str(self) + " class unmatches the binary bias shape." self.bias.data = bias_ext swcfg={ "btype" : torch.float, "rtype" : torch.float, "stype" : torch.float } # random_sequence from RNG hwcfg_irng = { "width" : self.hwcfg["widthi"] - self.hwcfg["signmag"], "dimr" : 1, "rng" : self.hwcfg["rngi"] } self.irng = RNG(hwcfg_irng, swcfg)() hwcfg_wrng = { "width" : self.hwcfg["widthw"] - self.hwcfg["signmag"], "dimr" : 1, "rng" : self.hwcfg["rngw"] } self.wrng = RNG(hwcfg_wrng, swcfg)() if (self.itc) and (not self.wtc): # cbsg controller is input self.rngctler = self.irng self.rngctlee = self.wrng elif (not self.itc) and (self.wtc): # cbsg controller is weight self.rngctler = self.wrng self.rngctlee = self.irng elif (not self.itc) and (not self.wtc): # when rate coding is applied to both input and weight, always control weight with input # the hardware cost of doing this is similar to the opposite self.rngctler = self.irng self.rngctlee = self.wrng # generate the value map for mul using current rng # dim 0 is input index # the tensor input value is the actual value produced by the rngctler self.mapctler = torch.nn.Parameter(torch.empty(self.cycle_max), requires_grad=False) cycle_ctlerval = torch.empty(0) torch.cat(self.cycle_max*[torch.arange(self.cycle_max, dtype=torch.float).unsqueeze(1)], 1, out=cycle_ctlerval) cycle_ctlerbit = torch.empty(0) torch.gt(cycle_ctlerval, self.rngctler.unsqueeze(0), out=cycle_ctlerbit) self.mapctler.data = torch.sum(cycle_ctlerbit, 1).squeeze_().type(torch.long) # dim 0 is input index, dim 1 is weight index # the tensor value is the actual weight value produced by the rngctlee, under a specific input and weight self.mapctlee = torch.nn.Parameter(torch.empty(self.cycle_max, self.cycle_max), requires_grad=False) cycle_ctleebit = torch.empty(0) torch.gt(cycle_ctlerval, self.rngctlee.unsqueeze(0), out=cycle_ctleebit) for c in range(self.cycle_max): self.mapctlee.data[c] = torch.sum(cycle_ctleebit[:, 0:self.mapctler.data[c]], 1).squeeze_() self.rshift_i = None self.rshift_w = None self.rshift_o = None @autocast() def forward(self, input): # See the autograd section for explanation of what happens here. self.rshift_i, self.rshift_w, self.rshift_o = \ rshift_offset(input, self.weight, self.hwcfg["widthi"] - self.hwcfg["signmag"], self.hwcfg["widthw"] - self.hwcfg["signmag"], self.hwcfg["rounding"], self.hwcfg["quantilei"], self.hwcfg["quantilew"]) return HUBLinearFunction.apply(input, self.weight, self.bias, self.rshift_i, self.rshift_w, self.rshift_o, self.cycle_act, self.mapctlee) # Inherit from Function class HUBLinearFunction(torch.autograd.Function): """ This code is for rate coding for both input and weight. """ # Note that both forward and backward are @staticmethods @staticmethod # bias is an optional argument def forward(ctx, input, weight, bias=None, rshift_i=3, rshift_w=3, rshift_o=3, cycle=128, mapcbsg=None): ctx.save_for_backward(input, weight, bias) assert len(input.size()) == 2, \ "Error: the input of HUBLinearFunction class needs 2 dimensions." # first dim should always be batch batch = input.size()[0] # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # input preparation # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # scale input to range 0~2^widthi-1 buf_i = torch.empty(0, dtype=torch.long, device=input.device) torch.abs((input >> rshift_i).unsqueeze_(1).round().type(torch.long), out=buf_i) torch.clamp(buf_i, 0, cycle-1, out=buf_i) # actual input: its sign act_input = torch.empty(0, device=input.device) torch.sign(input, out=act_input) act_input.unsqueeze_(1) # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # weight preparation # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # scale weight with batch to range 0~2^widthw-1 buf_w_no_batch = torch.empty(0, dtype=torch.long, device=weight.device) torch.abs((weight >> rshift_w).unsqueeze_(0).round().type(torch.long), out=buf_w_no_batch) torch.clamp(buf_w_no_batch, 0, cycle-1, out=buf_w_no_batch) buf_w = torch.empty(0, dtype=torch.long, device=weight.device) torch.cat(batch*[buf_w_no_batch], 0, out=buf_w) # get actual weight for calculation sign_wght_no_batch = torch.empty(0, device=weight.device) torch.sign(weight, out=sign_wght_no_batch) sign_wght_no_batch.unsqueeze_(0) act_wght = torch.empty(0, device=weight.device) torch.cat(batch*[sign_wght_no_batch], 0, out=act_wght) torch.mul(mapcbsg[buf_i, buf_w], act_wght, out=act_wght) output = torch.empty(0, device=weight.device) torch.matmul(act_input, act_wght.transpose(1, 2), out=output) output = (output >> rshift_o).squeeze_(1) if bias is not None: output += bias.unsqueeze(0).expand_as(output) return output # This function has only a single output, so it gets only one gradient @staticmethod def backward(ctx, grad_output): # This is a pattern that is very convenient - at the top of backward # unpack saved_tensors and initialize all gradients w.r.t. inputs to # None. Thanks to the fact that additional trailing Nones are # ignored, the return statement is simple even when the function has # optional inputs. input, weight, bias = ctx.saved_tensors grad_input = grad_weight = grad_bias = None # These needs_input_grad checks are optional and there only to # improve efficiency. If you want to make your code simpler, you can # skip them. Returning gradients for inputs that don't require it is # not an error. if ctx.needs_input_grad[0]: grad_input = grad_output.matmul(weight) if ctx.needs_input_grad[1]: grad_weight = grad_output.t().matmul(input) if bias is not None and ctx.needs_input_grad[2]: grad_bias = grad_output.sum(0) return grad_input, grad_weight, grad_bias, None, None, None, None, None class FXPLinear(torch.nn.Linear): """ This module is the fully connected layer for binary signed data in fxp format using binary computing. The hardware configuration specifies 1) the data with in bit for input and weight/bias 2) the quantile to quantize input and weight/bias 3) the rounding mode for both input and weight/bias """ def __init__( self, in_features, out_features, bias=True, weight_ext=None, bias_ext=None, hwcfg={ "widthi" : 8, "quantilei" : 1, "widthw" : 8, "quantilew" : 1, "rounding" : "round" }): super(FXPLinear, self).__init__(in_features, out_features, bias) self.hwcfg = {} self.hwcfg["widthi"] = hwcfg["widthi"] self.hwcfg["quantilei"] = hwcfg["quantilei"] self.hwcfg["widthw"] = hwcfg["widthw"] self.hwcfg["quantilew"] = hwcfg["quantilew"] self.hwcfg["rounding"] = hwcfg["rounding"].lower() # weight and bias if weight_ext is not None: assert (weight_ext.size()[0], weight_ext.size()[1]) == (out_features, in_features), \ "Error: the hw config 'out_features, in_features' in " + str(self) + " class unmatches the binary weight shape." self.weight.data = weight_ext if bias and (bias_ext is not None): assert bias_ext.size()[0] == out_features, \ "Error: the hw config 'out_features' in " + str(self) + " class unmatches the binary bias shape." self.bias.data = bias_ext # max abs value self.max_abs_i = 2**self.hwcfg["widthi"] self.max_abs_w = 2**self.hwcfg["widthw"] self.rshift_i = None self.rshift_w = None self.rshift_o = None @autocast() def forward(self, input): # See the autograd section for explanation of what happens here. self.rshift_i, self.rshift_w, _ = \ rshift_offset(input, self.weight, self.hwcfg["widthi"] - 1, self.hwcfg["widthw"] - 1, self.hwcfg["rounding"], self.hwcfg["quantilei"], self.hwcfg["quantilew"]) self.rshift_o = 0 - self.rshift_i - self.rshift_w return FXPLinearFunction.apply(input, self.weight, self.bias, self.rshift_i, self.rshift_w, self.rshift_o, self.max_abs_i, self.max_abs_w) # Inherit from Function class FXPLinearFunction(torch.autograd.Function): # Note that both forward and backward are @staticmethods @staticmethod # bias is an optional argument def forward(ctx, input, weight, bias=None, rshift_i=3, rshift_w=3, rshift_o=3, max_abs_i=128, max_abs_w=128): ctx.save_for_backward(input, weight, bias) # # # # # # #
<reponame>YileC928/finm-portfolio-2021 """ Mean models to use with ARCH processes. All mean models must inherit from :class:`ARCHModel` and provide the same methods with the same inputs. """ from __future__ import annotations import copy import sys from typing import ( TYPE_CHECKING, Any, Callable, Dict, List, Mapping, Optional, Sequence, Tuple, Union, cast, ) import numpy as np from pandas import DataFrame, Index from scipy.optimize import OptimizeResult from statsmodels.tsa.tsatools import lagmat from arch.__future__._utility import check_reindex from arch.typing import ArrayLike, ArrayLike1D, DateLike, Label, NDArray from arch.univariate.base import ( ARCHModel, ARCHModelForecast, ARCHModelResult, implicit_constant, ) from arch.univariate.distribution import ( Distribution, GeneralizedError, Normal, SkewStudent, StudentsT, ) from arch.univariate.volatility import ( ARCH, EGARCH, FIGARCH, GARCH, HARCH, ConstantVariance, VolatilityProcess, ) from arch.utility.array import ( AbstractDocStringInheritor, cutoff_to_index, ensure1d, parse_dataframe, ) from arch.vendor import cached_property if sys.version_info >= (3, 8): from typing import Literal elif TYPE_CHECKING: from typing_extensions import Literal __all__ = ["HARX", "ConstantMean", "ZeroMean", "ARX", "arch_model", "LS"] COV_TYPES = { "white": "White's Heteroskedasticity Consistent Estimator", "classic_ols": "Homoskedastic (Classic)", "robust": "Bollerslev-Wooldridge (Robust) Estimator", "mle": "ML Estimator", "classic": "ML Estimator", } def _forecast_pad(count: int, forecasts: NDArray) -> NDArray: shape = list(forecasts.shape) shape[0] = count fill = np.full(tuple(shape), np.nan) return np.concatenate((fill, forecasts)) def _ar_forecast( y: NDArray, horizon: int, start_index: int, constant: float, arp: NDArray, x: NDArray, exogp: NDArray, ) -> NDArray: """ Generate mean forecasts from an AR-X model Parameters ---------- y : ndarray horizon : int start_index : int constant : float arp : ndarray exogp : ndarray x : ndarray Returns ------- forecasts : ndarray """ t = y.shape[0] p = arp.shape[0] fcasts = np.empty((t - start_index, p + horizon)) for i in range(p): first = start_index - p + i + 1 last = t - p + i + 1 fcasts[:, i] = y[first:last] arp_rev = arp[::-1] for i in range(p, horizon + p): fcasts[:, i] = constant + fcasts[:, i - p : i].dot(arp_rev) if x.shape[0] > 0: fcasts[:, i] += x[:, :, i - p].T @ exogp fcasts = fcasts[:, p:] return fcasts def _ar_to_impulse(steps: int, params: NDArray) -> NDArray: p = params.shape[0] impulse = np.zeros(steps) impulse[0] = 1 if p == 0: return impulse for i in range(1, steps): k = min(p - 1, i - 1) st = max(i - p, 0) impulse[i] = impulse[st:i].dot(params[k::-1]) return impulse class HARX(ARCHModel, metaclass=AbstractDocStringInheritor): r""" Heterogeneous Autoregression (HAR), with optional exogenous regressors, model estimation and simulation Parameters ---------- y : {ndarray, Series} nobs element vector containing the dependent variable x : {ndarray, DataFrame}, optional nobs by k element array containing exogenous regressors lags : {scalar, ndarray}, optional Description of lag structure of the HAR. * Scalar included all lags between 1 and the value. * A 1-d n-element array includes the HAR lags 1:lags[0]+1, 1:lags[1]+1, ... 1:lags[n]+1. * A 2-d (2,n)-element array that includes the HAR lags of the form lags[0,j]:lags[1,j]+1 for all columns of lags. constant : bool, optional Flag whether the model should include a constant use_rotated : bool, optional Flag indicating to use the alternative rotated form of the HAR where HAR lags do not overlap hold_back : int Number of observations at the start of the sample to exclude when estimating model parameters. Used when comparing models with different lag lengths to estimate on the common sample. volatility : VolatilityProcess, optional Volatility process to use in the model distribution : Distribution, optional Error distribution to use in the model rescale : bool, optional Flag indicating whether to automatically rescale data if the scale of the data is likely to produce convergence issues when estimating model parameters. If False, the model is estimated on the data without transformation. If True, than y is rescaled and the new scale is reported in the estimation results. Examples -------- Standard HAR with average lags 1, 5 and 22 >>> import numpy as np >>> from arch.univariate import HARX >>> y = np.random.RandomState(1234).randn(100) >>> harx = HARX(y, lags=[1, 5, 22]) >>> res = harx.fit() A standard HAR with average lags 1 and 6 but holding back 10 observations >>> from pandas import Series, date_range >>> index = date_range('2000-01-01', freq='M', periods=y.shape[0]) >>> y = Series(y, name='y', index=index) >>> har = HARX(y, lags=[1, 6], hold_back=10) Models with equivalent parametrizations of lags. The first uses overlapping lags. >>> harx_1 = HARX(y, lags=[1,5,22]) The next uses rotated lags so that they do not overlap. >>> harx_2 = HARX(y, lags=[1,5,22], use_rotated=True) The third manually specified overlapping lags. >>> harx_3 = HARX(y, lags=[[1, 1, 1], [1, 5, 22]]) The final manually specified non-overlapping lags >>> harx_4 = HARX(y, lags=[[1, 2, 6], [1, 5, 22]]) It is simple to verify that these are the equivalent by inspecting the R2. >>> models = [harx_1, harx_2, harx_3, harx_4] >>> print([mod.fit().rsquared for mod in models]) 0.085, 0.085, 0.085, 0.085 Notes ----- The HAR-X model is described by .. math:: y_t = \mu + \sum_{i=1}^p \phi_{L_{i}} \bar{y}_{t-L_{i,0}:L_{i,1}} + \gamma' x_t + \epsilon_t where :math:`\bar{y}_{t-L_{i,0}:L_{i,1}}` is the average value of :math:`y_t` between :math:`t-L_{i,0}` and :math:`t - L_{i,1}`. """ def __init__( self, y: Optional[ArrayLike] = None, x: Optional[ArrayLike] = None, lags: Optional[ Union[int, Sequence[int], Sequence[Sequence[int]], NDArray] ] = None, constant: bool = True, use_rotated: bool = False, hold_back: Optional[int] = None, volatility: Optional[VolatilityProcess] = None, distribution: Optional[Distribution] = None, rescale: Optional[bool] = None, ) -> None: super().__init__( y, hold_back=hold_back, volatility=volatility, distribution=distribution, rescale=rescale, ) self._x = x self._x_names: List[str] = [] self._x_index: Optional[Union[NDArray, Index]] = None self.lags: Optional[ Union[int, Sequence[int], Sequence[Sequence[int]], NDArray] ] = lags self._lags = np.empty(0) self.constant: bool = constant self.use_rotated: bool = use_rotated self.regressors: np.ndarray[Any, np.dtype[np.float64]] = np.empty( (0, 0), dtype=np.float64 ) self._name = "HAR" if self._x is not None: self._name += "-X" if lags is not None: max_lags = int(np.max(np.asarray(lags, dtype=np.int32))) else: max_lags = 0 self._max_lags = max_lags self._hold_back = max_lags if hold_back is None else hold_back if self._hold_back < max_lags: from warnings import warn warn( "hold_back is less then the minimum number given the lags selected", RuntimeWarning, ) self._hold_back = max_lags self._init_model() @property def x(self) -> ArrayLike: """Gets the value of the exogenous regressors in the model""" return self._x def parameter_names(self) -> List[str]: return self._generate_variable_names() def _model_description(self, include_lags: bool = True) -> Dict[str, str]: """Generates the model description for use by __str__ and related functions""" lagstr = "none" if include_lags and self.lags is not None: assert self._lags is not None lagstr_comp = [f"[{lag[0]}:{lag[1]}]" for lag in self._lags.T] lagstr = ", ".join(lagstr_comp) xstr = str(self._x.shape[1]) if self._x is not None else "0" conststr = "yes" if self.constant else "no" od = {"constant": conststr} if include_lags: od["lags"] = lagstr od["no. of exog"] = xstr od["volatility"] = self.volatility.__str__() od["distribution"] = self.distribution.__str__() return od def __str__(self) -> str: descr = self._model_description() descr_str = self.name + "(" for key, val in descr.items(): if val and key: descr_str += key + ": " + val + ", " descr_str = descr_str[:-2] # Strip final ', ' descr_str += ")" return descr_str def __repr__(self) -> str: txt = self.__str__() txt.replace("\n", "") return txt + ", id: " + hex(id(self)) def _repr_html_(self) -> str: """HTML representation for IPython Notebook""" descr = self._model_description() html = "<strong>" + self.name + "</strong>(" for key, val in descr.items(): html += "<strong>" + key + ": </strong>" + val + ",\n" html += "<strong>ID: </strong> " + hex(id(self)) + ")" return html def resids( self, params: NDArray, y: Optional[ArrayLike] = None, regressors: Optional[ArrayLike] = None, ) -> ArrayLike: regressors = self._fit_regressors if y is None else regressors y = self._fit_y if y is None else y assert regressors is not None return y - regressors.dot(params) @cached_property def num_params(self) -> int: """ Returns the number of parameters """ assert self.regressors is not None return int(self.regressors.shape[1]) def simulate( self, params: Union[NDArray, Sequence[float]], nobs: int, burn: int = 500, initial_value: Optional[Union[float, NDArray]] = None, x: Optional[ArrayLike] = None, initial_value_vol: Optional[Union[float, NDArray]] = None, ) -> DataFrame: """ Simulates data from a linear regression, AR or HAR models Parameters ---------- params : ndarray Parameters to use when simulating the model. Parameter order is [mean volatility distribution] where the parameters of the
# Copyright 2021 Internet Corporation for Assigned Names and Numbers. # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, you can obtain one at https://mozilla.org/MPL/2.0/. # # Developed by Sinodun IT (sinodun.com) # # Aggregation RSSAC plots import textwrap import grafanalib.core as GCore import grafanacommon as GCommon def dash(myuid, agginfo, nodesel, **kwargs): return GCommon.Dashboard( title = "RSSAC Reporting", tags = [ agginfo['graph_tag'] ], uid = myuid, rows = [ GCore.Row( panels = [ GCommon.QPMGraph( title = 'RCODE volume', targets = [ GCommon.ClickHouseTarget( database = agginfo['database'], table = 'Responses' + agginfo['table_suffix'], round = agginfo['round'], query = textwrap.dedent("""\ SELECT t, groupArray((ResponseRcode, qc)) FROM ( SELECT t,ResponseRcode,60*cnt/{interval_divisor} AS qc FROM ( SELECT $timeSeries AS t, ResponseRcodeMap.ResponseRcode AS ResponseRcode, sum(toUInt64(ResponseRcodeMap.Count)) AS cnt FROM $table ARRAY JOIN ResponseRcodeMap WHERE $timeFilter AND NodeID IN {nodesel} GROUP BY t, ResponseRcode ORDER BY t, ResponseRcode ) GROUP BY t, ResponseRcode, cnt ORDER BY t, ResponseRcode ) GROUP BY t ORDER BY t""".format( interval_divisor=agginfo['interval_divisor'], nodesel=nodesel)), refId = 'A' ), ], ), ], ), GCore.Row( panels = [ GCommon.BarChart( title = 'DNS UDP Query size for sizes below 1000 bytes', layout = GCommon.BarChartLayout( barmode = GCommon.BAR_CHART_LAYOUT_MODE_STACK, showlegend = False, xaxis = GCommon.BarChartAxis( autotick = False, axtype = GCommon.BAR_CHART_AXIS_TYPE_LINEAR, axrange = [0, 1000], tick0 = 16, dtick = 16, tickangle = -45, tickmargin = 40, title = 'Message size (bytes)', ), yaxis = GCommon.BarChartAxis( axtype = GCommon.BAR_CHART_AXIS_TYPE_LINEAR, dtick = 16, rangemode = GCommon.BAR_CHART_AXIS_RANGEMODE_TOZERO, title = 'Messages per minute', ), ), traces = [ GCommon.BarChartTrace( name = 'UDP Query', color = '#1F60C4', x = 'UDPQueryLen', y = 'UDPQueryCnt', text = 'UDPQueryCnt', ), ], targets = [ GCommon.ClickHouseTableTarget( database = agginfo['database'], table = 'QueryResponseLength' + agginfo['table_suffix'], round = agginfo['round'], query = textwrap.dedent("""\ SELECT Len + intDiv({bucketsize}, 2) AS UDPQueryLen, 60 * sum(Cnt)/($to - $from) AS UDPQueryCnt FROM ( SELECT intDiv(QueryLengthMap.Length, {bucketsize})*{bucketsize} AS Len, sum(toUInt64(QueryLengthMap.Count)) AS Cnt FROM $table ARRAY JOIN QueryLengthMap WHERE $timeFilter AND TransportTCP=0 AND NodeID IN {nodesel} AND Len < 1000 GROUP BY Len UNION ALL ( SELECT CAST(number*{bucketsize} AS UInt16) AS Len, CAST(0 AS UInt64) AS Cnt FROM system.numbers WHERE number > 0 LIMIT {bucketlen} ) ) GROUP BY Len""".format( nodesel=nodesel, bucketsize=16, bucketlen=1000//16)), refId = 'A' ), ], ), ], ), GCore.Row( panels = [ GCommon.BarChart( title = 'DNS TCP Query size for sizes below 1000 bytes', layout = GCommon.BarChartLayout( barmode = GCommon.BAR_CHART_LAYOUT_MODE_STACK, showlegend = False, xaxis = GCommon.BarChartAxis( autotick = False, axtype = GCommon.BAR_CHART_AXIS_TYPE_LINEAR, axrange = [0, 1000], tick0 = 16, dtick = 16, tickangle = -45, tickmargin = 40, title = 'Message size (bytes)', ), yaxis = GCommon.BarChartAxis( axtype = GCommon.BAR_CHART_AXIS_TYPE_LINEAR, dtick = 16, rangemode = GCommon.BAR_CHART_AXIS_RANGEMODE_TOZERO, title = 'Messages per minute', ), ), traces = [ GCommon.BarChartTrace( name = 'TCP Query', color = '#1F60C4', x = 'TCPQueryLen', y = 'TCPQueryCnt', text = 'TCPQueryCnt', ), ], targets = [ GCommon.ClickHouseTableTarget( database = agginfo['database'], table = 'QueryResponseLength' + agginfo['table_suffix'], round = agginfo['round'], query = textwrap.dedent("""\ SELECT Len + intDiv({bucketsize}, 2) AS TCPQueryLen, 60 * sum(Cnt)/($to - $from) AS TCPQueryCnt FROM ( SELECT intDiv(QueryLengthMap.Length, {bucketsize})*{bucketsize} AS Len, sum(toUInt64(QueryLengthMap.Count)) AS Cnt FROM $table ARRAY JOIN QueryLengthMap WHERE $timeFilter AND TransportTCP=1 AND NodeID IN {nodesel} AND Len < 1000 GROUP BY Len UNION ALL ( SELECT CAST(number*{bucketsize} AS UInt16) AS Len, CAST(0 AS UInt64) AS Cnt FROM system.numbers WHERE number > 0 LIMIT {bucketlen} ) ) GROUP BY Len""".format( nodesel=nodesel, bucketsize=16, bucketlen=1000//16)), refId = 'A' ), ], ), ], ), GCore.Row( panels = [ GCommon.BarChart( title = 'DNS UDP Response size for sizes below 1000 bytes', layout = GCommon.BarChartLayout( barmode = GCommon.BAR_CHART_LAYOUT_MODE_STACK, showlegend = False, xaxis = GCommon.BarChartAxis( autotick = False, axtype = GCommon.BAR_CHART_AXIS_TYPE_LINEAR, axrange = [0, 1000], tick0 = 16, dtick = 16, tickangle = -45, tickmargin = 40, title = 'Message size (bytes)', ), yaxis = GCommon.BarChartAxis( axtype = GCommon.BAR_CHART_AXIS_TYPE_LINEAR, dtick = 16, rangemode = GCommon.BAR_CHART_AXIS_RANGEMODE_TOZERO, title = 'Messages per minute', ), ), traces = [ GCommon.BarChartTrace( name = 'UDP Response', color = '#1F60C4', x = 'UDPResponseLen', y = 'UDPResponseCnt', text = 'UDPResponseCnt', ), ], targets = [ GCommon.ClickHouseTableTarget( database = agginfo['database'], table = 'QueryResponseLength' + agginfo['table_suffix'], round = agginfo['round'], query = textwrap.dedent("""\ SELECT Len + intDiv({bucketsize}, 2) AS UDPResponseLen, 60 * sum(Cnt)/($to - $from) AS UDPResponseCnt FROM ( SELECT intDiv(ResponseLengthMap.Length, {bucketsize})*{bucketsize} AS Len, sum(toUInt64(ResponseLengthMap.Count)) AS Cnt FROM $table ARRAY JOIN ResponseLengthMap WHERE $timeFilter AND TransportTCP=0 AND NodeID IN {nodesel} AND Len < 1000 GROUP BY Len UNION ALL ( SELECT CAST(number*{bucketsize} AS UInt16) AS Len, CAST(0 AS UInt64) AS Cnt FROM system.numbers WHERE number > 0 LIMIT {bucketlen} ) ) GROUP BY Len""".format( nodesel=nodesel, bucketsize=16, bucketlen=1000//16)), refId = 'A' ), ], ), ], ), GCore.Row( panels = [ GCommon.BarChart( title = 'DNS TCP Response size for sizes below 1000 bytes', layout = GCommon.BarChartLayout( barmode = GCommon.BAR_CHART_LAYOUT_MODE_STACK, showlegend = False, xaxis = GCommon.BarChartAxis( autotick = False, axtype = GCommon.BAR_CHART_AXIS_TYPE_LINEAR, axrange = [0, 1000], tick0 = 16, dtick = 16, tickangle = -45, tickmargin = 40, title = 'Message size (bytes)', ), yaxis = GCommon.BarChartAxis( axtype = GCommon.BAR_CHART_AXIS_TYPE_LINEAR, dtick = 16, rangemode = GCommon.BAR_CHART_AXIS_RANGEMODE_TOZERO, title = 'Messages per minute', ), ), traces = [ GCommon.BarChartTrace( name = 'TCP Response', color = '#1F60C4', x = 'TCPResponseLen', y = 'TCPResponseCnt', text = 'TCPResponseCnt', ), ], targets = [ GCommon.ClickHouseTableTarget( database = agginfo['database'], table = 'QueryResponseLength' + agginfo['table_suffix'], round = agginfo['round'], query = textwrap.dedent("""\ SELECT Len + intDiv({bucketsize}, 2) AS TCPResponseLen, 60 * sum(Cnt)/($to - $from) AS TCPResponseCnt FROM ( SELECT intDiv(ResponseLengthMap.Length, {bucketsize})*{bucketsize} AS Len, sum(toUInt64(ResponseLengthMap.Count)) AS Cnt FROM $table ARRAY JOIN ResponseLengthMap WHERE $timeFilter AND TransportTCP=1 AND NodeID IN {nodesel} AND Len < 1000 GROUP BY Len UNION ALL ( SELECT CAST(number*{bucketsize} AS UInt16) AS Len, CAST(0 AS UInt64) AS Cnt FROM system.numbers WHERE number > 0 LIMIT {bucketlen} ) ) GROUP BY Len""".format( nodesel=nodesel, bucketsize=16, bucketlen=1000//16)), refId = 'A' ), ], ), ], ), GCore.Row( panels = [ GCommon.BarChart( title = 'DNS UDP Query size for sizes above 1000 bytes', layout = GCommon.BarChartLayout( barmode = GCommon.BAR_CHART_LAYOUT_MODE_STACK, showlegend = False, xaxis = GCommon.BarChartAxis( autotick = False, axtype = GCommon.BAR_CHART_AXIS_TYPE_LINEAR, axrange = [1000, 3000], tick0 = 1008, dtick = 32, tickangle = -90, tickmargin = 45, title = 'Message size (bytes)', ), yaxis = GCommon.BarChartAxis( axtype = GCommon.BAR_CHART_AXIS_TYPE_LINEAR, dtick = 16, rangemode = GCommon.BAR_CHART_AXIS_RANGEMODE_TOZERO, title = 'Messages per minute', ), ), traces = [ GCommon.BarChartTrace( name = 'UDP Query', color = '#FFB357', x = 'UDPQueryLen', y = 'UDPQueryCnt', text = 'UDPQueryCnt', ), ], targets = [ GCommon.ClickHouseTableTarget( database = agginfo['database'], table = 'QueryResponseLength' + agginfo['table_suffix'], round = agginfo['round'], query = textwrap.dedent("""\ SELECT Len + intDiv({bucketsize}, 2) AS UDPQueryLen, 60 * sum(Cnt)/($to - $from) AS UDPQueryCnt FROM ( SELECT intDiv(QueryLengthMap.Length, {bucketsize})*{bucketsize} AS Len, sum(toUInt64(QueryLengthMap.Count)) AS Cnt FROM $table ARRAY JOIN QueryLengthMap WHERE $timeFilter AND TransportTCP=0 AND NodeID IN {nodesel} AND Len >= 1000 GROUP BY Len UNION ALL ( SELECT CAST((number + intDiv(1000, {bucketsize}))*{bucketsize} AS UInt16) AS Len, CAST(0 AS UInt64) AS Cnt FROM system.numbers WHERE number > 0 LIMIT {bucketlen} ) ) GROUP BY Len""".format( nodesel=nodesel, bucketsize=16, bucketlen=2000//16)), refId = 'A' ), ], ), ], ), GCore.Row( panels = [ GCommon.BarChart( title = 'DNS TCP Query size for sizes above 1000 bytes', layout = GCommon.BarChartLayout( barmode = GCommon.BAR_CHART_LAYOUT_MODE_STACK, showlegend = False, xaxis = GCommon.BarChartAxis( autotick = False, axtype = GCommon.BAR_CHART_AXIS_TYPE_LINEAR, axrange = [1000, 3000], tick0 = 1008, dtick = 32, tickangle = -90, tickmargin = 45, title = 'Message size (bytes)', ), yaxis = GCommon.BarChartAxis( axtype = GCommon.BAR_CHART_AXIS_TYPE_LINEAR, dtick = 16, rangemode = GCommon.BAR_CHART_AXIS_RANGEMODE_TOZERO, title = 'Messages per minute', ), ), traces = [ GCommon.BarChartTrace( name = 'TCP Query', color = '#FFB357', x = 'TCPQueryLen', y = 'TCPQueryCnt', text = 'TCPQueryCnt', ), ], targets = [ GCommon.ClickHouseTableTarget( database = agginfo['database'], table = 'QueryResponseLength' + agginfo['table_suffix'], round = agginfo['round'], query = textwrap.dedent("""\ SELECT Len
proofctx): # Note that if var is a proof dummy variable, then # proofctx.fvvarmap.get(var, None) is just None and # check_free_in() will return False unless var occurs _explicitly_ # free in term. return self.check_free_in(var, term, proofctx.fvvarmap.get(var, None)) # match templ, which is an expression in the variable space of the # assertion being applied, against exp, an expression in the variable # space of the current proof, extending dictionary env, which maps from # the variables in the template space to expressions in the current proof def match(self, templ, exp, env): if type(templ) == type('var'): if env.has_key(templ): if exp != env[templ]: # todo: more debug detail raise VerifyError('Unification error') else: # Note, we check elsewhere if a binding variable is matched # against a non-binding-variable term. env[templ] = exp elif type(templ) == type([]): if type(exp) != type([]): raise VerifyError('Unification error, expected ' + sexp_to_string(templ) + ' got ' + exp) if templ[0] != exp[0]: raise VerifyError('Unification error, expected ' + templ[0] + ' got ' + exp[0]) # todo: next check should never trigger, I think all terms # given to match are well-formed. if len(exp) != len(templ): raise VerifyError('Term ' + templ[0] + ' expects arity ' + str(len(templ)) + ' got ' + str(len(exp))) for i in range(1, len(templ)): self.match(templ[i], exp[i], env) def apply_subst(self, templ, env): if type(templ) == type('var'): return env[templ] elif type(templ) == type([]): return [templ[0]] + [self.apply_subst(el, env) for el in templ[1:]] def term_common(kindname, sig, freespecs, kinds, terms, vars): """ term parsing support for 'term' and 'defthm' commands """ if type(sig) != type([]) or len(sig) < 1 or type(sig[0]) != type('term'): raise SyntaxError(\ 'A term signature must be a list starting with a term symbol.') try: kind = kinds[kindname] except KeyError: raise VerifyError('Unknown kind ' + kindname) except TypeError: raise SyntaxError('A term kind name must be an atom.') termname = sig[0] if termname in terms: raise VerifyError('A term ' + termname + ' already exists.') argkinds = [] # freemap will be a list whose length is the number of arguments # of the term. If freemap[i] < 0, then argument i is a term variable # argument. If freemap[i] >= 0, then argument i is a binding variable # and freemap[i] is a bitmap value. For 0 <= j < len(freemap), the jth # bit in freemap[i] is 1 if, in a term expression built from the term, # the actual binding variable argument i occurs free in the term expression # if it occurs free in the actual argument expression substituted for # argument j. invmap = {} args = sig[1:] nargs = len(args) freemap = [-1]*nargs for i in xrange(nargs): v = args[i] try: var = vars[v] except KeyError: raise VerifyError('Unknown variable ' + v) except TypeError: raise SyntaxError('Term formal argument must be variable') if v in invmap: raise VerifyError('Formal argument ' + v + ' reused') invmap[v] = i argkinds.append(var[1]) # kinds[var[1]] ? if var[0] == 'var': freemap[i] = 0 # empty bitmap elif var[0] != 'tvar': # might be 'stmt' or 'thm' in defthm case raise VerifyError('Term formal argument must be a variable.') if freespecs is None: return (kind, argkinds, freemap) for freespec in freespecs: if type(freespec) != type([]) or len(freespec) < 2: raise SyntaxError('Each free variable map must be a list of at least two variables.') try: bvix = invmap[freespec[0]] except KeyError: raise VerifyError(freespec[0] + ' is not a formal argument variable') except (IndexError, TypeError): raise SyntaxError('A free variable specification must be a list of formal argument variables, the first of which is a binding variable') bmap = freemap[bvix] if bmap < 0: raise VerifyError(freespec[0] + ' is not a binding variable argument') if bmap != 0: raise VerifyError('More than one freespec for ' + freespec[0]) for x in freespec[1:]: try: ix = invmap[x] except TypeError: raise SyntaxError('Expected a variable, found ' + sexp_to_string(x) + ' in free variable specification list') except KeyError: raise VerifyError('Expected an argument variable, found ' + x + ' in free variable specification list ') po2 = (1 << ix) if (bmap & po2) != 0: # Might as well be strict here... raise VerifyError(\ 'Duplicate argument variable listed in freespec for ' + freespec[0]) bmap = bmap | po2 freemap[bvix] = bmap return (kind, argkinds, freemap) def invertible_match(newexp, origexp, env, inv): if type(newexp) == type('var'): if type(origexp) != type('var'): return False v = env.get(newexp, None) if v != None: return (v == origexp) env[newexp] = origexp if origexp in inv: return False inv[origexp] = newexp return True if type(origexp) != type([]): return False # Note, we know that the arities are equal since this function is # called only with well-formed expressions. However, for robustness: n = len(newexp) if n != len(origexp) or n == 0: return False if newexp[0] != origexp[0]: return False i = 1 for ne in newexp[1:]: if not invertible_match(ne, origexp[i], env, inv): return False i = i + 1 return True class InterfaceCtx: def __init__(self, name, verify, prefix, params, sort="import"): self.name = name self.verify = verify self.prefix = prefix self.params = params self.sort = sort self.used_params = {} self.vars = {} # self.myterm holds the terms introduced by this import context. # self.terms is the larger collection of terms visible at the # current point in this import context. It contains also terms # made available via param commands. self.terms = {} self.myterms = {} # self.mykinds is the collection of kinds introduced by the import # context itself. self.kinds is the larger collection of kinds # available to the import context(at the current point). It includes # also kinds made available via param commands. self.kinds = {} self.mykinds = {} self.error_handler = None def get_kind(self, rawkind): try: return self.kinds[rawkind] except KeyError: raise VerifyError('Kind ' + rawkind + ' is not known in ' + \ self.sort + ' context.') except TypeError: raise SyntaxError ('A kind name must be a string.') def kind_cmd_common(self, arg): if type(arg) != type([]) or len(arg) != 1: raise VerifyError('kind command takes one arg') kname = arg[0] if type(kname) != type('str'): raise VerifyError('kind argument must be string') if kname in self.kinds: raise VerifyError('A kind ' + kname + ' is already visible in the current ' + self.sort + ' export context.') kprefixed = self.prefix + kname self.kinds[kname] = kprefixed self.mykinds[kname] = kprefixed return kprefixed def var_cmd(self, cmd, arg): if not isinstance(arg, list) or len(arg) < 1: raise SyntaxError('Expected ' + cmd + ' (KIND VAR ...)') kind = self.get_kind(arg[0]) for v in arg[1:]: if type(v) != type('var'): raise SyntaxError('Variable names must be atoms.') if v in self.vars: raise VerifyError('Variable ' + v + ' already defined') self.vars[v] = (cmd, kind, v) def param_cmd(self, arg): # param (IFACE IGNORED_URL (PARAM ...) PREFIX) if type(arg) != type([]) or len(arg) != 4: raise SyntaxError( \ 'Expected param (IFACE IGNORED_URL (PARAM ...) PREFIX)') ifname = arg[0] url = arg[1] # Unused except to check it is an atom paramnames = arg[2] prefix = arg[3] if type(ifname) != type('ifname') or \ type(url) != type('url') or \ type(paramnames) != type([]) or \ type(prefix) != type('prefix'): raise SyntaxError( \ 'Expected param (IFACE IGNORED_URL (PARAM ...) PREFIX)') if len(prefix) < 2 or prefix[0] != '"' or prefix[-1] != '"': raise SyntaxError('Namespace prefix must be enclosed in quotes') prefix = prefix[1:-1] if ifname in self.used_params: raise VerifyError('Interface parameter ' + ifname + \ ' was already used.') n = len(self.used_params) try: p = self.params[n] except IndexError: raise VerifyError(\ "More param commands than provided interface parameters") subparams = [] for pn in paramnames: try: subparams.append(self.used_params[pn]) except KeyError: raise VerifyError('Unknown interface parameter name ' + pn) except TypeError: raise SyntaxError('param parameter must be interface name') # note, this check also checks distinctness of subparams if subparams != p.params: raise VerifyError('Context ' + self.name + \ ' changes
<filename>repcap.py #repcap.py #version 1.0 #Python 3 #Requires scapy - tested/developed with 2.4.3 #Project to allow users to modify packet captures and replay them #Author: <NAME> - <EMAIL> # Command Line Tool that takes in arguments # Current version supports 5 modes: passed to tool via -m command # 0 - the ability to identify IP and MAC addresses in a packet capture - default when no mode provided # 1 - the ability to replay a packet capture unaltered - must include interface to send it # 2 - the ability to read in a packet capture and rewrite the ips and create a new packet capture file (.pcap) # 3 - the ability to read and rewrite ( same as 2 ) and then replay the capture ( with interface presented ) # 4 - a walk through to create a configuration file that will be used by modes 1 - 3 import logging, sys, getopt, os.path logging.getLogger("scapy.runtime").setLevel(logging.ERROR) from scapy.all import * infile = 'none' interface = 'none' outputfile = 'none' configfile = 'none' mode = 0 #Supported file types - pcap and pcapng today ALLOWED_EXTENSIONS = {'pcap', 'pcapng'} def allowed_file(filename): # Quick function to validate file type / extension return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS def mainargs(argv): # Take arguments from command and assign to runtime parameters global cwd, interface, mode, configfile, outputfile try: opts, args = getopt.getopt(argv, "hm:i:c:o:", ["mode=","interface=","config=","outfile="]) except getopt.GetoptError: printhelp() for opt, arg in opts: if opt == '-h': printhelp() sys.exit() elif opt in ("-m", "--mode"): mode = arg elif opt in ("-i", "--interface"): interface = arg elif opt in ("-c", "--config"): configfile = arg elif opt in ("-o", "--outfile"): outputfile = arg #print("Selected Mode is ",mode) #print(argv[len(argv)-1]) def printhelp(): # Function to print the help information when -h is invoked or incorrect commands provided print("_________________________________________________") print("usage: repcap.py <options> inputfile") print("inputfile must be .pcap or .pcapng") print("example: repcap.py example1.pcap - will list unique ip and mac addresses in example1.pcap") print("example: repcap.py -m 1 -i en0 example1.pcap - will replay example1.pcap unaltered out interface en0") print("example: repcap.py -m 4 example1.pcap - will guide through creating a config file and output example1.config") print("_________________________________________________") print("options:") print("-m mode see mode section below") print("-i target interface - used for packet replay - name of interface") print("-c configuration file - if not provided will look for default which is based on name of provided pcap <name of sourcefile>.config") print("-o output file - if not provided will use name of <name of sourcefile>new.pcap") print("_________________________________________________") print("modes:") print("1 = replay packet capture unaltered - must include -i option for interface") print("2 = read config file and rewrite IPs from source packet capture and create new file") print("3 = read config file and rewrite IPs from source packet capture, create new file and replay - must include -i option for interface") print("4 = guided mode for packet rewrite - will create .config text file") def findUniqueIP(pcap): # Function to identify all the unique source / destination IP and MAC addresses in a packet capture ( and sort ) print("Loading Packet Capture") uniqueip = {} uniquesortedip = {} packets = rdpcap(pcap) for p in packets: if p.haslayer(IP): if p[IP].src not in uniqueip: uniqueip[str(p[IP].src)] = str(p[Ether].src) elif p[IP].dst not in uniqueip: uniqueip[str(p[IP].dst)] = str(p[Ether].dst) for ip in sorted(uniqueip.keys(), key = lambda ip: (int(ip.split(".")[0]), int(ip.split(".")[1]), int(ip.split(".")[2]), int(ip.split(".")[3]))): uniquesortedip[ip] = uniqueip[ip] return uniquesortedip def replaypackets(pcap, inter): # Function to replay a packet capture - used for mode 1 and 3 print("Reading Packet Capture ") packets = rdpcap(pcap) print("Starting Packet Replay") sendp(packets, iface=str(inter), verbose=False) print("Packet Replay Complete") def validateipformat(ip): # Function to validate IP address is in the right format myregex = "^((25[0-5]|(2[0-4]|1[0-9]|[1-9]|)[0-9])(\.(?!$)|$)){4}$" return re.fullmatch(myregex, ip, flags=0) def validatemacformat(mac): # Function to validate MAC address is in the right format myregex = "^([0-9A-Fa-f]{2}[:]){5}([0-9A-Fa-f]{2})$" return re.fullmatch(myregex, mac, flags=0) def configbreakdown(configurationfile): # Function to read in a configuration file and pull out the IP and MAC changes in the file macdict = {} ipdict = {} cf = open(configurationfile, 'r') for line in cf: nowhite = line.strip() if nowhite.split(',')[0] == "ip": if nowhite.split(',')[2] == "Del": print("Deleting " + nowhite.split(',')[1]) elif validateipformat(nowhite.split(',')[2]) and validateipformat(nowhite.split(',')[1]): ipdict[(nowhite.split(',')[1])] = nowhite.split(',')[2] else: print("Configuration File Formatting Error, please go through mode 4 to create a new file") print(nowhite) sys.exit() elif nowhite.split(',')[0] == "mac": if validatemacformat(nowhite.split(',')[1]) and validatemacformat(nowhite.split(',')[2]): macdict[(nowhite.split(',')[1])] = nowhite.split(',')[2] else: print("Configuration File Formatting Error, please go through mode 4 to create new file") print(nowhite) sys.exit() else: print("Configuration File Formatting Error, please go through mode 4 to create new file") print(nowhite) sys.exit() return macdict, ipdict def namebreakdown(inputpcapname): # Function to break down a file and get the name and extension as a list pcapfilenamepath = inputpcapname.strip() pcapfilenamepath = pcapfilenamepath.split("/") pcapfilenamepath = pcapfilenamepath[len(pcapfilenamepath) - 1] pcapfilenamepath = pcapfilenamepath.split(".") return pcapfilenamepath def packetrewrite(macdict, ipdict, pcap): # Function that takes in MAC address and IP Dictionary to rewrite existing IP and MAC to new ones # Checks if the output file already exists and checks prior to over writing the file # output file name may be user provided or auto generated based on name of input file global outputfile loop1 = False if outputfile == 'none': tempname = namebreakdown(pcap) outputfile = tempname[0] + "new." + tempname[1] if os.path.isfile(outputfile): print("_________________________________________________") loop1 = True while loop1 == True: docontinue = input(outputfile + " already exists! This action will overwrite existing file. enter Y to proceed or N to cancel:") if str(docontinue) == "N": loop1 = False sys.exit() elif str(docontinue) == "Y": loop1 = False else: print(outputfile + " not found, creating new file") print("Reading in Packets from " + pcap) packets = rdpcap(pcap) print("Re-writing Packets") for p in packets: if p.haslayer(IP): del p[IP].chksum if p[IP].src in ipdict: p[IP].src = ipdict[p[IP].src] if p[IP].dst in ipdict: p[IP].dst = ipdict[p[IP].dst] if p[Ether].src in macdict: p[Ether].src = macdict[p[Ether].src] if p[Ether].dst in macdict: p[Ether].dst = macdict[p[Ether].dst] if p.haslayer(TCP): del p[TCP].chksum wrpcap(outputfile, packets) print("Packets rewritten to " + outputfile) def modezero(): # Mode 0 Function - default if no mode provided in command - print list of unique IP and MAC addresses uniqueip = findUniqueIP(infile) print("Unique IP and MAC addresses in Source PCAP: ") for ip, mac in uniqueip.items(): print(ip + " " + mac) sys.exit() def modeone(): # Mode 1 Function - replay provided packet capture without any changes global cwd, interface, mode, configfile, outputfile if interface == 'none': print("Error: Interface must be provided with Mode 1 command. See 'repcap.py -h' for command help") sys.exit() else: replaypackets(infile, interface) def modetwo(): # Mode 2 Function - does a packet capture rewrite and outputs to a new file # Takes in a configuration file and a source packet capture. User can provide a name for the new packet capture # or will create a packet capture based on the source file name ( with new ) global cwd, interface, mode, configfile, outputfile, infile cwd = os.path.abspath(os.path.dirname(sys.argv[0])) resultdict = {} if configfile == 'none': tempname = namebreakdown(infile) cfname = cwd + '/' + tempname[0] + ".config" else: cfname = configfile if os.path.isfile(cfname): print(cfname + " found - using for configuration") resultdict = configbreakdown(cfname) else: print(cfname + " not found and no configuration file provided. See 'repcap.py -h' for command help") sys.exit() packetrewrite(resultdict[0], resultdict[1], infile) def modethree(): # Mode 3 Function - does a packet capture rewrite and outputs to a new file and replays that new file # Takes in a configuration file and a source packet capture. User can provide configuration file or looks for default # Default Configuration file name is source file name with .config extension # User can provide a name for the new packet capture # or will create a packet capture based on the source file name ( with new ) global cwd, interface, mode, configfile, outputfile, infile cwd = os.path.abspath(os.path.dirname(sys.argv[0])) if interface == 'none': print("Error: Interface must be provided with Mode 3 command. See 'repcap.py -h' for command help") sys.exit() elif configfile == 'none': tempname = namebreakdown(infile) cfname = cwd + '/' + tempname[0] + ".config" else: cfname = configfile if os.path.isfile(cfname): print(cfname + " found - using for configuration") resultdict = configbreakdown(cfname) else: print(cfname + " not found and no configuration file provided. See 'repcap.py -h' for command help") sys.exit() packetrewrite(resultdict[0], resultdict[1], infile) replaypackets(infile, interface) def modefour(): # Mode 4 Function - walks users through existing IP Addresses and MAC addresses in provided packet capture # User can choose to maintain the same IP/MAC, Change the IP and/or Change the MAC Address or delete the host from the capture # User can provide configuration file name or will use the default # If file exists, check user wants to overwrite existing file # If user chooses to delete an IP Address, the paired MAC is removed as well - so doesn't prompt for details of that # User can't choose to delete a MAC address global cwd, infile, configfile loop1 = False skipmac = False cwd = os.path.abspath(os.path.dirname(sys.argv[0])) if configfile == 'none': tempname = namebreakdown(infile) cfname = cwd + '/' + tempname[0] + ".config" else: cfname = configfile if os.path.isfile(cfname): print("_________________________________________________") loop1 = True while loop1 == True: docontinue = input(cfname + " already exists! This action will overwrite existing file. enter Y to proceed or N to cancel:") if str(docontinue) == "N": loop1 =
<filename>src/python/live_plotting.py<gh_stars>0 #!/usr/bin/env python DEF_RES_PATH = "/home/dimitar/projects/STT_theories/results/APR4" PREVIUS_FILE_BETA = 0 PREVIUS_FILE_M = 0 PREVIUS_FILE_LAMBDA = 0 #~ DEF_RES_PATH_PREV = "/home/dimitar/projects/STT_theories/results/" \ #~ + "Results_Statia_1/" \ #~ + "beta{:.0f}/".format(PREVIUS_FILE_BETA) \ #~ + "lambda{:.0e}".format(PREVIUS_FILE_LAMBDA) #~ DEF_RES_FNAME_PREV = "STT_phiScal_J_AkmalPR_" \ #~ + "beta{:.3e}_".format(PREVIUS_FILE_BETA) \ #~ + "m{:.3e}_".format(PREVIUS_FILE_M) \ #~ + "lambda{:.3e}".format(PREVIUS_FILE_LAMBDA) DEF_RES_PATH_PREV = "/home/dimitar/projects/STT_theories/results/APR4" \ + "" \ + "" \ + "" DEF_RES_FNAME_PREV = "STT_phiScal_J_APR4_" \ + "beta{:.3e}_".format(PREVIUS_FILE_BETA) \ + "m{:.3e}_".format(PREVIUS_FILE_M) \ + "lambda{:.3e}".format(PREVIUS_FILE_LAMBDA) _kalin_beta = "beta-6" DEF_RES_KALIN = "/home/dimitar/Documents/Teaching_Materials/University/" \ + "Uvod.Fizika.Cherni.Dupki/Doktorant/Moi_Statii_Prezentacii/Statia_3/Kalin_data/" \ + _kalin_beta + "/" KALIN_BETA = _kalin_beta KALIN_LAMBDA = "lambda{}_".format(PREVIUS_FILE_LAMBDA) KALIN_M = "m{}".format(PREVIUS_FILE_M) def _check_if_StrNotBlank(string): """ check if a sting is blank/empty Parameters ---------- Returns ------- : boolean True if string is not blank/empty False if string is blank/empty """ return bool(string and string.strip()) def _get_latest_file( path = DEF_RES_PATH, model = "STT_phiScal_J_" ): """ return the name of the latest modified file in path by creating wildcard of the type model + "*" the default values are where the results are plus presume that we will plot the result file only Parameters ---------- path: string the path to the directory of interest model: string how the file name looks like, it serves as wildcard of the type model + "*" Returns ------- : string the name of latest modified file """ import glob import os if (_check_if_StrNotBlank(path) and _check_if_StrNotBlank(model)): filename = max( glob.glob(path + "/" + model + "*"), key=os.path.getctime ) filename = filename.split("/")[-1] #~ print( #~ "\n latest file in \n\t {} is: {} \n".format( #~ path, filename #~ ) #~ ) else: filename = "" print("\n path and name not set, some filename var!!! \n") return filename def _units_coef_clac(): """ Calculates the unit coefficients Parameters ---------- Returns ------- : dictionary "density" in (double) g cm^-3 "pressure" in (double) dyns cm^-3 "r" in (double) km "j" in (double) m^2 kg """ # mas of sun in kg const_msun = 1.9891e30 # gravitational const in m^3kg^-1s^-2 const_g = 6.67384e-11 # speed of light in ms^-1 const_c = 299792458 units = {} # units of density in g cm^-3 units["density"] = 1e-3 * const_c**6 / (const_g**3 * const_msun**2) # units of pressure in dyns cm^-3 units["pressure"] = const_c**8 / (const_g**3 * const_msun**2) * 10 # units of rad coordinate in km units["rad"] = 1e-3 * const_g * const_msun / const_c**2 # units of moment of inertia units["j"] = 1e7 * const_g**2 * const_msun**3 / const_c**4 return units def _load_kalin_file( data=[], headline=[], label=[], path=DEF_RES_KALIN, filename=KALIN_BETA+KALIN_LAMBDA+KALIN_M+".txt" ): """ load kalin result file with name <filename> by appending the data after taking care of coefficients to <data> and saving the <headlines>( what is the name of each column) and label - the filename itself Parameters ---------- path: string the full path of the directory where the file is filename: string the name of the file itself data: list where to append the data of interest headline: list what each column is label: list the name the given data, expect it will be the filename Returns ------- """ import os.path all_data = [] if os.path.isfile(path+filename): with open(path + filename, "r") as f: all_data = f.readlines() else: print( "from where to load a kalin file!!! {}{} pass ".format( path, filename ) ) pass #~ get rid of inline text all_data = [ line.strip() for line in all_data if "lambda" not in line and "f_rot" not in line and line.strip() ] #~ i am not interested in all data, so only the indexes here #~ will be saved #~ since in some files the central pressure is in different column #~ we check it and take into account indexes = [3, 5, 7, 10, 6, 2] _units = _units_coef_clac() units = [ _units["density"], _units["rad"], 1, 1, 1, 1 ] data.append([[] for i in indexes]) for cnt, line in enumerate(all_data): for i, u, d in zip(indexes, units, data[-1]): try: d.append(float(line.split(" ")[i]) / u) except ValueError: print( "\n ValueError: line {}: {} \n".format( cnt, line ) ) break for i, val in enumerate(data[-1][4]): data[-1][4][i] *= (-1) if val > 0 else 1 label.append(filename) return { "data": data[-1], "label": label[-1] } def _load_GR( data = [],headline = [], label = [], path = DEF_RES_PATH, filename = "" ): """ load the data from <filename> in <path> by appending them to <data>, append the headline (the name of each column) in <headline> and the name of the file in <label> Parameters ---------- path: string the path to the directory containing the file with data filename: string the name of the file which will be loaded data: list the loaded data will be appended here headline: list the name of each column will be appended here as a list label: list the name of the file will be apended here Returns ------- : dictionary dictionary with entries { "data" : data, "headline": headline, "label": label } """ data.clear() headline.clear() label.clear() if not(_check_if_StrNotBlank(path) and _check_if_StrNotBlank(filename)): print( "\n from where to load a file!!! \n\t {} /{} \n".format( path, filename ) ) with open(path + "/" + filename, "r") as f: all_data = f.readlines() headline.append( [ i.strip() for i in all_data.pop(0).strip().split(" ") if "#" not in i and len(i.strip()) ] ) label.append(filename.split("/")[-1][-41:]) data.append( [ [] for i in all_data[0].strip().split(" ") if len(i.strip()) ] ) for cnt, line in enumerate(all_data): for apnd, num in zip( data[-1], [ float(i) for i in line.strip().split(" ") if len(i.strip()) ] ): apnd.append(num) return { "data": data[-1], "headline": headline[-1], "label": label[-1] } def _load_previus_data( data = [],headline = [], label = [], path = DEF_RES_PATH_PREV, filename = DEF_RES_FNAME_PREV ): """ load the data from <filename> in <path> by appending them to <data>, append the headline (the name of each column) in <headline> and the name of the file in <label> Parameters ---------- path: string the path to the directory containing the file with data filename: string the name of the file which will be loaded data: list the loaded data will be appended here headline: list the name of each column will be appended here as a list label: list the name of the file will be apended here Returns ------- : dictionary dictionary with entries { "data" : data, "headline": headline, "label": label } """ data.clear() headline.clear() label.clear() if not(_check_if_StrNotBlank(path) and _check_if_StrNotBlank(filename)): print( "\n from where to load a file!!! \n\t {} /{} \n".format( path, filename ) ) try: with open(path + "/" + filename, "r") as f: all_data = f.readlines() except FileNotFoundError: print(path + "/" + filename," MISSING !!! ") return { } headline.append( [ i.strip() for i in all_data.pop(0).strip().split(" ") if "#" not in i and len(i.strip()) ] ) label.append(filename.split("/")[-1][-41:]) data.append( [ [] for i in all_data[0].strip().split(" ") if len(i.strip()) ] ) for cnt, line in enumerate(all_data): for apnd, num in zip( data[-1], [ float(i) for i in line.strip().split(" ") if len(i.strip()) ] ): apnd.append(num) return { "data": data[-1], "headline": headline[-1], "label": label[-1] } def _load_file( filename = "", data = [], headline = [], label = [], path = DEF_RES_PATH ): """ load the data from <filename> in <path> by appending them to <data>, append the headline (the name of each column) in <headline> and the name of the file in <label> Parameters ---------- path: string the path to the directory containing the file with data filename: string the name of the file which will be loaded data: list the loaded data will be appended here headline: list the name of each column will be appended here as a list label: list the name of the file will be apended here Returns ------- : dictionary dictionary with entries { "data" : data, "headline": headline, "label": label } """ data.clear() headline.clear() label.clear() if not(_check_if_StrNotBlank(path)): print( "\n from where to load a file!!! \n\t {} /{} \n".format( path, filename ) ) filename = _get_latest_file() with open(path + "/" + filename, "r") as f: all_data = f.readlines() headline.append( [ i.strip() for i in all_data.pop(0).strip().split(" ") if "#" not in i and len(i.strip()) ] )
<filename>ShapeStatistics.py #Purpose: To implement a suite of 3D shape statistics and to use them for point #cloud classification #TODO: Fill in all of this code for group assignment 2 import sys sys.path.append("S3DGLPy") from Primitives3D import * from PolyMesh import * import numpy as np import matplotlib.pyplot as plt POINTCLOUD_CLASSES = ['biplane', 'desk_chair', 'dining_chair', 'fighter_jet', 'fish', 'flying_bird', 'guitar', 'handgun', 'head', 'helicopter', 'human', 'human_arms_out', 'potted_plant', 'race_car', 'sedan', 'shelves', 'ship', 'sword', 'table', 'vase'] NUM_PER_CLASS = 10 ######################################################### ## UTILITY FUNCTIONS ## ######################################################### #Purpose: Export a sampled point cloud into the JS interactive point cloud viewer #Inputs: Ps (3 x N array of points), Ns (3 x N array of estimated normals), #filename: Output filename def exportPointCloud(Ps, Ns, filename): N = Ps.shape[1] fout = open(filename, "w") fmtstr = "%g" + " %g"*5 + "\n" for i in range(N): fields = np.zeros(6) fields[0:3] = Ps[:, i] fields[3:] = Ns[:, i] fout.write(fmtstr%tuple(fields.flatten().tolist())) fout.close() #Purpose: To sample a point cloud, center it on its centroid, and #then scale all of the points so that the RMS distance to the origin is 1 def samplePointCloud(mesh, N): (Ps, Ns) = mesh.randomlySamplePoints(N) ##TODO: Center the point cloud on its centroid and normalize #by its root mean square distance to the origin. Note that this #does not change the normals at all, only the points, since it's a #uniform scale centroid = np.mean(Ps, 1)[:, None] #return 3 by 1 Ps -= centroid; scale = np.sqrt(np.sum(np.square(Ps))/N) Ps /= scale; return (Ps, Ns) #Purpose: To sample the unit sphere as evenly as possible. The higher #res is, the more samples are taken on the sphere (in an exponential #relationship with res). By default, samples 66 points def getSphereSamples(res = 2): m = getSphereMesh(1, res) return m.VPos.T #Purpose: To compute PCA on a point cloud #Inputs: X (3 x N array representing a point cloud) def doPCA(X): return np.linalg.eigh(X.dot(X.T)) ######################################################### ## SHAPE DESCRIPTORS ## ######################################################### #Purpose: To compute a shape histogram, counting points #distributed in concentric spherical shells centered at the origin #Inputs: Ps (3 x N point cloud), Ns (3 x N array of normals) (not needed here #but passed along for consistency) #NShells (number of shells), RMax (maximum radius) #Returns: hist (histogram of length NShells) def getShapeHistogram(Ps, Ns, NShells, RMax): H = np.sqrt(np.sum(Ps**2, 0))[None, :] - np.linspace(0, RMax, NShells, False)[:, None] S = np.sum((H >= 0).reshape(NShells, Ps.shape[1]), 1) N = np.resize(S[1:], NShells) N[-1] = np.sum(np.sqrt(np.sum(Ps**2, 0)) > RMax) return S-N #Purpose: To create shape histogram with concentric spherical shells and #sectors within each shell, sorted in decreasing order of number of points #Inputs: Ps (3 x N point cloud), Ns (3 x N array of normals) (not needed here #but passed along for consistency), NShells (number of shells), #RMax (maximum radius), SPoints: A 3 x S array of points sampled evenly on #the unit sphere (get these with the function "getSphereSamples") def getShapeShellHistogram(Ps, Ns, NShells, RMax, SPoints): NSectors = SPoints.shape[1] #A number of sectors equal to the number of #points sampled on the sphere #Create a 2D histogram that is NShells x NSectors hist = np.zeros((NShells, NSectors)) bins = np.linspace(0, RMax, NShells, False) indx = np.digitize(np.sqrt(np.sum(np.square(Ps), axis=0)), bins) for i in range(NShells): subList = Ps[:, indx == i] dirList = np.argmax(subList.T.dot(SPoints), axis=1) #across row, size=#SizeOfShell count = np.bincount(dirList) hist[i, :count.shape[0]] = np.sort(count)[::-1] #using double slicing to reverse the sort order return hist.flatten() #Flatten the 2D histogram to a 1D array #alternative approach # raw = SPoints.T.dot(Ps) # sector = np.argmax(raw, axis=0) # dist = np.sqrt(np.sum(np.square(Ps))) # combined = zip(sector, dist) #combine two list into tuples # sorted(combined, key=lambda x: x[0]) #sort the list according to dist value #Purpose: To create shape histogram with concentric spherical shells and to #compute the PCA eigenvalues in each shell #Inputs: Ps (3 x N point cloud), Ns (3 x N array of normals) (not needed here #but passed along for consistency), NShells (number of shells), #RMax (maximum radius), sphereRes: An integer specifying points on thes phere #to be used to cluster shells def getShapeHistogramPCA(Ps, Ns, NShells, RMax): #Create a 2D histogram, with 3 eigenvalues for each shell hist = np.zeros((NShells, 3)) bins = np.linspace(0, RMax, NShells, False) indx = np.digitize(np.sqrt(np.sum(np.square(Ps), axis=0)), bins) for i in range(NShells): sub = Ps[:, indx == i] (eigVs, eigVecs) = doPCA(sub) hist[i, :] = np.sort(eigVs)[::-1] # reverse order, omitting eigs.shape(0) return hist.flatten() #Flatten the 2D histogram to a 1D array #Purpose: To create shape histogram of the pairwise Euclidean distances between #randomly sampled points in the point cloud #Inputs: Ps (3 x N point cloud), Ns (3 x N array of normals) (not needed here #but passed along for consistency), DMax (Maximum distance to consider), #NBins (number of histogram bins), NSamples (number of pairs of points sample #to compute distances) def getD2Histogram(Ps, Ns, DMax, NBins, NSamples): N = Ps.shape[1] S1 = Ps[:, np.random.random_integers(0, N-1, NSamples)] S2 = Ps[:, np.random.random_integers(0, N-1, NSamples)] D2 = np.sqrt(np.sum((S1-S2)**2, 0)) hist, be = np.histogram(D2, NBins, (0, DMax)) return hist #Purpose: To create shape histogram of the angles between randomly sampled #triples of points #Inputs: Ps (3 x N point cloud), Ns (3 x N array of normals) (not needed here #but passed along for consistency), NBins (number of histogram bins), #NSamples (number of triples of points sample to compute angles) def getA3Histogram(Ps, Ns, NBins, NSamples): N = Ps.shape[1] S1 = Ps[:, np.random.random_integers(0, N-1, NSamples)] S2 = Ps[:, np.random.random_integers(0, N-1, NSamples)] S3 = Ps[:, np.random.random_integers(0, N-1, NSamples)] V1 = S1 - S2 L1 = np.sqrt(np.sum(V1**2, 0)) V2 = S1 - S3 L2 = np.sqrt(np.sum(V2**2, 0)) valid = (L1 > 0) * (L2 > 0) V1 = V1[:, valid] / L1[valid] V2 = V2[:, valid] / L2[valid] C = np.sum(V1*V2, 0) D2S = np.sum((V1-V2)**2, 0) C[D2S == 0] = 1 A3 = np.arccos(C) hist, be = np.histogram(A3, NBins, (0, np.pi)) return hist #Purpose: To create the Extended Gaussian Image by binning normals to #sphere directions after rotating the point cloud to align with its principal axes #Inputs: Ps (3 x N point cloud) (use to compute PCA), Ns (3 x N array of normals), #SPoints: A 3 x S array of points sampled evenly on the unit sphere used to #bin the normals def getEGIHistogram(Ps, Ns, SPoints): S = SPoints.shape[1] hist = np.zeros(S) ##TOOD: Finish this; fill in hist return hist #Purpose: To create an image which stores the amalgamation of rotating #a bunch of planes around the largest principal axis of a point cloud and #projecting the points on the minor axes onto the image. #Inputs: Ps (3 x N point cloud), Ns (3 x N array of normals, not needed here), #NAngles: The number of angles between 0 and 2*pi through which to rotate #the plane, Extent: The extent of each axis, Dim: The number of pixels along #each minor axis def getSpinImage(Ps, Ns, NAngles, Extent, Dim): #Create an image eigs, V = doPCA(Ps) P = V[:, :2].T.dot(Ps) As = np.linspace(0, 2*np.pi, NAngles, False) C, S = np.cos(As), np.sin(As) A = np.zeros((NAngles, 2, 2)) A[:, 0, 0], A[:, 0, 1], A[:, 1, 0], A[:, 1, 1] = C, -S, S, C P = A.dot(P) x = P[:, 0, :].flatten() y = P[:, 1, :].flatten() hist, xe, ye = np.histogram2d(x, y, Dim, [[-Extent, Extent], [-Extent, Extent]]) return hist.flatten() #Purpose: To create a histogram of spherical harmonic magnitudes in concentric #spheres after rasterizing the point cloud to a voxel grid #Inputs: Ps (3 x N point cloud), Ns (3 x N array of normals, not used here), #VoxelRes: The number of voxels along each axis (for instance, if 30, then rasterize #to 30x30x30 voxels), Extent: The number of units along each axis (if 2, then #rasterize in the box [-1, 1] x [-1, 1] x [-1, 1]), NHarmonics: The number of spherical #harmonics, NSpheres, the number of concentric spheres to take def getSphericalHarmonicMagnitudes(Ps, Ns, VoxelRes, Extent, NHarmonics, NSpheres): hist = np.zeros((NSpheres, NHarmonics)) #TODO: Finish this return hist.flatten() #Purpose: Utility function for wrapping around the statistics functions. #Inputs: PointClouds (a python list of N point clouds), Normals (a python #list of the N corresponding normals), histFunction (a function #handle for one of the above functions), *args (addditional arguments #that the descriptor function needs) #Returns: AllHists (A KxN matrix of all descriptors, where K is the length #of each
<filename>script/geometry.py<gh_stars>0 import collections, os, sys import numpy as np import scipy.integrate from scipy.special import erf, erfc import matplotlib import matplotlib.pyplot as plt from matplotlib.collections import LineCollection from matplotlib.colors import LinearSegmentedColormap import noise matplotlib.rcParams['hatch.linewidth'] = 0.7 fontsize = 11/1.4 latex_preamble = r''' \usepackage{lmodern} \usepackage{amsmath} \usepackage{amsfonts} \usepackage{mathtools} \usepackage{siunitx} \usepackage{slantsc} \usepackage{graphicx} \usepackage{abraces} ''' matplotlib.rcParams.update({ 'text.usetex' : True, 'font.family' : 'serif', 'font.serif' : 'cmr10', 'font.size' : fontsize, 'mathtext.fontset' : 'cm', 'axes.formatter.use_mathtext': True, 'text.latex.preamble': latex_preamble, }) # Specs Mpc = 1 boxsize = 512*Mpc domain_subdivisions = (2, 3) gridsize = 54 shortrange_scale = 1.25*boxsize/gridsize shortrange_range = 4.5*shortrange_scale shortrange_tilesize = shortrange_range tiling = np.asarray( (boxsize/np.asarray(domain_subdivisions))/shortrange_tilesize*(1 + 1e-16), dtype=int, ) subtilings = [(2, 1), (1, 1), (3, 2), (1, 1), (2, 2), (4, 3)] # Initialize figure fig, ax = plt.subplots() # Draw box lw_box = 1.5 plt.plot([0, boxsize, boxsize, 0, 0], [0, 0, boxsize, boxsize, 0], 'k-', lw=lw_box, zorder=300) # Draw domains for dim in range(2): for i in range(1, domain_subdivisions[dim]): x, y = [0, boxsize], [boxsize/domain_subdivisions[dim]*i]*2 if dim == 1: x, y = y, x plt.plot(x, y, 'k-', lw=1.3, zorder=90) # Draw PM grid for i in range(1, gridsize): plt.plot([0, boxsize], [boxsize/gridsize*i]*2, '-', color=[0.89]*3, lw=0.5, zorder=-100) plt.plot([boxsize/gridsize*i]*2, [0, boxsize], '-', color=[0.89]*3, lw=0.5, zorder=-100) # Draw tiling for dim in range(2): for i in range(1, tiling[dim]*domain_subdivisions[dim]): x, y = [0, boxsize], [boxsize/domain_subdivisions[dim]/tiling[dim]*i]*2 if dim == 1: x, y = y, x plt.plot(x, y, 'C5-', lw=0.95, zorder=70) # Draw subtilings Subtile = collections.namedtuple('Subtile', ['x', 'y', 'width', 'height']) subtiles = [] domain_size_x = boxsize/domain_subdivisions[1] domain_size_y = boxsize/domain_subdivisions[0] tile_size_x = domain_size_x/tiling[1] tile_size_y = domain_size_y/tiling[0] n = -1 for i in range(domain_subdivisions[0]): for j in range(domain_subdivisions[1]): n += 1 subtiling = subtilings[n] domain_start_x = domain_size_x*j domain_start_y = domain_size_y*i for ii in range(tiling[0]): for jj in range(tiling[1]): tile_start_x = domain_start_x + tile_size_x*jj tile_start_y = domain_start_y + tile_size_y*ii for iii in range(subtiling[0]): for jjj in range(subtiling[1]): subtile = Subtile( tile_start_x + tile_size_x/subtiling[1]*jjj, tile_start_y + tile_size_y/subtiling[0]*iii, tile_size_x/subtiling[1], tile_size_y/subtiling[0], ) subtiles.append(subtile) for iii in range(1, subtiling[0]): plt.plot( [tile_start_x, tile_start_x + tile_size_x], [tile_start_y + tile_size_y/subtiling[0]*iii]*2, 'C1-', lw=0.6, zorder=60, ) for jjj in range(1, subtiling[1]): plt.plot( [tile_start_x + tile_size_x/subtiling[1]*jjj]*2, [tile_start_y, tile_start_y + tile_size_y], 'C1-', lw=0.6, zorder=60, ) def generate_subtiles(n): subtiling = subtilings[n] subtiles = [] for i in range(domain_subdivisions[0]): for j in range(domain_subdivisions[1]): domain_start_x = domain_size_x*j domain_start_y = domain_size_y*i for ii in range(tiling[0]): for jj in range(tiling[1]): tile_start_x = domain_start_x + tile_size_x*jj tile_start_y = domain_start_y + tile_size_y*ii for iii in range(subtiling[0]): for jjj in range(subtiling[1]): subtile = Subtile( tile_start_x + tile_size_x/subtiling[1]*jjj, tile_start_y + tile_size_y/subtiling[0]*iii, tile_size_x/subtiling[1], tile_size_y/subtiling[0], ) subtiles.append(subtile) return subtiles ghostly_subtiles = [generate_subtiles(n) for n in range(len(subtilings))] # Draw particles def get_subtile_dist(subtile1, subtile2): x1 = np.array((subtile1.x, subtile1.x + subtile1.width)) y1 = np.array((subtile1.y, subtile1.y + subtile1.height)) x2 = np.array((subtile2.x, subtile2.x + subtile2.width)) y2 = np.array((subtile2.y, subtile2.y + subtile2.height)) if subtile1.x - subtile2.x > 0.5*boxsize: x2 += boxsize elif subtile1.x - subtile2.x < -0.5*boxsize: x2 -= boxsize if subtile1.y - subtile2.y > 0.5*boxsize: y2 += boxsize elif subtile1.y - subtile2.y < -0.5*boxsize: y2 -= boxsize if max(y1) < min(y2): # 1 fully below 2 dy = max(y1) - min(y2) elif min(y1) > max(y2): # 1 fully above 2 dy = min(y1) - max(y2) else: # overlap in y-direction dy = 0 if max(x1) < min(x2): # 1 fully to the left of 2 dx = max(x1) - min(x2) elif min(x1) > max(x2): # 1 fully to the right of 2 dx = min(x1) - max(x2) else: # overlap in x-direction dx = 0 return np.sqrt(dx**2 + dy**2) theta = np.linspace(0, 2*np.pi, 200, endpoint=False) N = 8 eps_soft = 0.030*boxsize/np.cbrt(N) def place_particle(x, y, color='r', hatch='/'*8, place_dot=True): # Draw particle with radius equalt to softening length if place_dot: plt.fill(x + eps_soft*np.cos(theta), y + eps_soft*np.sin(theta), color, zorder=304, edgecolor='none') X = x + shortrange_range*np.cos(theta) Y = y + shortrange_range*np.sin(theta) def plot(x, y): if len(x) == 0: return diff_avg = np.mean(np.abs(np.diff(x))) index = -1 for i in range(1, len(x)): diffx = abs(x[i] - x[i - 1]) if diffx > 10*diff_avg: index = i break diffy = abs(y[i] - y[i - 1]) if diffy > 10*diff_avg: index = i break if index != -1: x = np.roll(x, -index) y = np.roll(y, -index) plt.plot(x, y, '-', color=color, lw=1.3, alpha=0.85, zorder=301) mask_ok_x = (0 <= X) & (X < boxsize) mask_ok_y = (0 <= Y) & (Y < boxsize) mask_left_x = (X < 0) mask_right_x = (boxsize <= X) mask_down_y = (Y < 0) mask_up_y = (boxsize <= Y) mask = mask_ok_x & mask_ok_y plot(X[mask], Y[mask]) mask = mask_ok_x & mask_down_y plot(X[mask], Y[mask] + boxsize) mask = mask_ok_x & mask_up_y plot(X[mask], Y[mask] - boxsize) mask = mask_left_x & mask_ok_y plot(X[mask] + boxsize, Y[mask]) mask = mask_right_x & mask_ok_y plot(X[mask] - boxsize, Y[mask]) mask = mask_left_x & mask_down_y plot(X[mask] + boxsize, Y[mask] + boxsize) mask = mask_left_x & mask_up_y plot(X[mask] + boxsize, Y[mask] - boxsize) mask = mask_right_x & mask_down_y plot(X[mask] - boxsize, Y[mask] + boxsize) mask = mask_right_x & mask_up_y plot(X[mask] - boxsize, Y[mask] - boxsize) # Hatch subtiles within which to search n = int(x/domain_size_x) + domain_subdivisions[1]*int(y/domain_size_y) for subtile in ghostly_subtiles[n]: if ( (subtile.x <= x < subtile.x + subtile.width) and (subtile.y <= y < subtile.y + subtile.height) ): break else: print(f'Failed to find subtile of particle at ({x}, {y})!', file=sys.stderr) sys.exit(1) Xs = [] Ys = [] for other_subtile in ghostly_subtiles[n]: dist = get_subtile_dist(subtile, other_subtile) if dist < shortrange_range: X = np.array([ other_subtile.x, other_subtile.x + other_subtile.width, other_subtile.x + other_subtile.width, other_subtile.x, other_subtile.x, ]) Y = np.array([ other_subtile.y, other_subtile.y, other_subtile.y + other_subtile.height, other_subtile.y + other_subtile.height, other_subtile.y, ]) if hatch is not None: plt.fill(X, Y, color='none', edgecolor=color, zorder=-90, hatch=hatch, fill=False, lw=0, alpha=0.50, ) Xs.append(X) Ys.append(Y) # Draw boundary of hatched region X = np.concatenate(Xs) Y = np.concatenate(Ys) def draw_hatched_boundary(x, y, X, Y, no=None): indices = [] fac = 1/np.prod(subtilings[n])**1.2 for q in theta: L = 0.5*boxsize while L > 0: L -= 0.2*boxsize/gridsize dist2 = (X - (x + L*np.cos(q)))**2 + (Y - (y + L*np.sin(q)))**2 if np.min(dist2) < (19.8*boxsize/gridsize*fac)**2: index = np.argmin(dist2) if index not in indices: indices.append(index) break indices.append(indices[0]) indices = np.array(indices) X = X[indices] Y = Y[indices] if no is None: no = [] if isinstance(no, str): no = [no] no = list(no) for no in no: nans_to_be_inserted = [] if no == 'bottom': Z = Y extrema = np.nanmin(Z) elif no == 'top': Z = Y extrema = np.nanmax(Z) elif no == 'left': Z = X extrema = np.nanmin(Z) elif no == 'right': Z = X extrema = np.nanmax(Z) if no is not None: reached = False for i, zi in enumerate(Z): if not reached: if zi == extrema: reached = True continue if zi == extrema: nans_to_be_inserted.append(i) else: reached = False count = 0 for index in nans_to_be_inserted: X = np.insert(X, index + count, np.nan) Y = np.insert(Y, index + count, np.nan) count += 1 if hatch is not None: plt.plot(X, Y, '--', color=color, lw=0.9, zorder=301, alpha=0.80) i = int(x/tile_size_x) j = int(y/tile_size_y) if 0 < j < domain_subdivisions[0]*tiling[0] - 1 and 0 < i < domain_subdivisions[1]*tiling[1] - 1: draw_hatched_boundary(x, y, X, Y) elif j == 0 and 0 < i < domain_subdivisions[1]*tiling[1] - 1: draw_hatched_boundary(x, y, X, Y, no='bottom') draw_hatched_boundary(x, y + boxsize, X, Y, no='top') elif i == 0 and 0 < j < domain_subdivisions[0]*tiling[0] - 1: draw_hatched_boundary(x, y, X, Y, no='left') draw_hatched_boundary(x + boxsize, y, X, Y, no='right') elif j == domain_subdivisions[0]*tiling[0] - 1 and 0 < i < domain_subdivisions[1]*tiling[1] - 1: draw_hatched_boundary(x, y, X, Y, no='top') draw_hatched_boundary(x, y - boxsize, X, Y, no='bottom') elif i == domain_subdivisions[1]*tiling[1] - 1 and 0 < j < domain_subdivisions[0]*tiling[0] - 1: draw_hatched_boundary(x, y, X, Y, no='right') draw_hatched_boundary(x - boxsize, y, X, Y, no='left') elif j == 0 and i == 0: draw_hatched_boundary(x, y, X, Y, no=('left', 'bottom')) draw_hatched_boundary(x + boxsize, y + boxsize, X, Y, no=('right', 'top')) draw_hatched_boundary(x + boxsize, y, X, Y, no=('right', 'bottom')) draw_hatched_boundary(x, y + boxsize, X, Y, no=('left', 'top')) elif j == 0 and i == domain_subdivisions[1]*tiling[1] - 1: draw_hatched_boundary(x, y, X, Y, no=('right', 'bottom')) draw_hatched_boundary(x - boxsize, y, X, Y, no=('left', 'bottom')) draw_hatched_boundary(x, y + boxsize, X, Y, no=('right', 'top')) draw_hatched_boundary(x - boxsize, y + boxsize, X, Y, no=('left', 'top'))
from io import BytesIO from sys import version_info from unittest import TestCase from xml.etree import ElementTree import datetime import pytest from pyclarity_lims.constants import nsmap from pyclarity_lims.descriptors import StringDescriptor, StringAttributeDescriptor, StringListDescriptor, \ StringDictionaryDescriptor, IntegerDescriptor, BooleanDescriptor, UdfDictionary, EntityDescriptor, \ InputOutputMapList, EntityListDescriptor, PlacementDictionary, EntityList, SubTagDictionary, ExternalidList,\ XmlElementAttributeDict, XmlAttributeList, XmlReagentLabelList, XmlPooledInputDict, XmlAction, QueuedArtifactList from pyclarity_lims.entities import Artifact, ProtocolStep, Container, Process, Step from pyclarity_lims.lims import Lims from tests import elements_equal if version_info[0] == 2: from mock import Mock else: from unittest.mock import Mock def _tostring(e): outfile = BytesIO() ElementTree.ElementTree(e).write(outfile, encoding='utf-8', xml_declaration=True) return outfile.getvalue().decode("utf-8") class TestDescriptor(TestCase): def _make_desc(self, klass, *args, **kwargs): return klass(*args, **kwargs) class TestStringDescriptor(TestDescriptor): def setUp(self): self.et = ElementTree.fromstring("""<?xml version="1.0" encoding="utf-8"?> <test-entry> <name>test name</name> </test-entry> """) self.instance = Mock(root=self.et) def test__get__(self): sd = self._make_desc(StringDescriptor, 'name') assert sd.__get__(self.instance, None) == "test name" def test__set__(self): sd = self._make_desc(StringDescriptor, 'name') sd.__set__(self.instance, "new test name") assert self.et.find('name').text == "new test name" def test_create(self): instance_new = Mock(root=ElementTree.Element('test-entry')) sd = self._make_desc(StringDescriptor, 'name') sd.__set__(instance_new, "test name") assert instance_new.root.find('name').text == 'test name' class TestIntegerDescriptor(TestDescriptor): def setUp(self): self.et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry> <count>32</count> </test-entry> """) self.instance = Mock(root=self.et) def test__get__(self): sd = self._make_desc(IntegerDescriptor, 'count') assert sd.__get__(self.instance, None) == 32 def test__set__(self): sd = self._make_desc(IntegerDescriptor, 'count') sd.__set__(self.instance, 23) assert self.et.find('count').text == '23' sd.__set__(self.instance, '23') assert self.et.find('count').text == '23' def test_create(self): instance_new = Mock(root=ElementTree.Element('test-entry')) sd = self._make_desc(IntegerDescriptor, 'count') sd.__set__(instance_new, 23) assert instance_new.root.find('count').text == '23' class TestBooleanDescriptor(TestDescriptor): def setUp(self): self.et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry> <istest>true</istest> </test-entry> """) self.instance = Mock(root=self.et) def test__get__(self): bd = self._make_desc(BooleanDescriptor, 'istest') assert bd.__get__(self.instance, None) def test__set__(self): bd = self._make_desc(BooleanDescriptor, 'istest') bd.__set__(self.instance, False) assert self.et.find('istest').text == 'false' bd.__set__(self.instance, 'true') assert self.et.find('istest').text == 'true' def test_create(self): instance_new = Mock(root=ElementTree.Element('test-entry')) bd = self._make_desc(BooleanDescriptor, 'istest') bd.__set__(instance_new, True) assert instance_new.root.find('istest').text == 'true' class TestEntityDescriptor(TestDescriptor): def setUp(self): self.et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry> <artifact uri="http://testgenologics.com:4040/api/v2/artifacts/a1"></artifact> </test-entry> """) self.lims = Lims('http://testgenologics.com:4040', username='test', password='password') self.a1 = Artifact(self.lims, id='a1') self.a2 = Artifact(self.lims, id='a2') self.instance = Mock(root=self.et, lims=self.lims) def test__get__(self): ed = self._make_desc(EntityDescriptor, 'artifact', Artifact) assert ed.__get__(self.instance, None) == self.a1 def test__set__(self): ed = self._make_desc(EntityDescriptor, 'artifact', Artifact) ed.__set__(self.instance, self.a2) assert self.et.find('artifact').attrib['uri'] == 'http://testgenologics.com:4040/api/v2/artifacts/a2' def test_create(self): instance_new = Mock(root=ElementTree.Element('test-entry')) ed = self._make_desc(EntityDescriptor, 'artifact', Artifact) ed.__set__(instance_new, self.a1) assert instance_new.root.find('artifact').attrib['uri'] == 'http://testgenologics.com:4040/api/v2/artifacts/a1' class TestEntityListDescriptor(TestDescriptor): def setUp(self): et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry> <artifact uri="http://testgenologics.com:4040/api/v2/artifacts/a1"></artifact> <artifact uri="http://testgenologics.com:4040/api/v2/artifacts/a2"></artifact> </test-entry> """) self.lims = Lims('http://testgenologics.com:4040', username='test', password='password') self.a1 = Artifact(self.lims, id='a1') self.a2 = Artifact(self.lims, id='a2') self.instance1 = Mock(root=et, lims=self.lims) et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry> <nesting> <artifact uri="http://testgenologics.com:4040/api/v2/artifacts/a1"></artifact> <artifact uri="http://testgenologics.com:4040/api/v2/artifacts/a2"></artifact> </nesting> </test-entry> """) self.instance2 = Mock(root=et, lims=self.lims) def test__get__(self): ed = self._make_desc(EntityListDescriptor, 'artifact', Artifact) assert ed.__get__(self.instance1, None) == [self.a1, self.a2] ed = self._make_desc(EntityListDescriptor, 'artifact', Artifact, nesting=['nesting']) assert ed.__get__(self.instance2, None) == [self.a1, self.a2] class TestStringAttributeDescriptor(TestDescriptor): def setUp(self): self.et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry name="test name"> </test-entry>""") self.instance = Mock(root=self.et) def test__get__(self): sd = self._make_desc(StringAttributeDescriptor, 'name') assert sd.__get__(self.instance, None) == "test name" def test__set__(self): sd = self._make_desc(StringAttributeDescriptor, 'name') sd.__set__(self.instance, "test name2") assert self.et.attrib['name'] == "test name2" def test_create(self): instance_new = Mock(root=ElementTree.Element('test-entry')) bd = self._make_desc(StringAttributeDescriptor, 'name') bd.__set__(instance_new, "test name2") assert instance_new.root.attrib['name'] == "test name2" class TestStringListDescriptor(TestDescriptor): def setUp(self): et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry> <test-subentry>A01</test-subentry> <test-subentry>B01</test-subentry> </test-entry>""") self.instance1 = Mock(root=et) et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry> <nesting> <test-subentry>A01</test-subentry> <test-subentry>B01</test-subentry> </nesting> </test-entry>""") self.instance2 = Mock(root=et) def test__get__(self): sd = self._make_desc(StringListDescriptor, 'test-subentry') assert sd.__get__(self.instance1, None) == ['A01', 'B01'] sd = self._make_desc(StringListDescriptor, 'test-subentry', nesting=['nesting']) assert sd.__get__(self.instance2, None) == ['A01', 'B01'] def test__set__(self): sd = self._make_desc(StringListDescriptor, 'test-subentry') sd.__set__(self.instance1, ['A02', 'B02']) res = sd.__get__(self.instance1, None) assert isinstance(res, list) assert res == ['A02', 'B02'] class TestStringDictionaryDescriptor(TestDescriptor): def setUp(self): et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry> <test-subentry> <test-firstkey/> <test-secondkey>second value</test-secondkey> </test-subentry> </test-entry>""") self.instance = Mock(root=et) def test__get__(self): sd = self._make_desc(StringDictionaryDescriptor, 'test-subentry') res = sd.__get__(self.instance, None) assert isinstance(res, dict) assert res['test-firstkey'] is None assert res['test-secondkey'] == 'second value' def test__set__(self): sd = self._make_desc(StringDictionaryDescriptor, 'test-subentry') sd.__set__(self.instance, {'mykey1': 'myvalue1'}) res = sd.__get__(self.instance, None) assert isinstance(res, dict) assert res['mykey1'] == 'myvalue1' class TestUdfDictionary(TestCase): def setUp(self): et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry xmlns:udf="http://genologics.com/ri/userdefined"> <udf:field type="String" name="test">stuff</udf:field> <udf:field type="Numeric" name="how much">42</udf:field> <udf:field type="Boolean" name="really?">true</udf:field> </test-entry>""") self.instance1 = Mock(root=et) et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry xmlns:udf="http://genologics.com/ri/userdefined"> <nesting> <udf:field type="String" name="test">stuff</udf:field> <udf:field type="Numeric" name="how much">42</udf:field> <udf:field type="Boolean" name="really?">true</udf:field> </nesting> </test-entry>""") self.instance2 = Mock(root=et) self.dict1 = UdfDictionary(self.instance1) self.dict2 = UdfDictionary(self.instance2, nesting=['nesting']) self.dict_fail = UdfDictionary(self.instance2) self.empty_et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry xmlns:udf="http://genologics.com/ri/userdefined"> </test-entry>""") def _get_udf_value(self, udf_dict, key): for e in udf_dict._elems: if e.attrib['name'] != key: continue else: return e.text def test___getitem__(self): assert self.dict1.__getitem__('test') == self._get_udf_value(self.dict1, 'test') assert self.dict2.__getitem__('test') == self._get_udf_value(self.dict2, 'test') self.assertRaises(KeyError, self.dict_fail.__getitem__, 'test') def test___setitem__(self): assert self._get_udf_value(self.dict1, 'test') == 'stuff' self.dict1.__setitem__('test', 'other') assert self._get_udf_value(self.dict1, 'test') == 'other' assert self._get_udf_value(self.dict1, 'how much') == '42' self.dict1.__setitem__('how much', 21) assert self._get_udf_value(self.dict1, 'how much') == '21' assert self._get_udf_value(self.dict1, 'really?') == 'true' self.dict1.__setitem__('really?', False) assert self._get_udf_value(self.dict1, 'really?') == 'false' self.assertRaises(TypeError, self.dict1.__setitem__, 'how much', '433') # FIXME: I'm not sure if this is the expected behaviour self.dict1.__setitem__('how much', None) assert self._get_udf_value(self.dict1, 'how much') == b'None' assert self._get_udf_value(self.dict2, 'test') == 'stuff' self.dict2.__setitem__('test', 'other') assert self._get_udf_value(self.dict2, 'test') == 'other' def test___setitem__new(self): self.dict1.__setitem__('new string', 'new stuff') assert self._get_udf_value(self.dict1, 'new string') == 'new stuff' self.dict1.__setitem__('new numeric', 21) assert self._get_udf_value(self.dict1, 'new numeric') == '21' self.dict1.__setitem__('new bool', False) assert self._get_udf_value(self.dict1, 'new bool') == 'false' self.dict2.__setitem__('new string', 'new stuff') assert self._get_udf_value(self.dict2, 'new string') == 'new stuff' def test___setitem__unicode(self): assert self._get_udf_value(self.dict1, 'test') == 'stuff' self.dict1.__setitem__('test', u'unicode') assert self._get_udf_value(self.dict1, 'test') == 'unicode' self.dict1.__setitem__(u'test', 'unicode2') assert self._get_udf_value(self.dict1, 'test') == 'unicode2' def test_create(self): instance = Mock(root=self.empty_et) dict1 = UdfDictionary(instance) dict1['test'] = 'value1' assert self._get_udf_value(dict1, 'test') == 'value1' def test_create_with_nesting(self): instance = Mock(root=self.empty_et) dict1 = UdfDictionary(instance, nesting=['cocoon']) dict1['test'] = 'value1' assert self._get_udf_value(dict1, 'test') == 'value1' def test___delitem__(self): assert self.dict1['test'] == self._get_udf_value(self.dict1, 'test') del self.dict1['test'] with pytest.raises(KeyError): _ = self.dict1['test'] assert self._get_udf_value(self.dict1, 'test') is None def test_items(self): pass def test_clear(self): assert self.dict1 self.dict1.clear() assert not self.dict1 assert len(self.dict1) == 0 def test___iter__(self): expected_content = [ ("test", "stuff"), ("really?", True), ("how much", 42) ] for k in self.dict1: assert (k, self.dict1[k]) in expected_content class TestPlacementDictionary(TestDescriptor): def setUp(self): et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry xmlns:udf="http://genologics.com/ri/userdefined"> <placement uri="http://testgenologics.com:4040/api/v2/artifacts/a1" limsid="a1"> <value>A:1</value> </placement> <other>thing</other> </test-entry>""") self.lims = Lims('http://testgenologics.com:4040', username='test', password='password') self.instance1 = Mock(root=et, lims=self.lims) self.dict1 = PlacementDictionary(self.instance1) self.art1 = Artifact(lims=self.lims, id='a1') def test___getitem__(self): assert self.dict1['A:1'] == self.art1 def test___setitem__(self): assert len(self.dict1.rootnode(self.dict1.instance).findall('placement')) == 1 art2 = Artifact(lims=self.lims, id='a2') self.dict1['A:1'] = art2 assert len(self.dict1.rootnode(self.dict1.instance).findall('placement')) == 1 self.dict1['A:2'] = art2 assert len(self.dict1.rootnode(self.dict1.instance).findall('placement')) == 2 assert self.dict1['A:2'] == art2 def test___setitem__2(self): et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry xmlns:udf="http://genologics.com/ri/userdefined"> </test-entry>""") instance = Mock(root=et, lims=self.lims) d = PlacementDictionary(instance) assert len(d.rootnode(d.instance).findall('placement')) == 0 d['A:1'] = self.art1 assert len(d.rootnode(d.instance).findall('placement')) == 1 def test___delitem__(self): assert len(self.dict1.rootnode(self.dict1.instance).findall('placement')) == 1 del self.dict1['A:1'] assert len(self.dict1.rootnode(self.dict1.instance).findall('placement')) == 0 def test_clear(self): sd = self._make_desc(StringDescriptor, 'other') assert sd.__get__(self.instance1, None) == "thing" assert len(self.dict1.rootnode(self.dict1.instance).findall('placement')) == 1 self.dict1.clear() assert len(self.dict1.rootnode(self.dict1.instance).findall('placement')) == 0 assert sd.__get__(self.instance1, None) == "thing" class TestSubTagDictionary(TestCase): def setUp(self): et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry xmlns:udf="http://genologics.com/ri/userdefined"> <test-tag> <key1>value1</key1> </test-tag> </test-entry>""") self.lims = Lims('http://testgenologics.com:4040', username='test', password='password') self.instance1 = Mock(root=et, lims=self.lims) self.dict1 = SubTagDictionary(self.instance1, tag='test-tag') et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry xmlns:udf="http://genologics.com/ri/userdefined"> </test-entry>""") self.instance2 = Mock(root=et, lims=self.lims) self.dict2 = SubTagDictionary(self.instance2, tag='test-tag') def test___getitem__(self): assert self.dict1['key1'] == 'value1' def test___setitem__(self): assert len(self.dict1.rootnode(self.dict1.instance)) == 1 assert self.dict1.rootnode(self.dict1.instance).find('key1').text == 'value1' self.dict1['key1'] = 'value11' assert len(self.dict1.rootnode(self.dict1.instance)) == 1 assert self.dict1.rootnode(self.dict1.instance).find('key1').text == 'value11' self.dict1['key2'] = 'value2' assert len(self.dict1.rootnode(self.dict1.instance)) == 2 assert self.dict1.rootnode(self.dict1.instance).find('key2').text == 'value2' assert self.dict1['key2'] == 'value2' def test___setitem__from_empty(self): assert len(self.dict2.rootnode(self.dict2.instance)) == 0 self.dict2['key1'] = 'value1' assert self.dict2.rootnode(self.dict2.instance).find('key1').text == 'value1' assert len(self.dict2.rootnode(self.dict2.instance)) == 1 class TestXmlElementAttributeDict(TestCase): def setUp(self): et = ElementTree.fromstring("""<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry xmlns:udf="http://genologics.com/ri/userdefined"> <test-tag attrib1="value1" attrib2="value2"/> <test-tag attrib1="value11" attrib2="value12" attrib3="value13"/> </test-entry>""") self.lims = Lims('http://testgenologics.com:4040', username='test', password='password') self.instance1 = Mock(root=et, lims=self.lims) self.dict1 = XmlElementAttributeDict(self.instance1, tag='test-tag', position=0) self.dict2 = XmlElementAttributeDict(self.instance1, tag='test-tag', position=1) def test___getitem__(self): assert self.dict1['attrib1'] == 'value1' assert self.dict2['attrib1'] == 'value11' def test__len__(self): assert len(self.dict1) == 2 assert len(self.dict2) == 3 def test___setitem__(self): assert self.dict1['attrib1'] == 'value1' assert self.dict1.rootnode(self.dict1.instance).findall('test-tag')[0].attrib['attrib1'] == 'value1' self.dict1['attrib1'] = 'value2' assert self.dict1.rootnode(self.dict1.instance).findall('test-tag')[0].attrib['attrib1'] == 'value2' class TestXmlPooledInputDict(TestCase): def setUp(self): et = ElementTree.fromstring('''<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <test-entry> <pooled-inputs> <pool output-uri="{uri}/out1" name="pool1"> <input uri="{uri}/in1"/> <input uri="{uri}/in2"/> </pool> <pool output-uri="{uri}/out2" name="pool2"> <input uri="{uri}/in3"/> <input uri="{uri}/in4"/> </pool> </pooled-inputs> </test-entry>'''.format(uri='http://testgenologics.com:4040')) self.lims = Lims('http://testgenologics.com:4040', username='test', password='password') self.instance1 = Mock(root=et, lims=self.lims) self.dict1 = XmlPooledInputDict(self.instance1) self.out1 = Artifact(self.lims, uri='http://testgenologics.com:4040/out1') self.in1 = Artifact(self.lims, uri='http://testgenologics.com:4040/in1') self.in2 = Artifact(self.lims, uri='http://testgenologics.com:4040/in2') def test___getitem__(self): assert self.dict1['pool1'] == (self.out1, (self.in1, self.in2)) def test___setitem1__(self): assert len(self.dict1) == 2 assert len(self.dict1.rootnode(self.dict1.instance)) == 2 # This works in the test but does not work in reality because # the pool artifact needs to be creaated by the LIMS. self.dict1['pool3'] = (self.out1, (self.in1,
in group.items() if v is not None}) physical_interface_list.append(physical_interface_dict) continue m = p2.match(line) if m: group = m.groupdict() physical_interface_dict.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) continue m = p3.match(line) if m: group = m.groupdict() physical_interface_dict.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) continue m = p4.match(line) if m: group = m.groupdict() physical_interface_dict.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) continue m = p5.match(line) if m: group = m.groupdict() physical_interface_dict.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) continue m = p6.match(line) if m: group = m.groupdict() physical_interface_dict.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) continue m = p7.match(line) if m: group = m.groupdict() if_device_flags = physical_interface_dict.setdefault('if-device-flags', {}) if_device_flags.update({k.replace('_', '-'): True for k, v in group.items() if v is not None}) continue m = p8.match(line) if m: group = m.groupdict() if_config_flags = physical_interface_dict.setdefault('if-config-flags', {}) if_config_flags.update({k.replace('_', '-'): True for k, v in group.items() if v is not None and k != "internal_flags"}) if "internal_flags" in group: if_config_flags.update({"internal-flags": group["internal_flags"]}) continue m = p9.match(line) if m: group = m.groupdict() if_media_flags = physical_interface_dict.setdefault('if-media-flags', {}) if_media_flags.update({k.replace('_', '-'): True for k, v in group.items() if v is not None}) continue m = p10.match(line) if m: group = m.groupdict() phys_cos_info = physical_interface_dict.setdefault('physical-interface-cos-information', {}) phys_cos_info.update({k.replace('_', '-'): v for k, v in group.items() if v is not None}) continue m = p11.match(line) if m: group = m.groupdict() physical_interface_dict.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) continue m = p12.match(line) if m: group = m.groupdict() physical_interface_dict.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) continue m = p13.match(line) if m: group = m.groupdict() physical_interface_dict.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) continue m = p14.match(line) if m: group = m.groupdict() traffic_stats = physical_interface_dict.setdefault('traffic-statistics', {}) traffic_stats.update({k.replace('_', '-'): v for k, v in group.items() if v is not None}) continue m = p15.match(line) if m: group = m.groupdict() traffic_stats.update({k.replace('_', '-'): v for k, v in group.items() if v is not None}) continue m = p16.match(line) if m: group = m.groupdict() physical_interface_dict.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) continue m = p17.match(line) if m: group = m.groupdict() active_alarm = physical_interface_dict.setdefault('active-alarms', {}) interface_alarm = active_alarm.setdefault('interface-alarms', {}) interface_alarm.update({k.replace('_', '-'): True for k, v in group.items() if v is not None}) continue m = p18.match(line) if m: group = m.groupdict() active_alarm = physical_interface_dict.setdefault('active-defects', {}) interface_defect = active_alarm.setdefault('interface-alarms', {}) interface_defect.update({k.replace('_', '-'): True for k, v in group.items() if v is not None}) continue m = p19.match(line) if m: group = m.groupdict() physical_interface_dict.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) continue m = p20.match(line) if m: group = m.groupdict() logical_interface_list = physical_interface_dict.setdefault('logical-interface', []) logical_interface_dict = {} logical_interface_dict.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) logical_interface_list.append(logical_interface_dict) continue m = p21.match(line) if m: group = m.groupdict() if_config_flags = logical_interface_dict.setdefault('if-config-flags', {}) if_config_flags.update({k.replace('_','-'): True for k, v in group.items() if v is not None and k not in [ "encapsulation", "internal_flags"]}) if "encapsulation" in group and group["encapsulation"]: logical_interface_dict.update({"encapsulation": group["encapsulation"]}) if "internal_flags" in group and group["internal_flags"]: if_config_flags.update({"internal-flags": group["internal_flags"]}) continue m = p22.match(line) if m: group = m.groupdict() traffic_stats = logical_interface_dict.setdefault('traffic-statistics', {}) traffic_stats.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) continue m = p23.match(line) if m: group = m.groupdict() traffic_stats.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) continue m = p24.match(line) if m: group = m.groupdict() logical_interface_dict.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) continue m = p25.match(line) if m: group = m.groupdict() allowed_in_traffic = logical_interface_dict.setdefault('allowed-host-inbound-traffic', {}) allowed_in_traffic.update({k.replace('_','-'): True for k, v in group.items() if v is not None}) continue m = p26.match(line) if m: group = m.groupdict() address_family_list = logical_interface_dict.setdefault('address-family', []) address_family_dict = {} address_family_dict.update({k.replace('_','-'): v for k, v in group.items() if v is not None}) address_family_list.append(address_family_dict) continue m = p27.match(line) if m: group = m.groupdict() address_family_flags = address_family_dict.setdefault('address-family-flags', {}) address_family_flags.update({k.replace('_','-'): True for k, v in group.items() if v is not None}) continue m = p28.match(line) if m: group = m.groupdict() interface_address_list = address_family_dict.setdefault('interface-address', []) interface_address_dict = {} ifa_flags = interface_address_dict.setdefault('ifa-flags', {}) if 'flags' in group and group['flags']: flags = group['flags'].split(' ') ifa_flags.update({"ifaf-current-{}".format(f.split('-')[-1].lower()): True for f in flags}) interface_address_list.append(interface_address_dict) continue m = p29.match(line) if m: group = m.groupdict() if group['ifa_destination']: interface_address_dict.update({'ifa-destination': group['ifa_destination']}) if group['ifa_local']: interface_address_dict.update({'ifa-local': group['ifa_local']}) if group['ifa_broadcast']: interface_address_dict.update({'ifa-broadcast': group['ifa_broadcast']}) continue return ret_dict # ======================================================= # Schema for 'show interfaces policers {interface}' # ======================================================= class ShowInterfacesPolicersInterfaceSchema(MetaParser): """Schema for show interfaces policers {interface}""" '''schema = { Optional("@xmlns:junos"): str, "interface-policer-information": { Optional("@junos:style"): str, Optional("@xmlns"): str, "physical-interface": [ "admin-status": str, "logical-interface": [ "admin-status": str, "name": str, "oper-status": str, "policer-information": [ { "policer-family": str, "policer-input": str, "policer-output": str } ] ], "name": str, "oper-status": str ] } }''' def validate_policer_information_list(value): # Pass ospf3-interface list as value if not isinstance(value, list): raise SchemaError('policer-information is not a list') policer_information_schema = Schema({ "policer-family": str, "policer-input": str, Optional("policer-output"): Or(str,None) }) # Validate each dictionary in list for item in value: policer_information_schema.validate(item) return value def validate_logical_interface_list(value): # Pass ospf3-interface list as value if not isinstance(value, list): raise SchemaError('logical-interface is not a list') logical_interface_schema = Schema({ "admin-status": str, "name": str, "oper-status": str, "policer-information": Use(ShowInterfacesPolicersInterface.validate_policer_information_list) }) # Validate each dictionary in list for item in value: logical_interface_schema.validate(item) return value def validate_physical_interface_list(value): # Pass ospf3-interface list as value if not isinstance(value, list): raise SchemaError('physical-interface is not a list') physical_interface_schema = Schema({ "admin-status": str, "logical-interface": Use(ShowInterfacesPolicersInterface.validate_logical_interface_list), "name": str, "oper-status": str }) # Validate each dictionary in list for item in value: physical_interface_schema.validate(item) return value schema = { Optional("@xmlns:junos"): str, "interface-policer-information": { Optional("@junos:style"): str, Optional("@xmlns"): str, "physical-interface": Use(validate_physical_interface_list) } } # ======================================================= # Parser for 'show interfaces policers {interface}' # ======================================================= class ShowInterfacesPolicersInterface(ShowInterfacesPolicersInterfaceSchema): """ Parser for: - show interfaces policers {interface} """ cli_command = 'show interfaces policers {interface}' def cli(self, interface=None, output=None): # execute the command if output is None: out = self.device.execute(self.cli_command.format(interface=interface)) else: out = output ret_dict = {} # ge-0/0/2 up up p1 = re.compile(r'^(?P<interface>[a-zA-Z\-\d\/]+)((?P<physical_interface_value>[\.\d]+))? +(?P<admin>\w+) +(?:(?P<link>\w+))?$') # inet GE_1M-ge-0/0/2.0-log_int-i GE_1M-ge-0/0/2.0-log_int-o # multiservice __default_arp_policer__ p2 = re.compile(r'^(?P<policer_family>\w+) +(?P<policer_input>\S+)( +((?P<policer_output>\S+)))?$') for line in out.splitlines(): line = line.strip() # ge-0/0/2 up up # ge-0/0/2.0 up up m = p1.match(line) if m: interface_policer_info = ret_dict.setdefault( "interface-policer-information", {}).setdefault("physical-interface",[]) #logical_interface_list = interface_policer_info.setdefault("logical-interface",[]) #policer_information_list = logical_interface_list.setdefault("policer-information", []) exists = False policer_information_list = None group = m.groupdict() for group_key, group_value in group.items(): if group_key == "physical_interface_value": if group_value != None: exists = True if exists: logical_interface_dict['name'] = group['interface'] + group['physical_interface_value'] logical_interface_dict['admin-status'] = group['admin'] logical_interface_dict['oper-status'] = group['link'] policer_information_list = [] logical_interface_dict["policer-information"] = policer_information_list logical_interface_list.append(logical_interface_dict) interface_policer_info_dict['logical-interface'] = logical_interface_list interface_policer_info.append(interface_policer_info_dict) else: logical_interface_list = [] logical_interface_dict = {} interface_policer_info_dict= {} interface_policer_info_dict['name'] = group['interface'] interface_policer_info_dict['admin-status'] = group['admin'] interface_policer_info_dict['oper-status'] = group['link'] # inet GE_1M-ge-0/0/2.0-log_int-i GE_1M-ge-0/0/2.0-log_int-o # multiservice __default_arp_policer__ m = p2.match(line) if m: group = m.groupdict() policer_information_dict = {} policer_information_dict['policer-family'] = group['policer_family'] policer_information_dict['policer-input'] = group['policer_input'] for group_key, group_value in group.items(): if group_key == "policer_output": if group_value != None: policer_information_dict['policer-output'] = group['policer_output'] policer_information_list.append(policer_information_dict) exists = False return ret_dict # ======================================================= # Schema for 'show interfaces queue {interface}' # ======================================================= class ShowInterfacesQueueSchema(MetaParser): """ Schema for: * show interfaces queue {interface} """ def validate_queue(value): if not isinstance(value, list): raise SchemaError('queue is not a list') queue_schema = Schema( { "forwarding-class-name": str, "queue-counters-queued-bytes": str, "queue-counters-queued-bytes-rate": str, "queue-counters-queued-packets": str, "queue-counters-queued-packets-rate": str, "queue-counters-red-bytes": str, "queue-counters-red-bytes-high": str, "queue-counters-red-bytes-low": str, "queue-counters-red-bytes-medium-high": str, "queue-counters-red-bytes-medium-low": str, "queue-counters-red-bytes-rate": str, "queue-counters-red-bytes-rate-high": str, "queue-counters-red-bytes-rate-low": str, "queue-counters-red-bytes-rate-medium-high": str, "queue-counters-red-bytes-rate-medium-low": str, "queue-counters-red-packets": str, "queue-counters-red-packets-high": str, "queue-counters-red-packets-low": str, "queue-counters-red-packets-medium-high": str, "queue-counters-red-packets-medium-low": str, "queue-counters-red-packets-rate": str, "queue-counters-red-packets-rate-high": str, "queue-counters-red-packets-rate-low": str, "queue-counters-red-packets-rate-medium-high": str, "queue-counters-red-packets-rate-medium-low": str, "queue-counters-tail-drop-packets": str, "queue-counters-tail-drop-packets-rate": str, Optional("queue-counters-rl-drop-packets"): str, Optional("queue-counters-rl-drop-packets-rate"): str, Optional("queue-counters-rl-drop-bytes"): str, Optional("queue-counters-rl-drop-bytes-rate"): str, "queue-counters-trans-bytes": str, "queue-counters-trans-bytes-rate": str, "queue-counters-trans-packets": str, "queue-counters-trans-packets-rate": str, "queue-number": str } ) for item in value: queue_schema.validate(item) return value schema = { "interface-information": { "physical-interface": { Optional("description"): str, "local-index": str, "snmp-index": str, "name": str, "oper-status": str, "queue-counters": { "interface-cos-summary": { "intf-cos-forwarding-classes-in-use": str, "intf-cos-forwarding-classes-supported": str, "intf-cos-num-queues-in-use": str,
# -*- coding: utf-8 -*- from __future__ import absolute_import from . import http import time from . import util from . import exceptions from . import compat from . import verlib import re import json from xml.etree import ElementTree from . import signalsmixin from . import plexobjects from . import plexresource from . import plexlibrary from . import asyncadapter from six.moves import range # from plexapi.client import Client # from plexapi.playqueue import PlayQueue TOTAL_QUERIES = 0 DEFAULT_BASEURI = 'http://localhost:32400' class PlexServer(plexresource.PlexResource, signalsmixin.SignalsMixin): TYPE = 'PLEXSERVER' def __init__(self, data=None): signalsmixin.SignalsMixin.__init__(self) plexresource.PlexResource.__init__(self, data) self.accessToken = None self.multiuser = False self.isSupported = None self.hasFallback = False self.supportsAudioTranscoding = False self.supportsVideoTranscoding = False self.supportsPhotoTranscoding = False self.supportsVideoRemuxOnly = False self.supportsScrobble = True self.allowsMediaDeletion = False self.allowChannelAccess = False self.activeConnection = None self.serverClass = None self.pendingReachabilityRequests = 0 self.pendingSecureRequests = 0 self.features = {} self.librariesByUuid = {} self.server = self self.session = http.Session() self.owner = None self.owned = False self.synced = False self.sameNetwork = False self.uuid = None self.name = None self.platform = None self.versionNorm = None self.rawVersion = None self.transcodeSupport = False if data is None: return self.owner = data.attrib.get('sourceTitle') self.owned = data.attrib.get('owned') == '1' self.synced = data.attrib.get('synced') == '1' self.sameNetwork = data.attrib.get('publicAddressMatches') == '1' self.uuid = data.attrib.get('clientIdentifier') self.name = data.attrib.get('name') self.platform = data.attrib.get('platform') self.rawVersion = data.attrib.get('productVersion') self.versionNorm = util.normalizedVersion(self.rawVersion) self.transcodeSupport = data.attrib.get('transcodeSupport') == '1' def __eq__(self, other): if not other: return False if self.__class__ != other.__class__: return False return self.uuid == other.uuid and self.owner == other.owner def __ne__(self, other): return not self.__eq__(other) def __str__(self): return "<PlexServer {0} owned: {1} uuid: {2} version: {3}>".format(repr(self.name), self.owned, self.uuid, self.versionNorm) def __repr__(self): return self.__str__() def close(self): self.session.cancel() def get(self, attr, default=None): return default @property def isSecure(self): if self.activeConnection: return self.activeConnection.isSecure def getObject(self, key): data = self.query(key) return plexobjects.buildItem(self, data[0], key, container=self) def hubs(self, section=None, count=None, search_query=None): hubs = [] params = {"includeMarkers": 1} if search_query: q = '/hubs/search' params['query'] = search_query.lower() if section: params['sectionId'] = section if count is not None: params['limit'] = count else: q = '/hubs' if section: if section == 'playlists': audio = plexlibrary.AudioPlaylistHub(False, server=self.server) video = plexlibrary.VideoPlaylistHub(False, server=self.server) if audio.items: hubs.append(audio) if video.items: hubs.append(video) return hubs else: q = '/hubs/sections/%s' % section if count is not None: params['count'] = count data = self.query(q, params=params) container = plexobjects.PlexContainer(data, initpath=q, server=self, address=q) for elem in data: hubs.append(plexlibrary.Hub(elem, server=self, container=container)) return hubs def playlists(self, start=0, size=10, hub=None): try: return plexobjects.listItems(self, '/playlists/all') except exceptions.BadRequest: return None @property def library(self): if self.platform == 'cloudsync': return plexlibrary.Library(None, server=self) else: return plexlibrary.Library(self.query('/library/'), server=self) def buildUrl(self, path, includeToken=False): if self.activeConnection: return self.activeConnection.buildUrl(self, path, includeToken) else: util.WARN_LOG("Server connection is None, returning an empty url") return "" def query(self, path, method=None, **kwargs): method = method or self.session.get url = self.buildUrl(path, includeToken=True) # If URL is empty, try refresh resources and return empty set for now if not url: util.WARN_LOG("Empty server url, returning None and refreshing resources") util.MANAGER.refreshResources(True) return None util.LOG('{0} {1}'.format(method.__name__.upper(), re.sub('X-Plex-Token=[^&]+', 'X-Plex-Token=****', url))) try: response = method(url, **kwargs) if response.status_code not in (200, 201): codename = http.status_codes.get(response.status_code, ['Unknown'])[0] raise exceptions.BadRequest('({0}) {1}'.format(response.status_code, codename)) data = response.text.encode('utf8') except asyncadapter.TimeoutException: util.ERROR() util.MANAGER.refreshResources(True) return None except http.requests.ConnectionError: util.ERROR() return None except asyncadapter.CanceledException: return None return ElementTree.fromstring(data) if data else None def getImageTranscodeURL(self, path, width, height, **extraOpts): if not path: return '' params = ("&width=%s&height=%s" % (width, height)) + ''.join(["&%s=%s" % (key, extraOpts[key]) for key in extraOpts]) if "://" in path: imageUrl = self.convertUrlToLoopBack(path) else: imageUrl = "http://127.0.0.1:" + self.getLocalServerPort() + path path = "/photo/:/transcode?url=" + compat.quote_plus(imageUrl) + params # Try to use a better server to transcode for synced servers if self.synced: from . import plexservermanager selectedServer = plexservermanager.MANAGER.getTranscodeServer("photo") if selectedServer: return selectedServer.buildUrl(path, True) if self.activeConnection: return self.activeConnection.simpleBuildUrl(self, path) else: util.WARN_LOG("Server connection is None, returning an empty url") return "" def isReachable(self, onlySupported=True): if onlySupported and not self.isSupported: return False return self.activeConnection and self.activeConnection.state == plexresource.ResourceConnection.STATE_REACHABLE def isLocalConnection(self): return self.activeConnection and (self.sameNetwork or self.activeConnection.isLocal) def isRequestToServer(self, url): if not self.activeConnection: return False if ':' in self.activeConnection.address[8:]: schemeAndHost = self.activeConnection.address.rsplit(':', 1)[0] else: schemeAndHost = self.activeConnection.address return url.startswith(schemeAndHost) def getToken(self): # It's dangerous to use for each here, because it may reset the index # on self.connections when something else was in the middle of an iteration. for i in range(len(self.connections)): conn = self.connections[i] if conn.token: return conn.token return None def getLocalServerPort(self): # TODO(schuyler): The correct thing to do here is to iterate over local # connections and pull out the port. For now, we're always returning 32400. return '32400' def collectDataFromRoot(self, data): # Make sure we're processing data for our server, and not some other # server that happened to be at the same IP. if self.uuid != data.attrib.get('machineIdentifier'): util.LOG("Got a reachability response, but from a different server") return False self.serverClass = data.attrib.get('serverClass') self.supportsAudioTranscoding = data.attrib.get('transcoderAudio') == '1' self.supportsVideoTranscoding = data.attrib.get('transcoderVideo') == '1' or data.attrib.get('transcoderVideoQualities') self.supportsVideoRemuxOnly = data.attrib.get('transcoderVideoRemuxOnly') == '1' self.supportsPhotoTranscoding = data.attrib.get('transcoderPhoto') == '1' or ( not data.attrib.get('transcoderPhoto') and not self.synced and not self.isSecondary() ) self.allowChannelAccess = data.attrib.get('allowChannelAccess') == '1' or ( not data.attrib.get('allowChannelAccess') and self.owned and not self.synced and not self.isSecondary() ) self.supportsScrobble = not self.isSecondary() or self.synced self.allowsMediaDeletion = not self.synced and self.owned and data.attrib.get('allowMediaDeletion') == '1' self.multiuser = data.attrib.get('multiuser') == '1' self.name = data.attrib.get('friendlyName') or self.name self.platform = data.attrib.get('platform') # TODO(schuyler): Process transcoder qualities self.rawVersion = data.attrib.get('version') if self.rawVersion: self.versionNorm = util.normalizedVersion(self.rawVersion) features = { 'mkvTranscode': '0.9.11.11', 'themeTranscode': '0.9.14.0', 'allPartsStreamSelection': '0.9.12.5', 'claimServer': '0.9.14.2', 'streamingBrain': '1.2.0' } for f, v in features.items(): if util.normalizedVersion(v) <= self.versionNorm: self.features[f] = True appMinVer = util.INTERFACE.getGlobal('minServerVersionArr', '0.0.0.0') self.isSupported = self.isSecondary() or util.normalizedVersion(appMinVer) <= self.versionNorm util.DEBUG_LOG("Server information updated from reachability check: {0}".format(self)) return True def updateReachability(self, force=True, allowFallback=False): if not force and self.activeConnection and self.activeConnection.state != plexresource.ResourceConnection.STATE_UNKNOWN: return util.LOG('Updating reachability for {0}: conns={1}, allowFallback={2}'.format(repr(self.name), len(self.connections), allowFallback)) epoch = time.time() retrySeconds = 60 minSeconds = 10 for i in range(len(self.connections)): conn = self.connections[i] diff = epoch - (conn.lastTestedAt or 0) if conn.hasPendingRequest: util.DEBUG_LOG("Skip reachability test for {0} (has pending request)".format(conn)) elif diff < minSeconds or (not self.isSecondary() and self.isReachable() and diff < retrySeconds): util.DEBUG_LOG("Skip reachability test for {0} (checked {1} secs ago)".format(conn, diff)) elif conn.testReachability(self, allowFallback): self.pendingReachabilityRequests += 1 if conn.isSecure: self.pendingSecureRequests += 1 if self.pendingReachabilityRequests == 1: self.trigger("started:reachability") if self.pendingReachabilityRequests <= 0: self.trigger("completed:reachability") def cancelReachability(self): for i in range(len(self.connections)): conn = self.connections[i] conn.cancelReachability() def onReachabilityResult(self, connection): connection.lastTestedAt = time.time() connection.hasPendingRequest = None self.pendingReachabilityRequests -= 1 if connection.isSecure: self.pendingSecureRequests -= 1 util.DEBUG_LOG("Reachability result for {0}: {1} is {2}".format(repr(self.name), connection.address, connection.state)) # Noneate active connection if the state is unreachable if self.activeConnection and self.activeConnection.state != plexresource.ResourceConnection.STATE_REACHABLE: self.activeConnection = None # Pick a best connection. If we already had an active connection and # it's still reachable, stick with it. (replace with local if # available) best = self.activeConnection for i in range(len(self.connections) - 1, -1, -1): conn = self.connections[i] if not best or conn.getScore() > best.getScore(): best = conn if best and best.state == best.STATE_REACHABLE: if best.isSecure or self.pendingSecureRequests <= 0: self.activeConnection = best else: util.DEBUG_LOG("Found a good connection for {0}, but holding out for better".format(repr(self.name))) if self.pendingReachabilityRequests <= 0: # Retest the server with fallback enabled. hasFallback will only # be True if there are available insecure connections and fallback # is allowed. if self.hasFallback: self.updateReachability(False, True) else: self.trigger("completed:reachability") util.LOG("Active connection for {0} is {1}".format(repr(self.name), self.activeConnection)) from . import plexservermanager plexservermanager.MANAGER.updateReachabilityResult(self, bool(self.activeConnection)) def markAsRefreshing(self): for i in range(len(self.connections)): conn = self.connections[i] conn.refreshed = False def markUpdateFinished(self, source): # Any connections for the given source which haven't been refreshed should # be removed. Since removing from a list is hard, we'll make a new list. toKeep = [] hasSecureConn = False for i in range(len(self.connections)): conn = self.connections[i] if not conn.refreshed: conn.sources = conn.sources & (~source) # If we lost our plex.tv connection, don't remember the token. if source == conn.SOURCE_MYPLEX: conn.token = None if conn.sources: if conn.address[:5] == "https": hasSecureConn = True toKeep.append(conn) else: util.DEBUG_LOG("Removed connection for {0} after updating connections for {1}".format(repr(self.name), source)) if conn == self.activeConnection: util.DEBUG_LOG("Active connection lost")
this entity from a cached registry Returns: Returns either the specified entity, or raises an exception if none is found """ registry_proto = self._get_registry_proto(allow_cache=allow_cache) for entity_proto in registry_proto.entities: if entity_proto.spec.name == name and entity_proto.spec.project == project: return Entity.from_proto(entity_proto) raise EntityNotFoundException(name, project=project) def apply_feature_view( self, feature_view: BaseFeatureView, project: str, commit: bool = True ): """ Registers a single feature view with Feast Args: feature_view: Feature view that will be registered project: Feast project that this feature view belongs to commit: Whether the change should be persisted immediately """ feature_view.ensure_valid() now = datetime.utcnow() if not feature_view.created_timestamp: feature_view.created_timestamp = now feature_view.last_updated_timestamp = now feature_view_proto = feature_view.to_proto() feature_view_proto.spec.project = project self._prepare_registry_for_changes() assert self.cached_registry_proto self._check_conflicting_feature_view_names(feature_view) existing_feature_views_of_same_type: RepeatedCompositeFieldContainer if isinstance(feature_view, FeatureView): existing_feature_views_of_same_type = ( self.cached_registry_proto.feature_views ) elif isinstance(feature_view, OnDemandFeatureView): existing_feature_views_of_same_type = ( self.cached_registry_proto.on_demand_feature_views ) elif isinstance(feature_view, RequestFeatureView): existing_feature_views_of_same_type = ( self.cached_registry_proto.request_feature_views ) else: raise ValueError(f"Unexpected feature view type: {type(feature_view)}") for idx, existing_feature_view_proto in enumerate( existing_feature_views_of_same_type ): if ( existing_feature_view_proto.spec.name == feature_view_proto.spec.name and existing_feature_view_proto.spec.project == project ): if ( feature_view.__class__.from_proto(existing_feature_view_proto) == feature_view ): return else: del existing_feature_views_of_same_type[idx] break existing_feature_views_of_same_type.append(feature_view_proto) if commit: self.commit() def list_on_demand_feature_views( self, project: str, allow_cache: bool = False ) -> List[OnDemandFeatureView]: """ Retrieve a list of on demand feature views from the registry Args: project: Filter on demand feature views based on project name allow_cache: Whether to allow returning on demand feature views from a cached registry Returns: List of on demand feature views """ registry = self._get_registry_proto(allow_cache=allow_cache) on_demand_feature_views = [] for on_demand_feature_view in registry.on_demand_feature_views: if on_demand_feature_view.spec.project == project: on_demand_feature_views.append( OnDemandFeatureView.from_proto(on_demand_feature_view) ) return on_demand_feature_views def get_on_demand_feature_view( self, name: str, project: str, allow_cache: bool = False ) -> OnDemandFeatureView: """ Retrieves an on demand feature view. Args: name: Name of on demand feature view project: Feast project that this on demand feature view belongs to allow_cache: Whether to allow returning this on demand feature view from a cached registry Returns: Returns either the specified on demand feature view, or raises an exception if none is found """ registry = self._get_registry_proto(allow_cache=allow_cache) for on_demand_feature_view in registry.on_demand_feature_views: if ( on_demand_feature_view.spec.project == project and on_demand_feature_view.spec.name == name ): return OnDemandFeatureView.from_proto(on_demand_feature_view) raise OnDemandFeatureViewNotFoundException(name, project=project) def get_data_source( self, name: str, project: str, allow_cache: bool = False ) -> DataSource: """ Retrieves a data source. Args: name: Name of data source project: Feast project that this data source belongs to allow_cache: Whether to allow returning this data source from a cached registry Returns: Returns either the specified data source, or raises an exception if none is found """ registry = self._get_registry_proto(allow_cache=allow_cache) for data_source in registry.data_sources: if data_source.project == project and data_source.name == name: return DataSource.from_proto(data_source) raise DataSourceObjectNotFoundException(name, project=project) def apply_materialization( self, feature_view: FeatureView, project: str, start_date: datetime, end_date: datetime, commit: bool = True, ): """ Updates materialization intervals tracked for a single feature view in Feast Args: feature_view: Feature view that will be updated with an additional materialization interval tracked project: Feast project that this feature view belongs to start_date (datetime): Start date of the materialization interval to track end_date (datetime): End date of the materialization interval to track commit: Whether the change should be persisted immediately """ self._prepare_registry_for_changes() assert self.cached_registry_proto for idx, existing_feature_view_proto in enumerate( self.cached_registry_proto.feature_views ): if ( existing_feature_view_proto.spec.name == feature_view.name and existing_feature_view_proto.spec.project == project ): existing_feature_view = FeatureView.from_proto( existing_feature_view_proto ) existing_feature_view.materialization_intervals.append( (start_date, end_date) ) existing_feature_view.last_updated_timestamp = datetime.utcnow() feature_view_proto = existing_feature_view.to_proto() feature_view_proto.spec.project = project del self.cached_registry_proto.feature_views[idx] self.cached_registry_proto.feature_views.append(feature_view_proto) if commit: self.commit() return raise FeatureViewNotFoundException(feature_view.name, project) def list_feature_views( self, project: str, allow_cache: bool = False ) -> List[FeatureView]: """ Retrieve a list of feature views from the registry Args: allow_cache: Allow returning feature views from the cached registry project: Filter feature views based on project name Returns: List of feature views """ registry_proto = self._get_registry_proto(allow_cache=allow_cache) feature_views: List[FeatureView] = [] for feature_view_proto in registry_proto.feature_views: if feature_view_proto.spec.project == project: feature_views.append(FeatureView.from_proto(feature_view_proto)) return feature_views def list_request_feature_views( self, project: str, allow_cache: bool = False ) -> List[RequestFeatureView]: """ Retrieve a list of request feature views from the registry Args: allow_cache: Allow returning feature views from the cached registry project: Filter feature views based on project name Returns: List of feature views """ registry_proto = self._get_registry_proto(allow_cache=allow_cache) feature_views: List[RequestFeatureView] = [] for request_feature_view_proto in registry_proto.request_feature_views: if request_feature_view_proto.spec.project == project: feature_views.append( RequestFeatureView.from_proto(request_feature_view_proto) ) return feature_views def get_feature_view( self, name: str, project: str, allow_cache: bool = False ) -> FeatureView: """ Retrieves a feature view. Args: name: Name of feature view project: Feast project that this feature view belongs to allow_cache: Allow returning feature view from the cached registry Returns: Returns either the specified feature view, or raises an exception if none is found """ registry_proto = self._get_registry_proto(allow_cache=allow_cache) for feature_view_proto in registry_proto.feature_views: if ( feature_view_proto.spec.name == name and feature_view_proto.spec.project == project ): return FeatureView.from_proto(feature_view_proto) raise FeatureViewNotFoundException(name, project) def delete_feature_service(self, name: str, project: str, commit: bool = True): """ Deletes a feature service or raises an exception if not found. Args: name: Name of feature service project: Feast project that this feature service belongs to commit: Whether the change should be persisted immediately """ self._prepare_registry_for_changes() assert self.cached_registry_proto for idx, feature_service_proto in enumerate( self.cached_registry_proto.feature_services ): if ( feature_service_proto.spec.name == name and feature_service_proto.spec.project == project ): del self.cached_registry_proto.feature_services[idx] if commit: self.commit() return raise FeatureServiceNotFoundException(name, project) def delete_feature_view(self, name: str, project: str, commit: bool = True): """ Deletes a feature view or raises an exception if not found. Args: name: Name of feature view project: Feast project that this feature view belongs to commit: Whether the change should be persisted immediately """ self._prepare_registry_for_changes() assert self.cached_registry_proto for idx, existing_feature_view_proto in enumerate( self.cached_registry_proto.feature_views ): if ( existing_feature_view_proto.spec.name == name and existing_feature_view_proto.spec.project == project ): del self.cached_registry_proto.feature_views[idx] if commit: self.commit() return for idx, existing_request_feature_view_proto in enumerate( self.cached_registry_proto.request_feature_views ): if ( existing_request_feature_view_proto.spec.name == name and existing_request_feature_view_proto.spec.project == project ): del self.cached_registry_proto.request_feature_views[idx] if commit: self.commit() return for idx, existing_on_demand_feature_view_proto in enumerate( self.cached_registry_proto.on_demand_feature_views ): if ( existing_on_demand_feature_view_proto.spec.name == name and existing_on_demand_feature_view_proto.spec.project == project ): del self.cached_registry_proto.on_demand_feature_views[idx] if commit: self.commit() return raise FeatureViewNotFoundException(name, project) def delete_entity(self, name: str, project: str, commit: bool = True): """ Deletes an entity or raises an exception if not found. Args: name: Name of entity project: Feast project that this entity belongs to commit: Whether the change should be persisted immediately """ self._prepare_registry_for_changes() assert self.cached_registry_proto for idx, existing_entity_proto in enumerate( self.cached_registry_proto.entities ): if ( existing_entity_proto.spec.name == name and existing_entity_proto.spec.project == project ): del self.cached_registry_proto.entities[idx] if commit: self.commit() return raise EntityNotFoundException(name, project) def apply_saved_dataset( self, saved_dataset: SavedDataset, project: str, commit: bool = True, ): """ Registers a single entity with Feast Args: saved_dataset: SavedDataset that will be added / updated to registry project: Feast project that this dataset belongs to commit: Whether the change should be persisted immediately """ now = datetime.utcnow() if not saved_dataset.created_timestamp: saved_dataset.created_timestamp = now saved_dataset.last_updated_timestamp = now saved_dataset_proto = saved_dataset.to_proto() saved_dataset_proto.spec.project = project self._prepare_registry_for_changes() assert self.cached_registry_proto for idx, existing_saved_dataset_proto in enumerate( self.cached_registry_proto.saved_datasets ): if ( existing_saved_dataset_proto.spec.name == saved_dataset_proto.spec.name and existing_saved_dataset_proto.spec.project == project ): del self.cached_registry_proto.saved_datasets[idx] break self.cached_registry_proto.saved_datasets.append(saved_dataset_proto) if commit: self.commit() def get_saved_dataset( self, name: str, project: str, allow_cache: bool = False ) -> SavedDataset: """ Retrieves a saved dataset. Args: name: Name of dataset project: Feast project that this dataset belongs to allow_cache: Whether to allow returning this dataset from a cached registry Returns: Returns either the specified SavedDataset, or raises an exception if none is found """ registry_proto = self._get_registry_proto(allow_cache=allow_cache) for saved_dataset in registry_proto.saved_datasets: if ( saved_dataset.spec.name == name and saved_dataset.spec.project == project ): return SavedDataset.from_proto(saved_dataset) raise SavedDatasetNotFound(name, project=project) def list_saved_datasets( self, project: str, allow_cache: bool = False ) -> List[SavedDataset]: """ Retrieves a list of all saved datasets in specified project Args: project: Feast project allow_cache: Whether to allow returning this dataset from a cached registry Returns: Returns the list of SavedDatasets """ registry_proto = self._get_registry_proto(allow_cache=allow_cache) return [ SavedDataset.from_proto(saved_dataset) for saved_dataset in registry_proto.saved_datasets if saved_dataset.spec.project == project ] def commit(self): """Commits the state of the registry cache to the remote registry store."""
# Licensed under an MIT style license -- see LICENSE.md import numpy as np from matplotlib import gridspec from scipy.stats import gaussian_kde import copy from pesummary.core.plots.figure import figure from .corner import hist2d from pesummary import conf __author__ = ["<NAME> <<EMAIL>>"] DEFAULT_LEGEND_KWARGS = {"loc": "best", "frameon": False} def pcolormesh( x, y, density, ax=None, levels=None, smooth=None, bins=None, label=None, level_kwargs={}, range=None, grid=True, legend=False, legend_kwargs={}, **kwargs ): """Generate a colormesh plot on a given axis Parameters ---------- x: np.ndarray array of floats for the x axis y: np.ndarray array of floats for the y axis density: np.ndarray 2d array of probabilities ax: matplotlib.axes._subplots.AxesSubplot, optional axis you wish to use for plotting levels: list, optional contour levels to show on the plot. Default None smooth: float, optional sigma to use for smoothing. Default, no smoothing applied level_kwargs: dict, optional optional kwargs to use for ax.contour **kwargs: dict, optional all additional kwargs passed to ax.pcolormesh """ if smooth is not None: import scipy.ndimage.filters as filter density = filter.gaussian_filter(density, sigma=smooth) _cmap = kwargs.get("cmap", None) _off = False if _cmap is not None and isinstance(_cmap, str) and _cmap.lower() == "off": _off = True if grid and "zorder" not in kwargs: _zorder = -10 else: _zorder = kwargs.pop("zorder", 10) if not _off: ax.pcolormesh(x, y, density, zorder=_zorder, **kwargs) if levels is not None: CS = ax.contour(x, y, density, levels=levels, **level_kwargs) if legend: _legend_kwargs = DEFAULT_LEGEND_KWARGS.copy() _legend_kwargs.update(legend_kwargs) CS.collections[0].set_label(label) ax.legend(**_legend_kwargs) return ax def analytic_twod_contour_plot(*args, smooth=None, **kwargs): """Generate a 2d contour plot given an analytic PDF Parameters ---------- *args: tuple all args passed to twod_contour_plot smooth: float, optional degree of smoothing to apply to probabilities **kwargs: dict, optional all additional kwargs passed to twod_contour_plot """ return twod_contour_plot( *args, smooth=smooth, _function=pcolormesh, **kwargs ) def twod_contour_plot( x, y, *args, rangex=None, rangey=None, fig=None, ax=None, return_ax=False, levels=[0.9], bins=300, smooth=7, xlabel=None, ylabel=None, fontsize={"label": 12}, grid=True, label=None, truth=None, _function=hist2d, truth_lines=True, truth_kwargs={}, _default_truth_kwargs={ "marker": 'o', "markeredgewidth": 2, "markersize": 6, "color": 'k' }, **kwargs ): """Generate a 2d contour contour plot for 2 marginalized posterior distributions Parameters ---------- x: np.array array of posterior samples to use for the x axis y: np.array array of posterior samples to use for the y axis rangex: tuple, optional range over which to plot the x axis rangey: tuple, optional range over which to plot the y axis fig: matplotlib.figure.Figure, optional figure you wish to use for plotting ax: matplotlib.axes._subplots.AxesSubplot, optional axis you wish to use for plotting return_ax: Bool, optional if True return the axis used for plotting. Else return the figure levels: list, optional levels you wish to use for the 2d contours. Default [0.9] bins: int, optional number of bins to use for gridding 2d parameter space. Default 300 smooth: int, optional how much smoothing you wish to use for the 2d contours xlabel: str, optional label to use for the xaxis ylabel: str, optional label to use for the yaxis fontsize: dict, optional dictionary containing the fontsize to use for the plot grid: Bool, optional if True, add a grid to the plot label: str, optional label to use for a given contour truth: list, optional the true value of the posterior. `truth` is a list of length 2 with first element being the true x value and second element being the true y value truth_lines: Bool, optional if True, add vertical and horizontal lines spanning the 2d space to show injected value truth_kwargs: dict, optional kwargs to use to indicate truth **kwargs: dict, optional all additional kwargs are passed to the `pesummary.core.plots.corner.hist2d` function """ if fig is None and ax is None: fig, ax = figure(gca=True) elif fig is None and ax is not None: return_ax = True elif ax is None: ax = fig.gca() xlow, xhigh = np.min(x), np.max(x) ylow, yhigh = np.min(y), np.max(y) if rangex is not None: xlow, xhigh = rangex if rangey is not None: ylow, yhigh = rangey if "range" not in list(kwargs.keys()): kwargs["range"] = [[xlow, xhigh], [ylow, yhigh]] _function( x, y, *args, ax=ax, levels=levels, bins=bins, smooth=smooth, label=label, grid=grid, **kwargs ) if truth is not None: _default_truth_kwargs.update(truth_kwargs) ax.plot(*truth, **_default_truth_kwargs) if truth_lines: ax.axvline( truth[0], color=_default_truth_kwargs["color"], linewidth=0.5 ) ax.axhline( truth[1], color=_default_truth_kwargs["color"], linewidth=0.5 ) if xlabel is not None: ax.set_xlabel(xlabel, fontsize=fontsize["label"]) if ylabel is not None: ax.set_ylabel(ylabel, fontsize=fontsize["label"]) ax.grid(grid) if fig is not None: fig.tight_layout() if return_ax: return ax return fig def comparison_twod_contour_plot( x, y, labels=None, plot_density=None, rangex=None, rangey=None, legend_kwargs={"loc": "best", "frameon": False}, colors=list(conf.colorcycle), linestyles=None, **kwargs ): """Generate a comparison 2d contour contour plot for 2 marginalized posterior distributions from multiple analyses Parameters ---------- x: np.ndarray 2d array of posterior samples to use for the x axis; array for each analysis y: np.ndarray 2d array of posterior samples to use for the y axis; array for each analysis labels: list, optional labels to assign to each contour plot_density: str, optional label of the analysis you wish to plot the density for. If you wish to plot both, simply pass `plot_density='both'` rangex: tuple, optional range over which to plot the x axis rangey: tuple, optional range over which to plot the y axis legend_kwargs: dict, optional kwargs to use for the legend colors: list, optional list of colors to use for each contour linestyles: list, optional linestyles to use for each contour **kwargs: dict, optional all additional kwargs are passed to the `pesummary.core.plots.publication.twod_contour_plot` function """ if labels is None and plot_density is not None: plot_density = None if labels is None: labels = [None] * len(x) xlow = np.min([np.min(_x) for _x in x]) xhigh = np.max([np.max(_x) for _x in x]) ylow = np.min([np.min(_y) for _y in y]) yhigh = np.max([np.max(_y) for _y in y]) if rangex is None: rangex = [xlow, xhigh] if rangey is None: rangey = [ylow, yhigh] fig = None for num, (_x, _y) in enumerate(zip(x, y)): if plot_density is not None and plot_density == labels[num]: plot_density = True elif plot_density is not None and isinstance(plot_density, list): if labels[num] in plot_density: plot_density = True else: plot_density = False elif plot_density is not None and plot_density == "both": plot_density = True else: plot_density = False _label = _color = _linestyle = None if labels is not None: _label = labels[num] if colors is not None: _color = colors[num] if linestyles is not None: _linestyle = linestyles[num] fig = twod_contour_plot( _x, _y, plot_density=plot_density, label=_label, fig=fig, rangex=rangex, rangey=rangey, color=_color, linestyles=_linestyle, **kwargs ) ax = fig.gca() legend = ax.legend(**legend_kwargs) return fig def _triangle_axes( figsize=(8, 8), width_ratios=[4, 1], height_ratios=[1, 4], wspace=0.0, hspace=0.0, ): """Initialize the axes for a 2d triangle plot Parameters ---------- figsize: tuple, optional figure size you wish to use. Default (8, 8) width_ratios: list, optional ratio of widths for the triangular axis. Default 4:1 height_ratios: list, optional ratio of heights for the triangular axis. Default 1:4 wspace: float, optional horizontal space between the axis. Default 0.0 hspace: float, optional vertical space between the axis. Default 0.0 """ high1d = 1.0 fig = figure(figsize=figsize, gca=False) gs = gridspec.GridSpec( 2, 2, width_ratios=width_ratios, height_ratios=height_ratios, wspace=wspace, hspace=hspace ) ax1, ax2, ax3, ax4 = ( fig.add_subplot(gs[0]), fig.add_subplot(gs[1]), fig.add_subplot(gs[2]), fig.add_subplot(gs[3]), ) ax1.minorticks_on() ax3.minorticks_on() ax4.minorticks_on() ax1.xaxis.set_ticklabels([]) ax4.yaxis.set_ticklabels([]) return fig, ax1, ax2, ax3, ax4 def _generate_triangle_plot( *args, function=None, fig_kwargs={}, existing_figure=None, **kwargs ): """Generate a triangle plot according to a given function Parameters ---------- *args: tuple all args passed to function function: func, optional function you wish to use to generate triangle plot. Default _triangle_plot **kwargs: dict, optional all kwargs passed to function """ if existing_figure is None: fig, ax1, ax2, ax3, ax4 = _triangle_axes(**fig_kwargs) ax2.axis("off") else: fig, ax1, ax3, ax4 = existing_figure if function is None: function = _triangle_plot return function(fig, [ax1, ax3, ax4], *args, **kwargs) def triangle_plot(*args, **kwargs): """Generate a triangular plot made of 3 axis. One central axis showing the 2d marginalized posterior and two smaller axes showing the marginalized 1d posterior distribution (above and to the right of central axis) Parameters ---------- x: list list of samples for the x axis y: list list of samples for the y axis kde: Bool/func, optional kde
''' this Adapter is designed to wrap the sending and receiving activities of the Battery Management extension if it is applied. ''' from tools.singleton import Singleton import api.ecu_sim_api as api import copy from api.core.component_specs import SimpleECUSpec, SimpleBusSpec from enums.sec_cfg_enum import CAEnum from components.security.communication.stream import MessageStream from api.core.api_core import TimingFunctionSet from components.security.ecu.types.impl_sec_mod_lwa import StdSecurLwSecModTimingFunctions from components.security.ecu.types.impl_ecu_secure import StdSecurECUTimingFunctions import logging class BatManAdministrator(Singleton): ''' centrally saves all BatManCANBusAdapter objects so that they can be mapped ''' def __init__(self): ''' constructor ''' self.can_bus_adapter = {} # key: cell_id, value: BatManCANBusAdapter self._ecu_spec = None # ecu spec used for all ECUs per default self._ecu_class_name = None # class of the ECU that is to be used self._individual_spec = {} # if one ECU is to use different settings self._monitor = False # monitor object connected to the environment self._result_reader = False # result reader connected to the monitor self._view = False # view connected to the environment self._view_options = [] # options of the view w.g. EventlineViewPlugin self.q_application = None self.active = False def activate_ecu_simulation(self): self.active = True def adapter_used(self): ''' this method returns True if the battery management is using this adapter implementation for the can bus connection Input: - Output: - ''' # available adapters lst = self.can_bus_adapter.keys() # True if adapters available if lst: return True else: return False def add_view(self, direct_view, view_options): ''' adds a view (GUI) to the environment which is opened together with the environment Input: direct_view DirectViewer direct view gui that is to be connected view_options list list of GUI Plugins that are to be used Output: - ''' self._view = direct_view self._view_options = view_options def available_can_adapters(self): ''' returns all adapters that are connected to this environment Input: - Output: adapters list list of BatManCANBusAdapter objects that are connected to this environment ''' return self.can_bus_adapter.keys() def set_individual_ecu_spec(self, ecu_spec, ecu_class_name): ''' if certain ECUs with certain ECU ids shall have defined ecu specs set and be of a defined class, then this method sets those ECU Specs individually. Input: ecu_spec AbstractECUSpec ECU Spec defining which ECU Ids are to be set and which ECU specs should be used for those ECU Ids ecu_class_name string name of the class that the ECUs should get assigned ''' for ecu_id in ecu_spec.ecu_id_list: self._individual_spec[ecu_id] = [ecu_spec, ecu_class_name] def set_ecu_spec(self, ecu_spec, ecu_class_name): ''' this method sets the ecu spec that will be used per default to set the ecu specification Input: ecu_spec AbstractECUSpec spec that will be used to define the properties of the ECU in this ECU Simulation environment ecu_class_name string name of the class that the ECUs should get assigned Output: - ''' self._ecu_spec = ecu_spec self._ecu_class_name = ecu_class_name def connect_monitor_reader(self, monitor, result_reader): ''' this method connects a Monitor and a ResultReader to the environment to be able to extract data from the simulation Input: monitor Monitor monitor connected to the environment result_reader ResultReader result reader connected to the monitor Output: - ''' self._monitor = monitor self._result_reader = result_reader def prepare_configuration(self, simpy_env, life_time): ''' this method prepares the configuration on the side of the ECU simulation. It sets up the defined environment by mapping the ECU Ids as they are defined in the battery management system on the ECUs and the defined specs. So the constellation used is implemented here. Input: simpy_env simpy.Environment environment used in the battery management system life_time float life time of the simulation Output: - ''' # lifetime life_time = 50000 # logging # api_log_path = os.path.join(os.path.dirname(__file__), "../logs/api.log") # api.show_logging(logging.INFO, api_log_path, True) # create environment sim_env = api.create_environment(life_time) sim_env.set_env(simpy_env) ecu_list = [] # generate a ecu from the ECU specs setting the adapter for ecu_id in self.available_can_adapters(): # logging.info("ECU ID %s: " % ecu_id) # define individual ECU Spec ecu_spec = copy.deepcopy(self._ecu_spec) ecu_class_name = self._ecu_class_name if ecu_id in self._individual_spec: ecu_spec = self._individual_spec[ecu_id][0] ecu_class_name = self._individual_spec[ecu_id][1] ecu_spec.ecu_id_list = [str(ecu_id)] # create ecu ecu = api.set_ecus(sim_env, 1, ecu_class_name, ecu_spec)[0] ecu_list += [ecu] # connect ecu to adapter ecu.connect_adapter(self.can_bus_adapter[ecu_id]) # add security module # create ECU specification ecu_spec = SimpleECUSpec(['SEC 1'], 200000, 200000) # 200 KB ecu_spec.set_ecu_setting('t_ecu_auth_trigger_process', 0) ecu_spec.set_ecu_setting('t_ecu_auth_trigger_intervall', 80000) ecu_spec.set_apply_jitter(0.0001) sec_mod_group = api.set_ecus(sim_env, 1, 'SecLwAuthSecurityModule', ecu_spec) security_module = sec_mod_group[0] # connect to one bus # create the bus specifications bus_spec = SimpleBusSpec(['CAN_0']) api.set_busses(sim_env, 1, 'StdCANBus', bus_spec) api.connect_bus_by_obj(sim_env, 'CAN_0', ecu_list + sec_mod_group) # security constellation all_ecu_groups = [ecu_list] api.register_ecu_groups_to_secmod(sim_env, sec_mod_group[0].ecu_id, all_ecu_groups) certificate_manager = api.create_cert_manager() all_created_ecus = api.ecu_list_from_groups([all_ecu_groups]) ecu_ids = [str(ecu.ecu_id) for ecu in all_created_ecus] for ecu_id in ecu_ids: api.generate_valid_ecu_cert_cfg(certificate_manager, ecu_id, CAEnum.CA_L313, security_module.ecu_id, 0, float('inf')) api.generate_valid_sec_mod_cert_cfg(certificate_manager, security_module.ecu_id, CAEnum.CA_L313, ecu_ids, 0, float('inf')) api.apply_certification(sim_env, certificate_manager) # define allowed streams -------------------------------------------------------------- TODO very IMPORTANT for broadcast_stream_id in [0x0080, 0x0081, 0x0082, 0x0083, 0x0012, 0x0013, 0x0020, 0x00A0, 0x00A1 ]: for ecu_id in ecu_ids: lst = copy.deepcopy(ecu_ids) lst.remove(ecu_id) stream = MessageStream(ecu_id, lst, broadcast_stream_id, float('inf'), 0, float('inf')) api.add_allowed_stream(sim_env, security_module.ecu_id, stream) # -------------------------------------------------------------- TODO very IMPORTANT # set gateways api.autoset_gateway_filters(sim_env, sec_mod_group[0].ecu_id) # set timing functions function_set = TimingFunctionSet() ecu_func_set = StdSecurLwSecModTimingFunctions(main_library_tag='CyaSSL') ecu_func_set.library_tags['t_ecu_auth_reg_msg_validate_cert'] = 'Crypto_Lib_SW' function_set.set_mapping_from_function_set(security_module.ecu_id, ecu_func_set) api.apply_timing_functions_set(sim_env, security_module.ecu_id, function_set) function_set_2 = TimingFunctionSet() ecu_func_set = StdSecurECUTimingFunctions(main_library_tag='CyaSSL') ecu_func_set.library_tags['t_adv_msg_secmodcert_enc'] = 'Crypto_Lib_SW' for ecu_id in ecu_ids: function_set_2.set_mapping_from_function_set(ecu_id, ecu_func_set) api.apply_timing_functions_set(sim_env, ecu_id, function_set_2) # add monitor if self._monitor and self._result_reader: api.connect_monitor(sim_env, self._monitor, 0.5) api.connect_result_reader(sim_env, self._monitor, self._result_reader) # run view if defined if self._view: self._view.show(self._result_reader, self._view_options, self.q_application) # run simulation api.open_simulation_stop_button(sim_env) api.build_simulation(sim_env) api.run_simulation(sim_env) def add_adapter(self, cell_id, adapter): ''' adds a adapter to the simulation environment Input: cell_id string id of the ECU/CMU that is added to the system adapter BatManCANBusAdapter adapter that maps the ECUSimulation environment to the Battery management system by intercepting the CANBus sending and receiving process Output: - ''' self.can_bus_adapter[cell_id] = adapter class BatManCANBusAdapter(object): ''' this class is instantiated in the Battery Management environment once per ECU/cell. It is implemented as one CAN Bus instance (per cell) that is accessed during the sending and receiving process of each cell. This adapter is then mapped onto the ECU Simulation environment by connecting each of those CAN Bus instances to one BatManECU and its application layer. So every time the cell in the Battery Management environment invokes the send or received message, the corresponding ECU that resembles this cell is called in the ecu simulation environment. ''' # message ids definitions for the battery management system CAN_SOC_BROADCAST = [0x0080, 32] # ('TARGET':'BROADCAST', 'ORIGIN':, 'soc' :) CAN_VOLTAGE_BROADCAST = [0x0081, 32] # ('TARGET':'BROADCAST', 'ORIGIN':, 'voltage' :) CAN_BLOCK_REQUEST = [0x0082, 16] # ('TARGET':'BROADCAST', 'ORIGIN':, 'SENDER_ID':, 'RECEIVER_ID':) CAN_UNBLOCK_REQUEST = [0x0083, 16] # ('TARGET':'BROADCAST', 'ORIGIN':, 'SENDER_ID':, 'RECEIVER_ID':) CAN_SEND_REQUEST = [0x0012, 0] # ('TARGET':, 'ORIGIN':) CAN_SEND_ACKNOWLEDGE = [0x0013, 64] # ('TARGET':, 'ORIGIN':, 'transferTime':, 'transferRate') CAN_STATUS_RESPONSE = [0x0020, 24] # ('TARGET':, 'ORIGIN':, 'STATUS', 'BLOCKERID1', 'BLOCKERID2') CAN_BALANCE_CONTROL = [0x00A0, 0] CAN_SUPPLY_LOAD_MODE = [0x00A1, 66] def __init__(self, cmu): ''' Constructor Input: cmu CMU cmu in the battery management system that corresponds to a ECU in the ECUSimulation environment ''' # define default ecu specs self.ecu_specs = None self.cmu = cmu # register at Administrator self.ecu_id = cmu.objectId BatManAdministrator().add_adapter(self.ecu_id, self) # dummy parameters (needed for instantiation) self.dataCount = 0 self.speed = 2 self.avgSpeed = 2 def CANsend(self, message): ''' when a CMU of the battery management system wants to send a message this method is invoked. If this adapter is connected to a BatManECU this method is overridden with the method that sends in the ECU Environment Input: message CANBusMessage can bus message that is sent by the batterymanagement Output: - ''' # logging.info('ID: {}, DATA: {}'.format(message.identifier, message.data)) self.receive(message) logging.info("CAN send not overridden") def receive(self, msg): ''' when a CMU of
import os import datetime import tempfile import numpy as np from simtk import openmm as mm from simtk import unit from simtk.openmm.app.pdbfile import PDBFile from simtk.openmm.app.topology import Topology import simtk.openmm.app.element as elem from cg_openmm.simulation.tools import build_mm_simulation from cg_openmm.utilities.util import lj_v from cg_openmm.utilities.iotools import write_pdbfile_without_topology def add_new_elements(cgmodel): """ Add coarse grained particle types to OpenMM. :param cgmodel: CGModel object (contains all attributes for a coarse grained model). :type cgmodel: class :returns: - new_particles (list) - a list of the particle names that were added to OpenMM's 'Element' List. :Example: >>> from foldamers.cg_model.cgmodel import CGModel >>> cgmodel = CGModel() >>> particle_types = add_new_elements(cgmodel) .. warning:: If the particle names were user defined, and any of the names conflict with existing element names in OpenMM, OpenMM will issue an error exit. """ element_index = 117 new_particles = [] for particle in cgmodel.particle_list: particle_name = particle["name"] if particle_name.upper() not in elem.Element._elements_by_symbol: elem.Element(element_index, particle_name, particle_name, cgmodel.get_particle_mass(particle)) element_index = element_index + 1 new_particles.append(particle_name) return new_particles def write_xml_file(cgmodel, xml_file_name): """ Write an XML-formatted forcefield file for a coarse grained model. :param cgmodel: CGModel() class object. :type cgmodel: class :param xml_file_name: Path to XML output file. :type xml_file_name: str :Example: >>> from foldamers.cg_model.cgmodel import CGModel >>> cgmodel = CGModel() >>> xml_file_name = "openmm_cgmodel.xml" >>> write_xml_file(cgmodel,xml_file_name) """ particle_list = add_new_elements(cgmodel) xml_object = open(xml_file_name, "w") xml_object.write("<ForceField>\n") xml_object.write(" <Info>\n") date = str(datetime.datetime.today()).split()[0] xml_object.write(f" <DateGenerated> {date} </DateGenerated>\n") xml_object.write(" <Source> https://github.com/shirtsgroup/cg_openmm </Source>\n") xml_object.write(" <Reference>\n") xml_object.write(" </Reference>\n") xml_object.write(" </Info>\n") xml_object.write(" <AtomTypes>\n") unique_particle_names = [] unique_masses = [] for particle_index in range(len(cgmodel.particle_list)): if cgmodel.particle_list[particle_index] not in unique_particle_names: unique_particle_names.append(cgmodel.particle_list[particle_index]) unique_masses.append(cgmodel.get_particle_mass(particle_index)) for particle_index in range(len(unique_particle_names)): particle_type = cgmodel.get_particle_type_name(particle_index) xml_object.write( ' <Type name="' + str(unique_particle_names[particle_index]) + '" class="' + str(particle_type) + '" element="' + str(unique_particle_names[particle_index]) + '" mass="' + str(unique_masses[particle_index]._value) + '"/>\n' ) xml_object.write(" </AtomTypes>\n") xml_object.write(" <Residues>\n") xml_object.write(' <Residue name="M">\n') for particle_index in range(len(unique_particle_names)): xml_object.write( ' <Atom name="' + str(unique_particle_names[particle_index]) + '" type="' + str(unique_particle_names[particle_index]) + '"/>\n' ) for bond in cgmodel.bond_list: if all(bond[i] < len(unique_particle_names) for i in range(2)): particle_1_name = cgmodel.get_particle_name(bond[0]) particle_2_name = cgmodel.get_particle_name(bond[1]) xml_object.write( ' <Bond atomName1="' + str(particle_1_name) + '" atomName2="' + str(particle_2_name) + '"/>\n' ) xml_object.write(' <ExternalBond atomName="' + str(unique_particle_names[0]) + '"/>\n') external_parent = unique_particle_names[ len(unique_particle_names) - cgmodel.monomer_types[0]["sidechain_length"] - 1 ] xml_object.write(' <ExternalBond atomName="' + str(external_parent) + '"/>\n') xml_object.write(" </Residue>\n") xml_object.write(' <Residue name="MT">\n') for particle_index in range(len(unique_particle_names)): xml_object.write( ' <Atom name="' + str(unique_particle_names[particle_index]) + '" type="' + str(unique_particle_names[particle_index]) + '"/>\n' ) for bond in cgmodel.bond_list: if all(bond[i] < len(unique_particle_names) for i in range(2)): particle_1_name = cgmodel.get_particle_name(bond[0]) particle_2_name = cgmodel.get_particle_name(bond[1]) xml_object.write( ' <Bond atomName1="' + str(particle_1_name) + '" atomName2="' + str(particle_2_name) + '"/>\n' ) xml_object.write(' <ExternalBond atomName="' + str(external_parent) + '"/>\n') xml_object.write(" </Residue>\n") xml_object.write(" </Residues>\n") if cgmodel.include_bond_forces: xml_object.write(" <HarmonicBondForce>\n") unique_bond_list = [] for bond in cgmodel.bond_list: if any(bond[i] < len(unique_particle_names) for i in range(2)): unique_bond_list.append(bond) for bond in unique_bond_list: particle_1_name = cgmodel.get_particle_name(bond[0]) particle_2_name = cgmodel.get_particle_name(bond[1]) # unique_particle_names.index(particle_1_name) xml_type_1 = particle_1_name # unique_particle_names.index(particle_2_name) xml_type_2 = particle_2_name bond_length = cgmodel.get_bond_length(bond).value_in_unit(unit.nanometer) bond_force_constant = cgmodel.get_bond_force_constant(bond) xml_object.write( ' <Bond type1="' + str(xml_type_1) + '" type2="' + str(xml_type_2) + '" length="' + str(bond_length) + '" k="' + str(bond_force_constant) + '"/>\n' ) xml_object.write(" </HarmonicBondForce>\n") if cgmodel.include_bond_angle_forces: xml_object.write(" <HarmonicAngleForce>\n") unique_angle_list = [] for angle in cgmodel.bond_angle_list: if any(angle[i] < len(unique_particle_names) for i in range(3)): unique_angle_list.append(angle) for angle in unique_angle_list: bond_angle_force_constant = cgmodel.get_bond_angle_force_constant(angle) equil_bond_angle = cgmodel.get_equil_bond_angle(angle) particle_1_name = cgmodel.get_particle_name(angle[0]) particle_2_name = cgmodel.get_particle_name(angle[1]) particle_3_name = cgmodel.get_particle_name(angle[2]) # unique_particle_names.index(particle_1_name) xml_type_1 = particle_1_name # unique_particle_names.index(particle_2_name) xml_type_2 = particle_2_name # unique_particle_names.index(particle_3_name) xml_type_3 = particle_3_name xml_object.write( ' <Angle angle="' + str(equil_bond_angle) + '" k="' + str(bond_angle_force_constant) + '" type1="' + str(xml_type_1) + '" type2="' + str(xml_type_2) + '" type3="' + str(xml_type_3) + '"/>\n' ) xml_object.write(" </HarmonicAngleForce>\n") if cgmodel.include_torsion_forces: xml_object.write(' <PeriodicTorsionForce ordering="amber">\n') unique_torsion_list = [] # print(cgmodel.torsion_list) for torsion in cgmodel.torsion_list: if any(torsion[i] < len(unique_particle_names) for i in range(4)): unique_torsion_list.append(torsion) for torsion in unique_torsion_list: torsion_force_constant = cgmodel.get_torsion_force_constant( [torsion[0], torsion[1], torsion[2], torsion[3]] ) torsion_phase_angle = cgmodel.get_torsion_phase_angle( [torsion[0], torsion[1], torsion[2], torsion[3]] ) particle_1_name = cgmodel.get_particle_name(torsion[0]) particle_2_name = cgmodel.get_particle_name(torsion[1]) particle_3_name = cgmodel.get_particle_name(torsion[2]) particle_4_name = cgmodel.get_particle_name(torsion[3]) # unique_particle_names.index(particle_1_name) xml_type_1 = particle_1_name # unique_particle_names.index(particle_2_name) xml_type_2 = particle_2_name # unique_particle_names.index(particle_3_name) xml_type_3 = particle_3_name # unique_particle_names.index(particle_4_name) xml_type_4 = particle_4_name periodicity = cgmodel.get_torsion_periodicity(torsion) xml_object.write( ' <Proper k1="' + str(torsion_force_constant) + '" periodicity1="' + str(periodicity) + '" phase1="' + str(torsion_phase_angle) + '" type1="' + str(xml_type_1) + '" type2="' + str(xml_type_2) + '" type3="' + str(xml_type_3) + '" type4="' + str(xml_type_4) + '"/>\n' ) xml_object.write(" </PeriodicTorsionForce>\n") if cgmodel.include_nonbonded_forces: xml_object.write(' <NonbondedForce coulomb14scale="0.833333" lj14scale="0.5">\n') for particle_index in range(len(unique_particle_names)): charge = cgmodel.get_particle_charge(particle_index)._value sigma = cgmodel.get_particle_sigma(particle_index).in_units_of(unit.nanometer)._value epsilon = cgmodel.get_particle_epsilon(particle_index)._value particle_name = cgmodel.get_particle_name(particle_index) xml_object.write(f' <Atom type=\"{particle_name}\" charge=\"{charge}\" sigma=\"{charge} epsilon=\"{epsilon}\"/>\n') xml_object.write(" </NonbondedForce>\n") xml_object.write("</ForceField>\n") xml_object.close() return def verify_topology(cgmodel): """ Given a coarse grained model that contains a Topology() (cgmodel.topology), this function verifies the validity of the topology. :param cgmodel: CGModel() class object. :type cgmodel: class :Example: >>> from foldamers.cg_model.cgmodel import CGModel >>> cgmodel = CGModel() >>> verify_topology(cgmodel) .. warning:: The function will force an error exit if the topology is invalid, and will proceed as normal if the topology is valid. """ if cgmodel.num_beads != cgmodel.topology.getNumAtoms(): print("ERROR: The number of particles in the coarse grained model\n") print("does not match the number of particles in the OpenMM topology.\n") print("There are " + str(cgmodel.num_beads) + " particles in the coarse grained model\n") print("and " + str(cgmodel.topology.getNumAtoms()) + " particles in the OpenMM topology.") exit() if cgmodel.polymer_length != cgmodel.topology.getNumResidues(): print("ERROR: The number of monomers in the coarse grained model\n") print("does not match the number of residues in the OpenMM topology.\n") print( "There are " + str(cgmodel.polymer_length) + " monomers in the coarse grained model\n" ) print( "and " + str(cgmodel.topology.getNumResidues()) + " monomers in the OpenMM topology." ) exit() return def build_topology(cgmodel, use_pdbfile=False, pdbfile=None): """ Construct an OpenMM `Topology() <https://simtk.org/api_docs/openmm/api4_1/python/classsimtk_1_1openmm_1_1app_1_1topology_1_1Topology.html>`_ class object for our coarse grained model, :param cgmodel: CGModel() class object :type cgmodel: class :param use_pdbfile: Determines whether or not to use a PDB file in order to generate the Topology(). :type use_pdbfile: Logical :param pdbfile: Name of a PDB file to use when building the topology. :type pdbfile: str :returns: - topology (`Topology() <https://simtk.org/api_docs/openmm/api4_1/python/classsimtk_1_1openmm_1_1app_1_1topology_1_1Topology.html>`_ ) - OpenMM Topology() object :Example: >>> from foldamers.cg_model.cgmodel import CGModel >>> from foldamers.util.iotools import write_pdbfile_without_topology >>> input_pdb = "top.pdb" >>> cgmodel = CGModel() >>> write_pdbfile_without_topology(cgmodel,input_pdb) >>> topology = build_topology(cgmodel,use_pdbfile=True,pdbfile=input_pdb) >>> cgmodel.topology = topology .. warning:: When 'use_pdbfile'=True, this function will use the `PDBFile() <https://simtk.org/api_docs/openmm/api4_1/python/classsimtk_1_1openmm_1_1app_1_1pdbfile_1_1PDBFile.html>`_ class object from OpenMM to build the Topology(). In order for this approach to function correctly, the particle names in the PDB file must match the particle names in the coarse grained model. """ if cgmodel.constrain_bonds: use_pdbfile = True if use_pdbfile: if pdbfile is None: tf = tempfile.NamedTemporaryFile() write_pdbfile_without_topology(cgmodel, tf.name) pdb = PDBFile(tf.name) topology = pdb.getTopology() tf.close() return topology else: pdb = PDBFile(pdbfile) topology = pdb.getTopology() return topology topology = Topology() chain = topology.addChain() residue_index = -1 openmm_particle_list = list() for particle in cgmodel.particle_list: if particle["monomer"] > residue_index: residue_index = particle["monomer"] residue = topology.addResidue(str(residue_index), chain) particle_symbol = particle["name"] element = elem.Element.getBySymbol(particle_symbol) openmm_particle = topology.addAtom(particle_symbol, element, residue) openmm_particle_list.append(particle) if cgmodel.include_bond_forces or cgmodel.constrain_bonds: for bond in cgmodel.bond_list: topology.addBond(openmm_particle_list[bond[0]],openmm_particle_list[bond[1]]) cgmodel.topology = topology verify_topology(cgmodel) return topology def get_num_forces(cgmodel): """ Given a CGModel() class object, this function determines how many forces we are including when evaluating the energy. :param cgmodel: CGModel() class object :type cgmodel: class :returns: - total_forces (int) - Number of forces in the coarse grained model :Example: >>> from foldamers.cg_model.cgmodel import CGModel >>> cgmodel = CGModel() >>> total_number_forces = get_num_forces(cgmodel) """ total_forces = 0 if cgmodel.include_bond_forces: total_forces = total_forces + 1 if cgmodel.include_nonbonded_forces: total_forces = total_forces + 1 if cgmodel.include_bond_angle_forces: total_forces = total_forces + 1 if cgmodel.include_torsion_forces: total_forces = total_forces + 1 return total_forces def verify_system(cgmodel): """ Given a CGModel() class object, this function confirms that its OpenMM `System() <https://simtk.org/api_docs/openmm/api4_1/python/classsimtk_1_1openmm_1_1openmm_1_1System.html>`_ object is configured correctly. :param cgmodel: CGModel() class object :type cgmodel: class :Example: >>> from foldamers.cg_model.cgmodel import CGModel >>> cgmodel = CGModel() >>> verify_system(cgmodel) .. warning:: The function will force an error exit if the system is invalid, and will proceed as normal if the system is
""" return pulumi.get(self, "prefix") @prefix.setter def prefix(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "prefix", value) @property @pulumi.getter(name="processingConfiguration") def processing_configuration(self) -> Optional[pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs']]: """ The data processing configuration. More details are given below. """ return pulumi.get(self, "processing_configuration") @processing_configuration.setter def processing_configuration(self, value: Optional[pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs']]): pulumi.set(self, "processing_configuration", value) @property @pulumi.getter(name="s3BackupConfiguration") def s3_backup_configuration(self) -> Optional[pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationS3BackupConfigurationArgs']]: """ The configuration for backup in Amazon S3. Required if `s3_backup_mode` is `Enabled`. Supports the same fields as `s3_configuration` object. """ return pulumi.get(self, "s3_backup_configuration") @s3_backup_configuration.setter def s3_backup_configuration(self, value: Optional[pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationS3BackupConfigurationArgs']]): pulumi.set(self, "s3_backup_configuration", value) @property @pulumi.getter(name="s3BackupMode") def s3_backup_mode(self) -> Optional[pulumi.Input[str]]: """ The Amazon S3 backup mode. Valid values are `Disabled` and `Enabled`. Default value is `Disabled`. """ return pulumi.get(self, "s3_backup_mode") @s3_backup_mode.setter def s3_backup_mode(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "s3_backup_mode", value) @pulumi.input_type class FirehoseDeliveryStreamExtendedS3ConfigurationCloudwatchLoggingOptionsArgs: def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]] = None, log_group_name: Optional[pulumi.Input[str]] = None, log_stream_name: Optional[pulumi.Input[str]] = None): """ :param pulumi.Input[bool] enabled: Enables or disables the logging. Defaults to `false`. :param pulumi.Input[str] log_group_name: The CloudWatch group name for logging. This value is required if `enabled` is true. :param pulumi.Input[str] log_stream_name: The CloudWatch log stream name for logging. This value is required if `enabled` is true. """ if enabled is not None: pulumi.set(__self__, "enabled", enabled) if log_group_name is not None: pulumi.set(__self__, "log_group_name", log_group_name) if log_stream_name is not None: pulumi.set(__self__, "log_stream_name", log_stream_name) @property @pulumi.getter def enabled(self) -> Optional[pulumi.Input[bool]]: """ Enables or disables the logging. Defaults to `false`. """ return pulumi.get(self, "enabled") @enabled.setter def enabled(self, value: Optional[pulumi.Input[bool]]): pulumi.set(self, "enabled", value) @property @pulumi.getter(name="logGroupName") def log_group_name(self) -> Optional[pulumi.Input[str]]: """ The CloudWatch group name for logging. This value is required if `enabled` is true. """ return pulumi.get(self, "log_group_name") @log_group_name.setter def log_group_name(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "log_group_name", value) @property @pulumi.getter(name="logStreamName") def log_stream_name(self) -> Optional[pulumi.Input[str]]: """ The CloudWatch log stream name for logging. This value is required if `enabled` is true. """ return pulumi.get(self, "log_stream_name") @log_stream_name.setter def log_stream_name(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "log_stream_name", value) @pulumi.input_type class FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationArgs: def __init__(__self__, *, input_format_configuration: pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationArgs'], output_format_configuration: pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationArgs'], schema_configuration: pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationSchemaConfigurationArgs'], enabled: Optional[pulumi.Input[bool]] = None): """ :param pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationArgs'] input_format_configuration: Nested argument that specifies the deserializer that you want Kinesis Data Firehose to use to convert the format of your data from JSON. More details below. :param pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationArgs'] output_format_configuration: Nested argument that specifies the serializer that you want Kinesis Data Firehose to use to convert the format of your data to the Parquet or ORC format. More details below. :param pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationSchemaConfigurationArgs'] schema_configuration: Nested argument that specifies the AWS Glue Data Catalog table that contains the column information. More details below. :param pulumi.Input[bool] enabled: Defaults to `true`. Set it to `false` if you want to disable format conversion while preserving the configuration details. """ pulumi.set(__self__, "input_format_configuration", input_format_configuration) pulumi.set(__self__, "output_format_configuration", output_format_configuration) pulumi.set(__self__, "schema_configuration", schema_configuration) if enabled is not None: pulumi.set(__self__, "enabled", enabled) @property @pulumi.getter(name="inputFormatConfiguration") def input_format_configuration(self) -> pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationArgs']: """ Nested argument that specifies the deserializer that you want Kinesis Data Firehose to use to convert the format of your data from JSON. More details below. """ return pulumi.get(self, "input_format_configuration") @input_format_configuration.setter def input_format_configuration(self, value: pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationArgs']): pulumi.set(self, "input_format_configuration", value) @property @pulumi.getter(name="outputFormatConfiguration") def output_format_configuration(self) -> pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationArgs']: """ Nested argument that specifies the serializer that you want Kinesis Data Firehose to use to convert the format of your data to the Parquet or ORC format. More details below. """ return pulumi.get(self, "output_format_configuration") @output_format_configuration.setter def output_format_configuration(self, value: pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationArgs']): pulumi.set(self, "output_format_configuration", value) @property @pulumi.getter(name="schemaConfiguration") def schema_configuration(self) -> pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationSchemaConfigurationArgs']: """ Nested argument that specifies the AWS Glue Data Catalog table that contains the column information. More details below. """ return pulumi.get(self, "schema_configuration") @schema_configuration.setter def schema_configuration(self, value: pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationSchemaConfigurationArgs']): pulumi.set(self, "schema_configuration", value) @property @pulumi.getter def enabled(self) -> Optional[pulumi.Input[bool]]: """ Defaults to `true`. Set it to `false` if you want to disable format conversion while preserving the configuration details. """ return pulumi.get(self, "enabled") @enabled.setter def enabled(self, value: Optional[pulumi.Input[bool]]): pulumi.set(self, "enabled", value) @pulumi.input_type class FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationArgs: def __init__(__self__, *, deserializer: pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerArgs']): """ :param pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerArgs'] deserializer: Nested argument that specifies which deserializer to use. You can choose either the Apache Hive JSON SerDe or the OpenX JSON SerDe. More details below. """ pulumi.set(__self__, "deserializer", deserializer) @property @pulumi.getter def deserializer(self) -> pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerArgs']: """ Nested argument that specifies which deserializer to use. You can choose either the Apache Hive JSON SerDe or the OpenX JSON SerDe. More details below. """ return pulumi.get(self, "deserializer") @deserializer.setter def deserializer(self, value: pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerArgs']): pulumi.set(self, "deserializer", value) @pulumi.input_type class FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerArgs: def __init__(__self__, *, hive_json_ser_de: Optional[pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerHiveJsonSerDeArgs']] = None, open_x_json_ser_de: Optional[pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerOpenXJsonSerDeArgs']] = None): """ :param pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerHiveJsonSerDeArgs'] hive_json_ser_de: Nested argument that specifies the native Hive / HCatalog JsonSerDe. More details below. :param pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerOpenXJsonSerDeArgs'] open_x_json_ser_de: Nested argument that specifies the OpenX SerDe. More details below. """ if hive_json_ser_de is not None: pulumi.set(__self__, "hive_json_ser_de", hive_json_ser_de) if open_x_json_ser_de is not None: pulumi.set(__self__, "open_x_json_ser_de", open_x_json_ser_de) @property @pulumi.getter(name="hiveJsonSerDe") def hive_json_ser_de(self) -> Optional[pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerHiveJsonSerDeArgs']]: """ Nested argument that specifies the native Hive / HCatalog JsonSerDe. More details below. """ return pulumi.get(self, "hive_json_ser_de") @hive_json_ser_de.setter def hive_json_ser_de(self, value: Optional[pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerHiveJsonSerDeArgs']]): pulumi.set(self, "hive_json_ser_de", value) @property @pulumi.getter(name="openXJsonSerDe") def open_x_json_ser_de(self) -> Optional[pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerOpenXJsonSerDeArgs']]: """ Nested argument that specifies the OpenX SerDe. More details below. """ return pulumi.get(self, "open_x_json_ser_de") @open_x_json_ser_de.setter def open_x_json_ser_de(self, value: Optional[pulumi.Input['FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerOpenXJsonSerDeArgs']]): pulumi.set(self, "open_x_json_ser_de", value) @pulumi.input_type class FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerHiveJsonSerDeArgs: def __init__(__self__, *, timestamp_formats: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None): """ :param pulumi.Input[Sequence[pulumi.Input[str]]] timestamp_formats: A list of how you want Kinesis Data Firehose to parse the date and time stamps that may be present in your input data JSON. To specify these format strings, follow the pattern syntax of JodaTime's DateTimeFormat format strings. For more information, see [Class DateTimeFormat](https://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html). You can also use the special value millis to parse time stamps in epoch milliseconds. If you don't specify a format, Kinesis Data Firehose uses java.sql.Timestamp::valueOf by default. """ if timestamp_formats is not None: pulumi.set(__self__, "timestamp_formats", timestamp_formats) @property @pulumi.getter(name="timestampFormats") def timestamp_formats(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: """ A list of how you want Kinesis Data Firehose to parse the date and time stamps that may be present in your input data JSON. To specify these format strings, follow the pattern syntax of JodaTime's DateTimeFormat format strings. For more information, see [Class DateTimeFormat](https://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html). You can also use the special value millis to parse time stamps in epoch milliseconds. If you don't specify a format, Kinesis Data Firehose uses java.sql.Timestamp::valueOf by default. """ return pulumi.get(self, "timestamp_formats") @timestamp_formats.setter def timestamp_formats(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): pulumi.set(self, "timestamp_formats", value) @pulumi.input_type class FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerOpenXJsonSerDeArgs: def __init__(__self__, *, case_insensitive: Optional[pulumi.Input[bool]] = None, column_to_json_key_mappings: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, convert_dots_in_json_keys_to_underscores: Optional[pulumi.Input[bool]] = None): """ :param pulumi.Input[bool] case_insensitive: When set to true, which is the default, Kinesis Data Firehose converts JSON keys to lowercase before deserializing them. :param pulumi.Input[Mapping[str, pulumi.Input[str]]] column_to_json_key_mappings: A map of column names to JSON keys that aren't identical to the column names. This is useful when the JSON contains keys that are Hive keywords. For example, timestamp is a Hive keyword. If you have a JSON key named timestamp, set this parameter to `{ ts = "timestamp" }` to map this key to a column named ts. :param pulumi.Input[bool] convert_dots_in_json_keys_to_underscores: When set to `true`, specifies that the names of the keys include dots and that you want Kinesis Data Firehose to replace them with underscores. This is useful because Apache Hive does not allow dots in column names. For example, if the JSON contains a key whose name is "a.b", you can define the column name to be "a_b" when using this option. Defaults to `false`. """ if case_insensitive is not None: pulumi.set(__self__, "case_insensitive", case_insensitive) if column_to_json_key_mappings is not None: pulumi.set(__self__, "column_to_json_key_mappings", column_to_json_key_mappings) if convert_dots_in_json_keys_to_underscores is not None: pulumi.set(__self__, "convert_dots_in_json_keys_to_underscores", convert_dots_in_json_keys_to_underscores) @property @pulumi.getter(name="caseInsensitive") def case_insensitive(self) -> Optional[pulumi.Input[bool]]: """ When set to true, which is the default, Kinesis Data Firehose converts JSON keys to lowercase before deserializing them. """ return pulumi.get(self, "case_insensitive") @case_insensitive.setter def case_insensitive(self, value: Optional[pulumi.Input[bool]]): pulumi.set(self, "case_insensitive", value) @property @pulumi.getter(name="columnToJsonKeyMappings") def column_to_json_key_mappings(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: """ A map of column names to JSON keys that aren't identical to the column names. This is useful when the JSON contains keys that are Hive keywords. For example, timestamp is a Hive keyword. If you have a JSON key named timestamp, set this parameter to
user namespace. Return value: a flag indicating whether the code to be run completed successfully: - 0: successful execution. - 1: an error occurred. """ outflag = 1 # start by assuming error, success will reset it try: exec code in self.user_ns outflag = 0 except SystemExit: self.resetbuffer() self.traceback_trap.args = sys.exc_info() except: self.traceback_trap.args = sys.exc_info() return outflag def execute_macro(self, macro): """ Execute the value of a macro. Parameters ---------- macro : Macro """ python = macro.value if self.translator is not None: python = self.translator(python) self.execute_python(python) def getCommand(self, i=None): """Gets the ith message in the message_cache. This is implemented here for compatibility with the old ipython1 shell I am not sure we need this though. I even seem to remember that we were going to get rid of it. """ return self.message_cache.get_message(i) def reset(self): """Reset the interpreter. Currently this only resets the users variables in the namespace. In the future we might want to also reset the other stateful things like that the Interpreter has, like In, Out, etc. """ self.user_ns.clear() self.setup_namespace() def complete(self,line,text=None, pos=None): """Complete the given text. :Parameters: text : str Text fragment to be completed on. Typically this is """ # fixme: implement raise NotImplementedError def push(self, ns): """ Put value into the namespace with name key. Parameters ---------- **kwds """ self.user_ns.update(ns) def push_function(self, ns): # First set the func_globals for all functions to self.user_ns new_kwds = {} for k, v in ns.iteritems(): if not isinstance(v, FunctionType): raise TypeError("function object expected") new_kwds[k] = FunctionType(v.func_code, self.user_ns) self.user_ns.update(new_kwds) def pack_exception(self,message,exc): message['exception'] = exc.__class__ message['exception_value'] = \ traceback.format_exception_only(exc.__class__, exc) def feed_block(self, source, filename='<input>', symbol='single'): """Compile some source in the interpreter. One several things can happen: 1) The input is incorrect; compile_command() raised an exception (SyntaxError or OverflowError). 2) The input is incomplete, and more input is required; compile_command() returned None. Nothing happens. 3) The input is complete; compile_command() returned a code object. The code is executed by calling self.runcode() (which also handles run-time exceptions, except for SystemExit). The return value is: - True in case 2 - False in the other cases, unless an exception is raised, where None is returned instead. This can be used by external callers to know whether to continue feeding input or not. The return value can be used to decide whether to use sys.ps1 or sys.ps2 to prompt the next line.""" self.message = self.setup_message() try: code = self.command_compiler(source,filename,symbol) except (OverflowError, SyntaxError, IndentationError, ValueError ), e: # Case 1 self.traceback_trap.args = sys.exc_info() self.pack_exception(self.message,e) return COMPILER_ERROR,False if code is None: # Case 2: incomplete input. This means that the input can span # multiple lines. But we still need to decide when to actually # stop taking user input. Later we'll add auto-indentation support # somehow. In the meantime, we'll just stop if there are two lines # of pure whitespace at the end. last_two = source.rsplit('\n',2)[-2:] print 'last two:',last_two # dbg if len(last_two)==2 and all(s.isspace() for s in last_two): return COMPLETE_INPUT,False else: return INCOMPLETE_INPUT, True else: # Case 3 return COMPLETE_INPUT, False def pull(self, keys): """ Get an item out of the namespace by key. Parameters ---------- key : str Returns ------- value : object Raises ------ TypeError if the key is not a string. NameError if the object doesn't exist. """ if isinstance(keys, str): result = self.user_ns.get(keys, NotDefined()) if isinstance(result, NotDefined): raise NameError('name %s is not defined' % keys) elif isinstance(keys, (list, tuple)): result = [] for key in keys: if not isinstance(key, str): raise TypeError("objects must be keyed by strings.") else: r = self.user_ns.get(key, NotDefined()) if isinstance(r, NotDefined): raise NameError('name %s is not defined' % key) else: result.append(r) if len(keys)==1: result = result[0] else: raise TypeError("keys must be a strong or a list/tuple of strings") return result def pull_function(self, keys): return self.pull(keys) #### Interactive user API ################################################## def ipsystem(self, command): """ Execute a command in a system shell while expanding variables in the current namespace. Parameters ---------- command : str """ # Expand $variables. command = self.var_expand(command) system_shell(command, header='IPython system call: ', verbose=self.rc.system_verbose, ) def ipmagic(self, arg_string): """ Call a magic function by name. ipmagic('name -opt foo bar') is equivalent to typing at the ipython prompt: In[1]: %name -opt foo bar To call a magic without arguments, simply use ipmagic('name'). This provides a proper Python function to call IPython's magics in any valid Python code you can type at the interpreter, including loops and compound statements. It is added by IPython to the Python builtin namespace upon initialization. Parameters ---------- arg_string : str A string containing the name of the magic function to call and any additional arguments to be passed to the magic. Returns ------- something : object The return value of the actual object. """ # Taken from IPython. raise NotImplementedError('Not ported yet') args = arg_string.split(' ', 1) magic_name = args[0] magic_name = magic_name.lstrip(self.config.ESC_MAGIC) try: magic_args = args[1] except IndexError: magic_args = '' fn = getattr(self.magic, 'magic_'+magic_name, None) if fn is None: self.error("Magic function `%s` not found." % magic_name) else: magic_args = self.var_expand(magic_args) return fn(magic_args) #### Private 'Interpreter' interface ####################################### def setup_message(self): """Return a message object. This method prepares and returns a message dictionary. This dict contains the various fields that are used to transfer information about execution, results, tracebacks, etc, to clients (either in or out of process ones). Because of the need to work with possibly out of process clients, this dict MUST contain strictly pickle-safe values. """ return dict(number=self.current_cell_number) def setup_namespace(self): """ Add things to the namespace. """ self.user_ns.setdefault('__name__', '__main__') self.user_ns.setdefault('__builtins__', __builtin__) self.user_ns['__IP'] = self if self.raw_input_builtin is not None: self.user_ns['raw_input'] = self.raw_input_builtin if self.input_builtin is not None: self.user_ns['input'] = self.input_builtin builtin_additions = dict( ipmagic=self.ipmagic, ) __builtin__.__dict__.update(builtin_additions) if self.history is not None: self.history.setup_namespace(self.user_ns) def set_traps(self): """ Set all of the output, display, and traceback traps. """ self.output_trap.set() self.display_trap.set() self.traceback_trap.set() def unset_traps(self): """ Unset all of the output, display, and traceback traps. """ self.output_trap.unset() self.display_trap.unset() self.traceback_trap.unset() def split_commands(self, python): """ Split multiple lines of code into discrete commands that can be executed singly. Parameters ---------- python : str Pure, exec'able Python code. Returns ------- commands : list of str Separate commands that can be exec'ed independently. """ # compiler.parse treats trailing spaces after a newline as a # SyntaxError. This is different than codeop.CommandCompiler, which # will compile the trailng spaces just fine. We simply strip any # trailing whitespace off. Passing a string with trailing whitespace # to exec will fail however. There seems to be some inconsistency in # how trailing whitespace is handled, but this seems to work. python = python.strip() # The compiler module does not like unicode. We need to convert # it encode it: if isinstance(python, unicode): # Use the utf-8-sig BOM so the compiler detects this a UTF-8 # encode string. python = '\xef\xbb\xbf' + python.encode('utf-8') # The compiler module will parse the code into an abstract syntax tree. # This has a bug with str("a\nb"), but not str("""a\nb""")!!! ast = compiler.parse(python) # Uncomment to help debug the ast tree # for n in ast.node: # print n.lineno,'->',n # Each separate command is available by iterating over ast.node. The # lineno attribute is the line number (1-indexed) beginning the commands # suite. # lines ending with ";" yield a Discard Node that doesn't have a lineno # attribute. These nodes can and should be discarded. But there are # other situations that cause Discard nodes that shouldn't be discarded. # We might eventually discover other cases where lineno is None and have # to put in a more sophisticated test. linenos = [x.lineno-1 for x in ast.node if x.lineno is not None] # When we finally get the slices, we will need to slice all the way to #
# Copyright (c) MONAI Consortium # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ========================================================================= # Adapted from https://github.com/MIC-DKFZ/nnDetection/blob/main/nndet/evaluator/detection/coco.py # which has the following license... # https://github.com/MIC-DKFZ/nnDetection/blob/main/LICENSE # # Copyright 2020 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ========================================================================= # Adapted from https://github.com/cocodataset/cocoapi # which has the following license... # https://github.com/cocodataset/cocoapi/blob/master/license.txt # Copyright (c) 2014, <NAME> and <NAME> # All rights reserved. # Redistribution and use in source and binary forms, with or without # modification, are permitted provided 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 views and conclusions contained in the software and documentation are those # of the authors and should not be interpreted as representing official policies, # either expressed or implied, of the FreeBSD Project. """ This script is almost same with https://github.com/MIC-DKFZ/nnDetection/blob/main/nndet/evaluator/detection/coco.py The changes include 1) code reformatting, 2) docstrings. """ import logging as logger import time from typing import Dict, List, Sequence, Tuple, Union import numpy as np class COCOMetric: def __init__( self, classes: Sequence[str], iou_list: Sequence[float] = (0.1, 0.5, 0.75), iou_range: Sequence[float] = (0.1, 0.5, 0.05), max_detection: Sequence[int] = (1, 5, 100), per_class: bool = True, verbose: bool = True, ): """ Class to compute COCO metrics Metrics computed includes, - mAP over the IoU range specified by `iou_range` at last value of `max_detection` - AP values at IoU thresholds specified by `iou_list` at last value of `max_detection` - AR over max detections thresholds defined by `max_detection` (over iou range) Args: classes (Sequence[str]): name of each class (index needs to correspond to predicted class indices!) iou_list (Sequence[float]): specific thresholds where ap is evaluated and saved iou_range (Sequence[float]): (start, stop, step) for mAP iou thresholds max_detection (Sequence[int]): maximum number of detections per image verbose (bool): log time needed for evaluation Example: .. code-block:: python from monai.data.box_utils import box_iou from monai.apps.detection.metrics.coco import COCOMetric from monai.apps.detection.metrics.matching import matching_batch # 3D example outputs of one image from detector val_outputs_all = [ {"boxes": torch.tensor([[1,1,1,3,4,5]],dtype=torch.float16), "labels": torch.randint(3,(1,)), "scores": torch.randn((1,)).absolute()}, ] val_targets_all = [ {"boxes": torch.tensor([[1,1,1,2,6,4]],dtype=torch.float16), "labels": torch.randint(3,(1,))}, ] coco_metric = COCOMetric( classes=['c0','c1','c2'], iou_list=[0.1], max_detection=[10] ) results_metric = matching_batch( iou_fn=box_iou, iou_thresholds=coco_metric.iou_thresholds, pred_boxes=[val_data_i["boxes"].numpy() for val_data_i in val_outputs_all], pred_classes=[val_data_i["labels"].numpy() for val_data_i in val_outputs_all], pred_scores=[val_data_i["scores"].numpy() for val_data_i in val_outputs_all], gt_boxes=[val_data_i["boxes"].numpy() for val_data_i in val_targets_all], gt_classes=[val_data_i["labels"].numpy() for val_data_i in val_targets_all], ) val_metric_dict = coco_metric(results_metric) print(val_metric_dict) """ self.verbose = verbose self.classes = classes self.per_class = per_class iou_list_np = np.array(iou_list) _iou_range = np.linspace( iou_range[0], iou_range[1], int(np.round((iou_range[1] - iou_range[0]) / iou_range[2])) + 1, endpoint=True ) self.iou_thresholds = np.union1d(iou_list_np, _iou_range) self.iou_range = iou_range # get indices of iou values of ious range and ious list for later evaluation self.iou_list_idx = np.nonzero(iou_list_np[:, np.newaxis] == self.iou_thresholds[np.newaxis])[1] self.iou_range_idx = np.nonzero(_iou_range[:, np.newaxis] == self.iou_thresholds[np.newaxis])[1] if ( not (self.iou_thresholds[self.iou_list_idx] == iou_list_np).all() or not (self.iou_thresholds[self.iou_range_idx] == _iou_range).all() ): raise ValueError( "Require self.iou_thresholds[self.iou_list_idx] == iou_list_np and " "self.iou_thresholds[self.iou_range_idx] == _iou_range." ) self.recall_thresholds = np.linspace(0.0, 1.00, int(np.round((1.00 - 0.0) / 0.01)) + 1, endpoint=True) self.max_detections = max_detection def __call__(self, *args, **kwargs) -> Tuple[Dict[str, float], Union[Dict[str, np.ndarray], None]]: """ Compute metric. See :func:`compute` for more information. Args: *args: positional arguments passed to :func:`compute` **kwargs: keyword arguments passed to :func:`compute` Returns: Dict[str, float]: dictionary with scalar values for evaluation Dict[str, np.ndarray]: dictionary with arrays, e.g. for visualization of graphs """ return self.compute(*args, **kwargs) def check_number_of_iou(self, *args) -> None: """ Check if shape of input in first dimension is consistent with expected IoU values (assumes IoU dimension is the first dimension) Args: args: array like inputs with shape function """ num_ious = len(self.get_iou_thresholds()) for arg in args: if arg.shape[0] != num_ious: raise ValueError( f"Require arg.shape[0] == len(self.get_iou_thresholds()). Got arg.shape[0]={arg.shape[0]}, " f"self.get_iou_thresholds()={self.get_iou_thresholds()}." ) def get_iou_thresholds(self) -> Sequence[float]: """ Return IoU thresholds needed for this metric in an numpy array Returns: Sequence[float]: IoU thresholds [M], M is the number of thresholds """ return list(self.iou_thresholds) def compute(self, results_list: List[Dict[int, Dict[str, np.ndarray]]]) -> Tuple[Dict[str, float], None]: """ Compute COCO metrics Args: results_list (List[Dict[int, Dict[str, np.ndarray]]]): list with results per image (in list) per category (dict). Inner Dict contains multiple results obtained by :func:`box_matching_batch`. - `dtMatches`: matched detections [T, D], where T = number of thresholds, D = number of detections - `gtMatches`: matched ground truth boxes [T, G], where T = number of thresholds, G = number of ground truth - `dtScores`: prediction scores [D] detection scores - `gtIgnore`: ground truth boxes which should be ignored [G] indicate whether ground truth should be ignored - `dtIgnore`: detections which should be ignored [T, D], indicate which detections should be ignored Returns: Dict[str, float], dictionary with coco metrics """ if self.verbose: logger.info("Start COCO metric computation...") tic = time.time() dataset_statistics = self._compute_statistics(results_list=results_list) # Dict[str, Union[np.ndarray, List]] if self.verbose: toc = time.time() logger.info(f"Statistics for COCO metrics finished (t={(toc - tic):0.2f}s).") results = {} results.update(self._compute_ap(dataset_statistics)) results.update(self._compute_ar(dataset_statistics)) if self.verbose: toc = time.time() logger.info(f"COCO metrics computed in t={(toc - tic):0.2f}s.") return results, None def _compute_ap(self, dataset_statistics: Dict[str, Union[np.ndarray, List]]) -> Dict[str, float]: """ Compute AP metrics Args: dataset_statistics (List[Dict[int, Dict[str, np.ndarray]]]): list with result s per image (in list) per category (dict). Inner Dict contains multiple results obtained by :func:`box_matching_batch`. - `dtMatches`: matched detections [T, D], where T = number of thresholds, D = number of detections - `gtMatches`: matched ground truth boxes [T, G], where T = number of thresholds, G = number of ground truth - `dtScores`: prediction scores [D] detection scores - `gtIgnore`: ground truth boxes which should be ignored [G] indicate whether ground truth should be ignored - `dtIgnore`: detections which should be ignored [T, D], indicate which detections should be ignored """ results = {} if self.iou_range: # mAP key = ( f"mAP_IoU_{self.iou_range[0]:.2f}_{self.iou_range[1]:.2f}_{self.iou_range[2]:.2f}_" f"MaxDet_{self.max_detections[-1]}" ) results[key] = self._select_ap(dataset_statistics, iou_idx=self.iou_range_idx, max_det_idx=-1) if self.per_class: for cls_idx, cls_str in enumerate(self.classes): # per class results key = ( f"{cls_str}_" f"mAP_IoU_{self.iou_range[0]:.2f}_{self.iou_range[1]:.2f}_{self.iou_range[2]:.2f}_" f"MaxDet_{self.max_detections[-1]}" ) results[key] = self._select_ap( dataset_statistics, iou_idx=self.iou_range_idx, cls_idx=cls_idx, max_det_idx=-1 ) for idx in self.iou_list_idx: # AP@IoU key = f"AP_IoU_{self.iou_thresholds[idx]:.2f}_MaxDet_{self.max_detections[-1]}" results[key] = self._select_ap(dataset_statistics, iou_idx=[idx], max_det_idx=-1) if self.per_class: for cls_idx, cls_str in enumerate(self.classes): # per class results key = f"{cls_str}_" f"AP_IoU_{self.iou_thresholds[idx]:.2f}_" f"MaxDet_{self.max_detections[-1]}" results[key] = self._select_ap(dataset_statistics, iou_idx=[idx], cls_idx=cls_idx, max_det_idx=-1) return results def _compute_ar(self, dataset_statistics: Dict[str, Union[np.ndarray, List]]) -> Dict[str,
# -*- coding: utf-8 -*- """This python module aims to manage `DokuWiki <https://www.dokuwiki.org/dokuwiki>`_ wikis by using the provided `XML-RPC API <https://www.dokuwiki.org/devel:xmlrpc>`_. It is compatible with python2.7 and python3+. Installation ------------ It is on `PyPi <https://pypi.python.org/pypi/dokuwiki>`_ so you can use the ``pip`` command to install it:: pip install dokuwiki Otherwise sources are in `github <https://github.com/fmenabe/python-dokuwiki>`_ """ import re import sys import base64 import weakref from xml.parsers.expat import ExpatError if sys.version_info[0] == 3: from xmlrpc.client import ServerProxy, Binary, Fault, Transport from urllib.parse import urlencode else: from xmlrpclib import ServerProxy, Binary, Fault, Transport from urllib import urlencode from datetime import datetime, timedelta ERR = 'XML or text declaration not at start of entity: line 2, column 0' _URL_RE = re.compile(r'(?P<proto>https?)://(?P<host>[^/]*)(?P<uri>/.*)?') def date(date): """DokuWiki returns dates of `xmlrpclib`/`xmlrpc.client` ``DateTime`` type and the format changes between DokuWiki versions ... This function convert *date* to a `datetime` object. """ date = date.value return (datetime.strptime(date[:-5], '%Y-%m-%dT%H:%M:%S') if len(date) == 24 else datetime.strptime(date, '%Y%m%dT%H:%M:%S')) def utc2local(date): """DokuWiki returns date with a +0000 timezone. This function convert *date* to the local time. """ date_offset = (datetime.now() - datetime.utcnow()) # Python < 2.7 don't have the 'total_seconds' method so calculate it by hand! date_offset = (date_offset.microseconds + (date_offset.seconds + date_offset.days * 24 * 3600) * 1e6) / 1e6 date_offset = int(round(date_offset / 60 / 60)) return date + timedelta(hours=date_offset) class DokuWikiError(Exception): """Exception raised by this module when there is an error.""" pass class CookiesTransport(Transport): """A Python3 xmlrpc.client.Transport subclass that retains cookies.""" def __init__(self): Transport.__init__(self) self._cookies = dict() def send_headers(self, connection, headers): if self._cookies: cookies = map(lambda x: x[0] + '=' + x[1], self._cookies.items()) connection.putheader("Cookie", "; ".join(cookies)) Transport.send_headers(self, connection, headers) def parse_response(self, response): """parse and store cookie""" try: for header in response.msg.get_all("Set-Cookie"): cookie = header.split(";", 1)[0] cookieKey, cookieValue = cookie.split("=", 1) self._cookies[cookieKey] = cookieValue finally: return Transport.parse_response(self, response) class CookiesTransport2(Transport): """A Python2 xmlrpclib.Transport subclass that retains cookies.""" def __init__(self): Transport.__init__(self) self._cookies = dict() def send_request(self, connection, handler, request_body): Transport.send_request(self, connection, handler, request_body) # set cookie below handler if self._cookies: cookies = map(lambda x: x[0] + '=' + x[1], self._cookies.items()) connection.putheader("Cookie", "; ".join(cookies)) def parse_response(self, response): """parse and store cookie""" try: for header in response.getheader("set-cookie").split(", "): # filter 'expire' information if not header.startswith("D"): continue cookie = header.split(";", 1)[0] cookieKey, cookieValue = cookie.split("=", 1) self._cookies[cookieKey] = cookieValue finally: return Transport.parse_response(self, response) class DokuWiki(object): """Initialize a connection to a DokuWiki wiki. *url*, *user* and *password* are respectively the URL, the login and the password for connecting to the wiki. *kwargs* are `xmlrpclib`/`xmlrpc.client` **ServerProxy** parameters. The exception `DokuWikiError` is raised if the authentification fails but others exceptions (like ``gaierror`` for invalid domain, ``ProtocolError`` for an invalid wiki, ...) are not catched. .. code:: try: wiki = dokuwiki.DokuWiki('URL', 'USER', 'PASSWORD', cookieAuth=False) except (DokuWikiError, Exception) as err: print('unable to connect: %s' % err) """ def __init__(self, url, user, password, cookieAuth=False, **kwargs): """Initialize the object by connecting to the XMLRPC server.""" # Initialize XMLRPC client. try: params = _URL_RE.search(url).groupdict() if cookieAuth == False: url = '%s://%s:%s@%s%s/lib/exe/xmlrpc.php' % ( params['proto'], user, password, params['host'], params['uri'] or '') else: url = '%s://%s%s/lib/exe/xmlrpc.php' % ( params['proto'], params['host'], params['uri'] or '') except AttributeError: raise DokuWikiError("invalid url '%s'" % url) if cookieAuth == False: self.proxy = ServerProxy(url, **kwargs) else: if sys.version_info[0] == 3: self.proxy = ServerProxy(url, CookiesTransport(), **kwargs) else: self.proxy = ServerProxy(url, CookiesTransport2(), **kwargs) # Force login to check the connection. if not self.login(user, password): raise DokuWikiError('invalid login or password!') # Set "namespaces" for pages and medias functions. self.pages = _Pages(weakref.ref(self)()) self.medias = _Medias(weakref.ref(self)()) def send(self, command, *args, **kwargs): """Generic method for executing an XML-RPC *command*. *args* and *kwargs* are the arguments and parameters needed by the command. """ args = list(args) if kwargs: args.append(kwargs) method = self.proxy for elt in command.split('.'): method = getattr(method, elt) try: return method(*args) except Fault as err: if err.faultCode == 121: return {} elif err.faultCode == 321: return [] raise DokuWikiError(err) except ExpatError as err: if str(err) != ERR: raise DokuWikiError(err) @property def version(self): """Property that returns the DokuWiki version of the remote Wiki.""" return self.send('dokuwiki.getVersion') @property def time(self): """Property that returns the current time at the remote wiki server as Unix timestamp. """ return self.send('dokuwiki.getTime') @property def xmlrpc_version(self): """Property that returns the XML RPC interface version of the remote Wiki. This is DokuWiki implementation specific and independent of the supported standard API version returned by ``wiki.getRPCVersionSupported``. """ return self.send('dokuwiki.getXMLRPCAPIVersion') @property def xmlrpc_supported_version(self): """Property that returns *2* with the supported RPC API version.""" return self.send('wiki.getRPCVersionSupported') @property def title(self): """Property that returns the title of the wiki.""" return self.send('dokuwiki.getTitle') def login(self, user, password): """Log to the wiki using *user* and *password* credentials. It returns a boolean that indicates if the user succesfully authenticate.""" return self.send('dokuwiki.login', user, password) def add_acl(self, scope, user, permission): """Add an `ACL <https://www.dokuwiki.org/acl>`_ rule that restricts the page/namespace *scope* to *user* (use *@group* syntax for groups) with *permission* level. It returns a boolean that indicate if the rule was correctly added. """ return self.send('plugin.acl.addAcl', scope, user, permission) def del_acl(self, scope, user): """Delete any ACL matching the given *scope* and *user* (or group if *@group* syntax is used). It returns a boolean that indicate if the rule was correctly removed. """ return self.send('plugin.acl.delAcl', scope, user) class _Pages(object): """This object regroup methods for managing pages of a DokuWiki. This object is accessible from the ``pages`` property of an `DokuWiki` instance:: wiki = dokuwiki.DokuWiki('URL', 'User', 'Password') wiki.pages.list() """ def __init__(self, dokuwiki): self._dokuwiki = dokuwiki def list(self, namespace='/', **options): """List all pages of the given *namespace*. Valid *options* are: * *depth*: (int) recursion level, 0 for all * *hash*: (bool) do an md5 sum of content * *skipacl*: (bool) list everything regardless of ACL """ return self._dokuwiki.send('dokuwiki.getPagelist', namespace, options) def changes(self, timestamp): """Returns a list of changes since given *timestamp*. For example, for returning all changes since *2016-01-01*:: from datetime import datetime wiki.pages.changes(datetime(2016, 1, 1).timestamp()) """ return self._dokuwiki.send('wiki.getRecentChanges', timestamp) def search(self, string): """Performs a fulltext search on *string* and returns the first 15 results. """ return self._dokuwiki.send('dokuwiki.search', string) def versions(self, page, offset=0): """Returns the available versions of *page*. *offset* can be used to list earlier versions in the history. """ return self._dokuwiki.send('wiki.getPageVersions', page, offset) def info(self, page, version=None): """Returns informations of *page*. Informations of the last version is returned if *version* is not set. """ return (self._dokuwiki.send('wiki.getPageInfoVersion', page, version) if version is not None else self._dokuwiki.send('wiki.getPageInfo', page)) def get(self, page, version=None): """Returns the content of *page*. The content of the last version is returned if *version* is not set. """ return (self._dokuwiki.send('wiki.getPageVersion', page, version) if version is not None else self._dokuwiki.send('wiki.getPage', page)) def append(self, page, content, **options): """Appends *content* text to *page*. Valid *options* are: * *sum*: (str) change summary * *minor*: (bool) whether this is a minor change """ return self._dokuwiki.send('dokuwiki.appendPage', page, content, options) def html(self, page, version=None): """Returns HTML content of *page*. The HTML content of the last version of the page is returned if *version* is not set. """ return (self._dokuwiki.send('wiki.getPageHTMLVersion', page, version) if version is not None else self._dokuwiki.send('wiki.getPageHTML', page)) def set(self, page, content, **options): """Set/replace the *content* of *page*. Valid *options* are: * *sum*: (str) change summary * *minor*: (bool) whether this is a minor change """ try: return self._dokuwiki.send('wiki.putPage', page, content, options) except ExpatError as err: # Sometime the first line of the XML response is blank which raise # the 'ExpatError' exception although the change has been done. This # allow to ignore the error. if str(err) != ERR: raise DokuWikiError(err) def delete(self, page): """Delete *page* by setting an empty content.""" return self.set(page, '') def lock(self, page): """Locks *page*.""" result = self._dokuwiki.send('dokuwiki.setLocks', lock=[page], unlock=[]) if result['lockfail']: raise DokuWikiError('unable to lock page') def unlock(self, page): """Unlocks *page*.""" result = self._dokuwiki.send('dokuwiki.setLocks', lock=[], unlock=[page]) if result['unlockfail']: raise DokuWikiError('unable to unlock page') def permission(self, page): """Returns the permission level of *page*.""" return self._dokuwiki.send('wiki.aclCheck', page) def links(self, page): """Returns a list of all links contained in *page*.""" return self._dokuwiki.send('wiki.listLinks', page) def backlinks(self, page): """Returns a list of all links referencing *page*.""" return self._dokuwiki.send('wiki.getBackLinks', page) class _Medias(object): """This
database change flag and the version number. self.changed = 1 self.version += 1 # Return the results. return val def __remove(self,which,var): # Special helper function - it assumes the table is already locked. This is # used in the loading function when a variable needs to be removed. # # Do we have the specific sub-dictionary we need? If not, the # variable doesn't exist, so no need in gaing any further. if which in self.db.keys(): # Does the variable exist in the dictionary? if var in self.db[which].keys(): # Yes. So delete it from the dictionary. del self.db[which][var] # If there is an expiry on the variable, get rid of it too. self.__clearExpire(which,var) @synchronized(lock) def remove(self,which,var): # Do the actual remove self.__remove(which,var) # Increment the total op. count. self.totalOperations += 1 self.totalChangeOperations += 1 # Update the database change flag and the version number. self.changed = 1 self.version += 1 @synchronized(lock) def keys(self,which,match): """ Return all the variable names in the database. """ matched = [x for x in self.db[which].keys() if fnmatch.fnmatch(x,match)] s = " ".join(matched) # Increment the total op. count. self.totalOperations += 1 # Return results return s @synchronized(lock) def re(self,which,match): """ Return all the variable names in the database that match a the regular expression. """ p = re.compile(match) matched = [x for x in self.db[which].keys() if p.match(x)] s = " ".join(matched) # Increment the total op. count. self.totalOperations += 1 # Return results return s @synchronized(lock) def getType(self,which,var): """ Return the type of a variable, which can be one of: none - variable doesn't exist string - variable is a string type list - variable is a list set - variable is a set """ if var in self.db[which].keys(): val = self.db[which][var] if type(val) is type(""): val = "string" elif type(val) is type([]): val = "list" else: val = "set" else: val = "none" # Imcrement the total op. count. self.totalOperations += 1 # Return the results return val def __expire(self,which,var,secs): # Special helper function; used when loading files. # dt = time.time() + secs self.__setExpire(which,var,dt) # Trigger an event to remove it. self.timerque.enq({'data': [which,var,self], 'timestamp':dt }) @synchronized(lock) def expire(self,which,var,secs): """ Set an time to live limit on a variable. The variable must exist and the time is given in seconds. Tiem to live values live across invocations. """ # Make sure we have the variable in the system. if var not in self.db[which].keys(): raise ERR("no such key") # See if there is an expiration already on the variable. If so # we don't update it. Otherwise we do set it. Notice if we don't # take the "then" clause the return code is 0. This means it # failed. if self.__isExpire(which,var) == 0: self.__expire(which,var,secs) # Things have changed... self.changed = 1 self.version += 1 # UPdate the operation count. self.totalOperations += 1 # Return the results return 1 @synchronized(lock) def getTTL(self,which,var): """ Get the current time to live value for a variable. """ # Just check to see if the expire exists. pass @synchronized(lock) def flushAll(self): """ Remove all the variables behind all the database tables. """ self.db = {"0":{}} self.expiredb = {} # Increment the total op. count. self.totalOperations += 1 self.totalChangeOperations += 1 # Update the database change flag and the version number. self.changed = 1 self.version += 1 @synchronized(lock) def flush(self,which): """ Remove all the variables behind a specific table. """ self.db[which] = {} self.expiredb[which] = {} # Increment the total op. count. self.totalOperations += 1 self.totalChangeOperations += 1 # Update the database change flag and the version number. self.changed = 1 self.version += 1 @synchronized(lock) def size(self,which): """ Return the number of keys in a specific table. """ # Compute how many keys are in the subdictionary val = len(self.db[which].keys()) # Update the counters. self.totalOperations += 1 # Return the count. return val @synchronized(lock) def insert(self,which,var,index,val): # Insert it... if index == -1: self.db[which][var].append(val) else : self.db[which][var].insert(index,val) # Increment the total op. count. self.totalOperations += 1 self.totalChangeOperations += 1 # Update the database change flag and the version number. self.changed = 1 self.version += 1 @synchronized(lock) def listlen(self,which,var): # Get the length of the list rc = len(self.db[which][var]) # Update the total op. counter self.totalOperations += 1 # Return the results. return rc @synchronized(lock) def lrange(self,which,var,s,e): # Does the variable exist? if var in self.db[which].keys(): # Yes, so just extract the piece we want. v = self.db[which][var] if s < 0 : s = len(v) + s if e < 0 : e = len(v) + e e = e + 1 rc = v[s:e] else: # Nope, return an empty list. rc = [] # Update the operation counter. self.totalOperations += 1 # Return the results return rc @synchronized(lock) def ltrim(self,which,var,s,e): # Update the list variable...we keep the slice [s;e] of the list v = self.db[which][var] if e > len(v): e = len(v) try: self.db[which][var] = v[s:e] except IndexError: self.db[which][var] = [] # Increment the total op. count. self.totalOperations += 1 self.totalChangeOperations += 1 # Update the database change flag and the version number. self.changed = 1 self.version += 1 @synchronized(lock) def lindex(self,which,var,i): try: r = self.db[which][var][i] except IndexError: r = None self.totalOperations += 1 return r @synchronized(lock) def lset(self,which,var,i,val): # Find the variable and make sure we have a good # index. r = self.db[which][var] if i >= len(r): self.totalOperations += 1 return -1 r[i] = val # Increment the total op. count. self.totalOperations += 1 self.totalChangeOperations += 1 # Update the database change flag and the version number. self.changed = 1 self.version += 1 # Return the results return 0 @synchronized(lock) def lrem(self,which,var,num,val): # Get the list we are to change...we are going to remove # at least 'num' instances of 'val' from the list. If # num is 0, we will remove all instances. v = self.db[which][var] if num >= 0 : start = 0 end = len(v) incr = 1 rev = 0 if num == 0: num = end else: start = len(v)-1 end = -1 incr = -1 num = abs(num) rev = 1 l = [] cnt = 0 for i in range(start,end,incr): if v[i] != val: l.append(v[i]) else: if num > 0: cnt = cnt + 1 num = num - 1 else: l.append(v[i]) # Append always puts things at the end of the list, which is okay # if we are scanning the list from 0 to the end ( num > -1). If we # are scanning it the other way, we need to reverse the list. if rev : l.reverse() self.db[which][var] = l # Increment the total op. count. self.totalOperations += 1 self.totalChangeOperations += 1 # Update the database change flag and the version number. self.changed = 1 self.version += 1 # Return the results. return cnt @synchronized(lock) def lpop(self,which,var): try: # Does the variable exist? If so, pop it off the # front of the list. If not, return None! if var in self.db[which].keys(): rc = self.db[which][var].pop(0) else: rc = None except IndexError: rc = None # Increment the total op. count. self.totalOperations += 1 self.totalChangeOperations += 1 # Update the database change flag and the version number. self.changed = 1 self.version += 1 # Return either None, if there is no list or nothing # on it or the thing. return rc @synchronized(lock) def rpop(self,which,var): try: # See lpop for commentary... if var in self.db[which].keys(): rc = self.db[which][var].pop() else: rc = None except IndexError: rc = None # Increment the total op. count. self.totalOperations += 1 self.totalChangeOperations += 1 # Update the database change flag and the version number. self.changed = 1 self.version += 1 # Return any defined values. return rc @synchronized(lock) def sadd(self,which,var,item): if var not in self.db[which].keys(): self.db[which][var] = set() if item in
<reponame>mlraglin/fury """UI container module.""" __all__ = ["Panel2D", "TabPanel2D", "TabUI", "ImageContainer2D", "GridUI"] import numpy as np import vtk from fury.io import load_image from fury.ui.core import UI, Rectangle2D, TextBlock2D from fury.utils import set_input, rotate from fury.actor import grid class Panel2D(UI): """A 2D UI Panel. Can contain one or more UI elements. Attributes ---------- alignment : [left, right] Alignment of the panel with respect to the overall screen. """ def __init__(self, size, position=(0, 0), color=(0.1, 0.1, 0.1), opacity=0.7, align="left"): """Init class instance. Parameters ---------- size : (int, int) Size (width, height) in pixels of the panel. position : (float, float) Absolute coordinates (x, y) of the lower-left corner of the panel. color : (float, float, float) Must take values in [0, 1]. opacity : float Must take values in [0, 1]. align : [left, right] Alignment of the panel with respect to the overall screen. """ super(Panel2D, self).__init__(position) self.resize(size) self.alignment = align self.color = color self.opacity = opacity self.position = position self._drag_offset = None def _setup(self): """Setup this UI component. Create the background (Rectangle2D) of the panel. """ self._elements = [] self.element_offsets = [] self.background = Rectangle2D() self.add_element(self.background, (0, 0)) # Add default events listener for this UI component. self.background.on_left_mouse_button_pressed = self.left_button_pressed self.background.on_left_mouse_button_dragged = self.left_button_dragged def _get_actors(self): """Get the actors composing this UI component.""" actors = [] for element in self._elements: actors += element.actors return actors def _add_to_scene(self, scene): """Add all subcomponents or VTK props that compose this UI component. Parameters ---------- scene : scene """ for element in self._elements: element.add_to_scene(scene) def _get_size(self): return self.background.size def resize(self, size): """Set the panel size. Parameters ---------- size : (float, float) Panel size (width, height) in pixels. """ self.background.resize(size) def _set_position(self, coords): """Set the lower-left corner position of this UI component. Parameters ---------- coords: (float, float) Absolute pixel coordinates (x, y). """ coords = np.array(coords) for element, offset in self.element_offsets: element.position = coords + offset @property def color(self): return self.background.color @color.setter def color(self, color): self.background.color = color @property def opacity(self): return self.background.opacity @opacity.setter def opacity(self, opacity): self.background.opacity = opacity def add_element(self, element, coords, anchor="position"): """Add a UI component to the panel. The coordinates represent an offset from the lower left corner of the panel. Parameters ---------- element : UI The UI item to be added. coords : (float, float) or (int, int) If float, normalized coordinates are assumed and they must be between [0,1]. If int, pixels coordinates are assumed and it must fit within the panel's size. """ coords = np.array(coords) if np.issubdtype(coords.dtype, np.floating): if np.any(coords < 0) or np.any(coords > 1): raise ValueError("Normalized coordinates must be in [0,1].") coords = coords * self.size if anchor == "center": element.center = self.position + coords elif anchor == "position": element.position = self.position + coords else: msg = ("Unknown anchor {}. Supported anchors are 'position'" " and 'center'.") raise ValueError(msg) self._elements.append(element) offset = element.position - self.position self.element_offsets.append((element, offset)) def remove_element(self, element): """Remove a UI component from the panel. Parameters ---------- element : UI The UI item to be removed. """ idx = self._elements.index(element) del self._elements[idx] del self.element_offsets[idx] def update_element(self, element, coords, anchor="position"): """Update the position of a UI component in the panel. Parameters ---------- element : UI The UI item to be updated. coords : (float, float) or (int, int) New coordinates. If float, normalized coordinates are assumed and they must be between [0,1]. If int, pixels coordinates are assumed and it must fit within the panel's size. """ self.remove_element(element) self.add_element(element, coords, anchor) def left_button_pressed(self, i_ren, _obj, panel2d_object): click_pos = np.array(i_ren.event.position) self._drag_offset = click_pos - panel2d_object.position i_ren.event.abort() # Stop propagating the event. def left_button_dragged(self, i_ren, _obj, _panel2d_object): if self._drag_offset is not None: click_position = np.array(i_ren.event.position) new_position = click_position - self._drag_offset self.position = new_position i_ren.force_render() def re_align(self, window_size_change): """Re-organise the elements in case the window size is changed. Parameters ---------- window_size_change : (int, int) New window size (width, height) in pixels. """ if self.alignment == "left": pass elif self.alignment == "right": self.position += np.array(window_size_change) else: msg = "You can only left-align or right-align objects in a panel." raise ValueError(msg) class TabPanel2D(UI): """Render content within a Tab. Attributes ---------- content_panel: :class: 'Panel2D' Hold all the content UI components. text_block: :class: 'TextBlock2D' Renders the title of the tab. """ def __init__(self, position=(0, 0), size=(100, 100), title="New Tab", color=(0.5, 0.5, 0.5), content_panel=None): """Init class instance. Parameters ---------- position : (float, float) Absolute coordinates (x, y) of the lower-left corner of the UI component size : (int, int) Width and height of the pixels of this UI component. title : str Renders the title for Tab panel. color : list of 3 floats Background color of tab panel. content_panel : Panel2D Panel consisting of the content UI elements. """ self.content_panel = content_panel self.panel_size = size self._text_size = (int(1.0 * size[0]), size[1]) super(TabPanel2D, self).__init__() self.title = title self.panel.position = position self.color = color def _setup(self): """Setup this UI component. Create parent panel. Create Text to hold tab information. Create Button to close tab. """ self.panel = Panel2D(size=self.panel_size) self.text_block = TextBlock2D(size=self._text_size, color=(0, 0, 0)) self.panel.add_element(self.text_block, (0, 0)) def _get_actors(self): """Get the actors composing this UI component.""" return self.panel.actors + self.content_panel.actors def _add_to_scene(self, _scene): """Add all subcomponents or VTK props that compose this UI component. Parameters ---------- scene : scene """ self.panel.add_to_scene(_scene) self.content_panel.add_to_scene(_scene) def _set_position(self, _coords): """Set the lower-left corner position of this UI component. Parameters ---------- coords: (float, float) Absolute pixel coordinates (x, y). """ self.panel.position = _coords def _get_size(self): self.panel.size def resize(self, size): """Resize Tab panel. Parameters ---------- size : (int, int) New width and height in pixels. """ self._text_size = (int(0.7 * size[0]), size[1]) self._button_size = (int(0.3 * size[0]), size[1]) self.panel.resize(size) self.text_block.resize(self._text_size) @property def color(self): """Return the background color of tab panel.""" return self.panel.color @color.setter def color(self, color): """Set background color of tab panel. Parameters ---------- color : list of 3 floats. """ self.panel.color = color @property def title(self): """Return the title of tab panel.""" return self.text_block.message @title.setter def title(self, text): """Set the title of tab panel. Parameters ---------- text : str New title for tab panel. """ self.text_block.message = text def add_element(self, element, coords, anchor="position"): """Add a UI component to the content panel. The coordinates represent an offset from the lower left corner of the panel. Parameters ---------- element : UI The UI item to be added. coords : (float, float) or (int, int) If float, normalized coordinates are assumed and they must be between [0,1]. If int, pixels coordinates are assumed and it must fit within the panel's size. """ element.set_visibility(False) self.content_panel.add_element(element, coords, anchor) def remove_element(self, element): """Remove a UI component from the content panel. Parameters ---------- element : UI The UI item to be removed. """ self.content_panel.remove_element(element) def update_element(self, element, coords, anchor="position"): """Update the position of a UI component in the content panel. Parameters ---------- element : UI The UI item to be updated. coords : (float, float) or (int, int) New coordinates. If float, normalized coordinates are assumed and they must be between [0,1]. If int, pixels coordinates are assumed and it must fit within the panel's size. """ self.content_panel.update_element(element, coords, anchor="position") class TabUI(UI): """UI element to add multiple panels within a single window. Attributes ---------- tabs: :class: List of 'TabPanel2D' Stores all the instances of 'TabPanel2D' that renderes the contents. """ def __init__(self, position=(0, 0), size=(100, 100), nb_tabs=1, active_color=(1, 1, 1), inactive_color=(0.5, 0.5, 0.5), draggable=False): """Init class instance. Parameters ---------- position : (float, float) Absolute coordinates (x, y) of the lower-left corner of this UI component. size : (int, int) Width and height in pixels of this UI component. nb_tabs : int Number of tabs to be renders. active_color : tuple of 3 floats. Background color of active tab panel. inactive_color : tuple of 3 floats. Background color of inactive tab panels. draggable : bool Whether the UI element is draggable or not. """ self.tabs = [] self.nb_tabs = nb_tabs self.parent_size = size self.content_size = (size[0], int(0.9 * size[1]))
<filename>cmiputil/dds.py #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Module to parse DDS (Dataset Descriptor Structure) used in OPeNDAP. DDS --- For the definition of DDS, see `OpenDAP UserGuide`_. In this module, we change the notation in the DDS syntax as follows: | *declarations* := list(*declaration*) | *declaration* := *Var* | *Struct* | *Struct* := *stype* { *declarations* } (*name* | *name* *arr*) | *stype* := Dataset|Structure|Sequence|Grid | *Grid* := Grid { ARRAY: *declaration* MAPS: *declarations* } (*name* | *name* *arr*) | *Var* := *btype* (*name* | *name* *arr*) | *btype* := Byte|Int32|UInt32|Float64|String|Url| ... | *arr* := [integer] | [*name* = integer] As you can see from above syntax, one *Struct* can contain other *Struct* recursively, and consists the tree structure. The root of the tree must be one "Dataset". In this module, each element of above syntax is implemented as one class. Basic Usage ----------- Text form of DDS will be obtained by, for example, :meth:`.ESGFDataInfo.getDDS`. Use :func:`parse_dataset` to parse it to get the tree structure. The root of the tree is a :class:`Dataset` instance, and you can access nodes and leafs of the tree by dot notation (see also 'Example' section below):: ds = parse_dataset(text=sample1) ds.tas # Grid('tas, arrary=Var(tas, ...), maps={'time':..., 'lat':..., 'lon':...}) ds.tas.array.arr[0] # Arr('time', 8412) .. _OpenDAP UserGuide: https://opendap.github.io/documentation/UserGuideComprehensive.html#DDS Example: >>> sample1 = ''' ... Dataset { ... Float64 lat[lat = 160]; ... Float64 lat_bnds[lat = 160][bnds = 2]; ... Float64 lon[lon = 320]; ... Float64 lon_bnds[lon = 320][bnds = 2]; ... Float64 height; ... Float64 time[time = 8412]; ... Float64 time_bnds[time = 8412][bnds = 2]; ... Grid { ... ARRAY: ... Float32 tas[time = 8412][lat = 160][lon = 320]; ... MAPS: ... Float64 time[time = 8412]; ... Float64 lat[lat = 160]; ... Float64 lon[lon = 320]; ... } tas; ... } CMIP6.CMIP.MRI.MRI-ESM2-0.piControl.r1i1p1f1.Amon.tas.gn.tas.20190222.aggregation.1;''' >>> sample1_struct = Dataset( ... 'CMIP6.CMIP.MRI.MRI-ESM2-0.piControl.r1i1p1f1.Amon.tas.gn.tas.20190222.aggregation.1', ... { ... 'lat': ... Var('lat', 'Float64', arr=[Arr('lat', 160)]), ... 'lat_bnds': ... Var('lat_bnds', 'Float64', arr=[Arr('lat', 160), ... Arr('bnds', 2)]), ... 'lon': ... Var('lon', 'Float64', arr=[Arr('lon', 320)]), ... 'lon_bnds': ... Var('lon_bnds', 'Float64', arr=[Arr('lon', 320), ... Arr('bnds', 2)]), ... 'height': ... Var('height', 'Float64'), ... 'time': ... Var('time', 'Float64', arr=[Arr('time', 8412)]), ... 'time_bnds': ... Var('time_bnds', 'Float64', arr=[Arr('time', 8412), ... Arr('bnds', 2)]), ... 'tas': ... Grid('tas', ... array=Var( ... 'tas', ... 'Float32', ... arr=[Arr('time', 8412), ... Arr('lat', 160), ... Arr('lon', 320)]), ... maps={ ... 'time': Var('time', 'Float64', arr=[Arr('time', 8412)]), ... 'lat': Var('lat', 'Float64', arr=[Arr('lat', 160)]), ... 'lon': Var('lon', 'Float64', arr=[Arr('lon', 320)]) ... }) ... }) >>> sample1_struct == parse_dataset(sample1) True >>> from cmiputil import dds >>> sample2 = ''' ... Dataset { ... Int32 catalog_number; ... Sequence { ... String experimenter; ... Int32 time; ... Structure { ... Float64 latitude; ... Float64 longitude; ... } location; ... Sequence { ... Float64 depth; ... Float64 salinity; ... Float64 oxygen; ... Float64 temperature; ... } cast; ... } station; ... } data; ... ''' >>> sample2_struct = Dataset( ... 'data', { ... 'catalog_number': ... Var('catalog_number', 'Int32'), ... 'station': ... Sequence( ... 'station', { ... 'experimenter': ... Var('experimenter', 'String'), ... 'time': ... Var('time', 'Int32'), ... 'location': ... Structure( ... 'location', { ... 'latitude': Var('latitude', 'Float64'), ... 'longitude': Var('longitude', 'Float64') ... }), ... 'cast': ... Sequence( ... 'cast', { ... 'depth': Var('depth', 'Float64'), ... 'salinity': Var('salinity', 'Float64'), ... 'oxygen': Var('oxygen', 'Float64'), ... 'temperature': Var('temperature', 'Float64') ... }) ... }) ... }) >>> sample2_struct == parse_dataset(sample2) True >>> sample3 = ''' ... Dataset { ... Structure { ... Float64 lat; ... Float64 lon; ... } location; ... Structure { ... Int32 minutes; ... Int32 day; ... Int32 year; ... } time; ... Float64 depth[500]; ... Float64 temperature[500]; ... } xbt-station; ... ''' >>> sample3_struct = Dataset( ... 'xbt-station', { ... 'location': ... Structure('location', { ... 'lat': Var('lat', 'Float64'), ... 'lon': Var('lon', 'Float64') ... }), ... 'time': ... Structure( ... 'time', { ... 'minutes': Var('minutes', 'Int32'), ... 'day': Var('day', 'Int32'), ... 'year': Var('year', 'Int32') ... }), ... 'depth': ... Var('depth', 'Float64', arr=[Arr('', 500)]), ... 'temperature': ... Var('temperature', 'Float64', arr=[Arr('', 500)]) ... }) >>> sample3_struct == parse_dataset(sample3) True """ import enum import re import textwrap as tw from pprint import pprint _debug = False def _enable_debug(): global _debug _debug = True def _disable_debug(): global _debug _debug = False def _debug_write(text): global _debug if _debug: print(text) class BType(enum.Enum): """ Values for :attr:`.Var.btype`. """ Byte = 'Byte' Int16 = 'Int16' Int32 = 'Int32' UInt32 = 'UInt32' Float32 = 'Float32' Float64 = 'Float64' String = 'String' Url = 'Url' class SType(enum.Enum): """ Values for :attr:`Struct.stype` """ Dataset = 'Dataset' Structure = 'Structure' Sequence = 'Sequence' Grid = 'Grid' _idents_btype = [t.name for t in BType] _idents_stype = [t.name for t in SType] _idents = _idents_btype + _idents_stype _pat_idents_stype = re.compile(r'^\s*(' + '|'.join(_idents_stype) + ')') _pat_ident = re.compile(r'^\s*(' + '|'.join(_idents) + ')') _pat_struct = re.compile( r'^\s*(' + r'|'.join(_idents_stype) + r')\s*\{(.*)\}\s*(\S+);\s*', re.DOTALL) _pat_dataset = re.compile(r'^\s*Dataset\s+' r'\{(.+)\}\s*(\S+);\s*$', re.DOTALL) _pat_grid = re.compile( r'^\s*Grid\s*\{\s*Array:(.+)Maps:' r'\s*(.+)\s*\}\s*(\w+);', re.IGNORECASE | re.DOTALL) _pat_varline = re.compile(r'^\s*(\w+)\s*(\w+)(\[.+\])*;\s*$', re.DOTALL) _pat_arrdecl = re.compile(r'\[(\w+?)\s*=\s*(\d+)\]') _pat_arrdecl_valonly = re.compile(r'^s*\[(\d+)]') _pat_arrdecl_line = re.compile(r'\[(?:\w+?\s*=)*\s*\d+\]') class Decls(dict): """ Class for *declarations*. | *declarations* := list(*declaration*) In this module, *declarations* are expressed as `dict`, not `list`. At this point, this class is just an alias for `dict`. """ pass class Decl: """ Class for *declaration*, that is, base class for :class:`Var` and :class:`Struct`. No need to use this class explicitly. | *declaration* := *Var* | *Struct* """ def __init__(self, name=''): self.name = name def __eq__(self, other): _debug_write(f'Decl.__eq__():{type(self)},{type(other)}') if not isinstance(other, type(self)): return False res = [getattr(self, a) == getattr(other, a) for a in self.__dict__] return all(res) def text_formatted(self, indent=None, linebreak=True): pass class Struct(Decl): """ Class for *struct*, that is, base class for :class:`Structure`, :class:`Sequence`, :class:`Grid` and :class:`Dataset`. Do not use this directly. | *struct* := *stype* { *declarations* } *var* | *stype* := Dataset|Structure|Sequence|Grid You can access items of ``self.decl`` as if they are the attribute of this class, via dot notation. Examples: >>> text = ''' ... Sequence { ... Float64 depth; ... Float64 salinity; ... Float64 oxygen; ... Float64 temperature; ... } cast;''' >>> s = Sequence(text=text) >>> s.salinity Var('salinity', 'Float64') >>> text = ''' ... Dataset { ... Int32 catalog_number; ... Sequence { ... String experimenter; ... Int32 time; ... Structure { ... Float64 latitude; ... Float64 longitude; ... } location; ... } station; ... } data;''' >>> d = parse_dataset(text) >>> d.station.location.latitude Var('latitude', 'Float64') Attributes: name(str): *name* stype(SType): *stype* decl(Decls)): *declarations* """ stype = None def __init__(self, name='', decl=None, text=None): """ Parameters: name(str): *name* decl(str or Decls)): *declarations* text(str): text to be parsed. If `text` is *not* ``None``, other attributes are overridden by the result of :meth:`.parse` or left untouced.. """ if text: _debug_write(f'{self.__class__.__name__}' f"text='{text}'") self.parse(text) else: self.name = name if decl is None: self.decl = None elif isinstance(decl, dict): self.decl = decl elif type(decl) is str: self.decl = parse_declarations(decl) else: raise TypeError(f'decl={decl} is invalid type: {type(decl)}') def parse(self, text): """ Parse `text` to construct :class:`Struct`. If given `text` is not valid for each subclass, the instance is left as 'null' instance. """ _debug_write(f'{self.__class__.__name__}.parse: text="{text}"') res = _pat_struct.match(text) if not res: return None _debug_write(f'{self.__class__.__name__}.parse:name="{res.group(3)}"') _debug_write(f'{self.__class__.__name__}.parse:decl="{res.group(2)}"') if self.stype and self.stype == SType(res.group(1)): self.decl = parse_declarations(res.group(2)) self.name = res.group(3) def __getattr__(self, key): # print('__getattr__() called') if key in self.decl: return self.decl[key] else: raise AttributeError( f"'{self.__class__.__name__}' object has no attribute '{key}'") def __getitem__(self, key): # print('__getitem__() called') if key in self.decl: return self.decl[key] else: raise KeyError(f"'{key}'") def __contains__(self, item): # print('__contains__() called') return (item in self.__dict__) or (item in self.decl) def __repr__(self): if self.name: name = f"'{self.name}'" else: name = '' if self.decl: # decl = f'decl={self.decl.__repr__()}' decl = f'{self.decl.__repr__()}' else: decl = '' res = ', '.join([l for l in [name, decl] if l]) return (f'{self.__class__.__name__}({res})') def __str__(self): return self.text_formatted() def text_formatted(self, indent=4, linebreak=True): """ Return formatted text. """ _debug_write( f'{self.__class__.__name__}.text_formatted:indent={indent},linebreak={linebreak}' ) if self.name: name = self.name + ';' else: name = '' if self.stype: stype = f'{self.stype.name}' else: stype = '' if self.decl: if linebreak: lb = '\n' else: lb = '' decl = f'{lb}'.join([ self.decl[d].text_formatted(indent, linebreak) for d in self.decl if d ]) decl = tw.indent(decl, ' ' * indent) decl = f'{lb}'.join(('{',
]) self.ContentionCount = v_uint32() self.NumberOfSharedWaiters = v_uint16() self.NumberOfExclusiveWaiters = v_uint16() self.Address = v_ptr32() self.SpinLock = v_uint32() class FILE_NETWORK_OPEN_INFORMATION(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.CreationTime = LARGE_INTEGER() self.LastAccessTime = LARGE_INTEGER() self.LastWriteTime = LARGE_INTEGER() self.ChangeTime = LARGE_INTEGER() self.AllocationSize = LARGE_INTEGER() self.EndOfFile = LARGE_INTEGER() self.FileAttributes = v_uint32() self._pad0038 = v_bytes(size=4) class GENERAL_LOOKASIDE::__unnamed(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.LastAllocateMisses = v_uint32() class OBJECTOWNER_S(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Lock = v_uint32() class OBJECT_HANDLE_INFORMATION(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.HandleAttributes = v_uint32() self.GrantedAccess = v_uint32() class IRP::__unnamed(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Overlay = IRP::__unnamed::__unnamed() self._pad0030 = v_bytes(size=8) class INITIAL_PRIVILEGE_SET(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.PrivilegeCount = v_uint32() self.Control = v_uint32() self.Privilege = vstruct.VArray([ LUID_AND_ATTRIBUTES() for i in xrange(3) ]) class ULARGE_INTEGER(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.LowPart = v_uint32() self.HighPart = v_uint32() class GENERAL_LOOKASIDE(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.ListHead = SLIST_HEADER() self.Depth = v_uint16() self.MaximumDepth = v_uint16() self.TotalAllocates = v_uint32() self.AllocateMisses = v_uint32() self.TotalFrees = v_uint32() self.FreeMisses = v_uint32() self.Type = v_uint32() self.Tag = v_uint32() self.Size = v_uint32() self.Allocate = v_ptr32() self.Free = v_ptr32() self.ListEntry = LIST_ENTRY() self.LastTotalAllocates = v_uint32() self.LastAllocateMisses = v_uint32() self.Future = vstruct.VArray([ v_uint32() for i in xrange(2) ]) class EX_PUSH_LOCK(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Waiting = v_uint32() class CM_PARTIAL_RESOURCE_DESCRIPTOR::__unnamed(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Generic = CM_PARTIAL_RESOURCE_DESCRIPTOR::__unnamed::__unnamed() class SECTION_OBJECT_POINTERS(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.DataSectionObject = v_ptr32() self.SharedCacheMap = v_ptr32() self.ImageSectionObject = v_ptr32() class DEVOBJ_EXTENSION(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Type = v_uint16() self.Size = v_uint16() self.DeviceObject = v_ptr32() class tagVSTATE(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.fl = v_uint32() self.bSystemStable = v_uint32() self.ulRandomSeed = v_uint32() self.ulFailureMask = v_uint32() self.ulDebugLevel = v_uint32() self.hsemPoolTracker = v_ptr32() self.lePoolTrackerHead = LIST_ENTRY() class EX_RUNDOWN_REF::__unnamed(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Count = v_uint32() class POWER_STATE(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.SystemState = v_uint32() class UNICODE_STRING(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Length = v_uint16() self.MaximumLength = v_uint16() self.Buffer = v_ptr32() class GDIHandleBitFields(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Index = v_uint32() class ACCESS_STATE(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.OperationID = LUID() self.SecurityEvaluated = v_uint8() self.GenerateAudit = v_uint8() self.GenerateOnClose = v_uint8() self.PrivilegesAllocated = v_uint8() self.Flags = v_uint32() self.RemainingDesiredAccess = v_uint32() self.PreviouslyGrantedAccess = v_uint32() self.OriginalDesiredAccess = v_uint32() self.SubjectSecurityContext = SECURITY_SUBJECT_CONTEXT() self.SecurityDescriptor = v_ptr32() self.AuxData = v_ptr32() self.Privileges = ACCESS_STATE::__unnamed() self.AuditPrivileges = v_uint8() self._pad0064 = v_bytes(size=3) self.ObjectName = UNICODE_STRING() self.ObjectTypeName = UNICODE_STRING() class FILE_STANDARD_INFORMATION(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.AllocationSize = LARGE_INTEGER() self.EndOfFile = LARGE_INTEGER() self.NumberOfLinks = v_uint32() self.DeletePending = v_uint8() self.Directory = v_uint8() self._pad0018 = v_bytes(size=2) class KAPC(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Type = v_uint16() self.Size = v_uint16() self.Spare0 = v_uint32() self.Thread = v_ptr32() self.ApcListEntry = LIST_ENTRY() self.KernelRoutine = v_ptr32() self.RundownRoutine = v_ptr32() self.NormalRoutine = v_ptr32() self.NormalContext = v_ptr32() self.SystemArgument1 = v_ptr32() self.SystemArgument2 = v_ptr32() self.ApcStateIndex = v_uint8() self.ApcMode = v_uint8() self.Inserted = v_uint8() self._pad0030 = v_bytes(size=1) class WAIT_CONTEXT_BLOCK(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.WaitQueueEntry = KDEVICE_QUEUE_ENTRY() self.DeviceRoutine = v_ptr32() self.DeviceContext = v_ptr32() self.NumberOfMapRegisters = v_uint32() self.DeviceObject = v_ptr32() self.CurrentIrp = v_ptr32() self.BufferChainingDpc = v_ptr32() class EX_PUSH_LOCK::__unnamed(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Waiting = v_uint32() class MDL(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Next = v_ptr32() self.Size = v_uint16() self.MdlFlags = v_uint16() self.Process = v_ptr32() self.MappedSystemVa = v_ptr32() self.StartVa = v_ptr32() self.ByteCount = v_uint32() self.ByteOffset = v_uint32() class EX_RUNDOWN_REF(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Count = v_uint32() class W32THREAD(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.pEThread = v_ptr32() self.RefCount = v_uint32() self.ptlW32 = v_ptr32() self.pgdiDcattr = v_ptr32() self.pgdiBrushAttr = v_ptr32() self.pUMPDObjs = v_ptr32() self.pUMPDHeap = v_ptr32() self.dwEngAcquireCount = v_uint32() self.pSemTable = v_ptr32() self.pUMPDObj = v_ptr32() class KDPC(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Type = v_uint16() self.Number = v_uint8() self.Importance = v_uint8() self.DpcListEntry = LIST_ENTRY() self.DeferredRoutine = v_ptr32() self.DeferredContext = v_ptr32() self.SystemArgument1 = v_ptr32() self.SystemArgument2 = v_ptr32() self.Lock = v_ptr32() class OWNER_ENTRY(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.OwnerThread = v_uint32() self.OwnerCount = v_uint32() class KEVENT(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Header = DISPATCHER_HEADER() class KSEMAPHORE(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Header = DISPATCHER_HEADER() self.Limit = v_uint32() class PAGED_LOOKASIDE_LIST(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.L = GENERAL_LOOKASIDE() self.Lock__ObsoleteButDoNotDelete = FAST_MUTEX() class OBJECT_TYPE(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Mutex = ERESOURCE() self.TypeList = LIST_ENTRY() self.Name = UNICODE_STRING() self.DefaultObject = v_ptr32() self.Index = v_uint32() self.TotalNumberOfObjects = v_uint32() self.TotalNumberOfHandles = v_uint32() self.HighWaterNumberOfObjects = v_uint32() self.HighWaterNumberOfHandles = v_uint32() self.TypeInfo = OBJECT_TYPE_INITIALIZER() self.Key = v_uint32() self.ObjectLocks = vstruct.VArray([ ERESOURCE() for i in xrange(4) ]) class DEVICE_OBJECT::__unnamed(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.ListEntry = LIST_ENTRY() self._pad0028 = v_bytes(size=32) class DISPATCHER_HEADER(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Type = v_uint8() self.Absolute = v_uint8() self.Size = v_uint8() self.Inserted = v_uint8() self.SignalState = v_uint32() self.WaitListHead = LIST_ENTRY() class IRP::__unnamed::__unnamed::__unnamed::__unnamed(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.CurrentStackLocation = v_ptr32() class HOBJ(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.unused = v_uint32() class IO_TIMER(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) class OBJECT_TYPE_INITIALIZER(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Length = v_uint16() self.UseDefaultObject = v_uint8() self.CaseInsensitive = v_uint8() self.InvalidAttributes = v_uint32() self.GenericMapping = GENERIC_MAPPING() self.ValidAccessMask = v_uint32() self.SecurityRequired = v_uint8() self.MaintainHandleCount = v_uint8() self.MaintainTypeList = v_uint8() self._pad0020 = v_bytes(size=1) self.PoolType = v_uint32() self.DefaultPagedPoolCharge = v_uint32() self.DefaultNonPagedPoolCharge = v_uint32() self.DumpProcedure = v_ptr32() self.OpenProcedure = v_ptr32() self.CloseProcedure = v_ptr32() self.DeleteProcedure = v_ptr32() self.ParseProcedure = v_ptr32() self.SecurityProcedure = v_ptr32() self.QueryNameProcedure = v_ptr32() self.OkayToCloseProcedure = v_ptr32() class SCSI_REQUEST_BLOCK(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) class IO_STACK_LOCATION::__unnamed::__unnamed::__unnamed::__unnamed(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.ReplaceIfExists = v_uint8() self.AdvanceOnly = v_uint8() class FILE_BASIC_INFORMATION(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.CreationTime = LARGE_INTEGER() self.LastAccessTime = LARGE_INTEGER() self.LastWriteTime = LARGE_INTEGER() self.ChangeTime = LARGE_INTEGER() self.FileAttributes = v_uint32() self._pad0028 = v_bytes(size=4) class DEVICE_OBJECT(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Type = v_uint16() self.Size = v_uint16() self.ReferenceCount = v_uint32() self.DriverObject = v_ptr32() self.NextDevice = v_ptr32() self.AttachedDevice = v_ptr32() self.CurrentIrp = v_ptr32() self.Timer = v_ptr32() self.Flags = v_uint32() self.Characteristics = v_uint32() self.Vpb = v_ptr32() self.DeviceExtension = v_ptr32() self.DeviceType = v_uint32() self.StackSize = v_uint8() self._pad0034 = v_bytes(size=3) self.Queue = DEVICE_OBJECT::__unnamed() self.AlignmentRequirement = v_uint32() self.DeviceQueue = KDEVICE_QUEUE() self.Dpc = KDPC() self.ActiveThreadCount = v_uint32() self.SecurityDescriptor = v_ptr32() self.DeviceLock = KEVENT() self.SectorSize = v_uint16() self.Spare1 = v_uint16() self.DeviceObjectExtension = v_ptr32() self.Reserved = v_ptr32() class LIST_ENTRY(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Flink = v_ptr32() self.Blink = v_ptr32() class EINFO(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.pobj = v_ptr32() class SECURITY_QUALITY_OF_SERVICE(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Length = v_uint32() self.ImpersonationLevel = v_uint32() self.ContextTrackingMode = v_uint8() self.EffectiveOnly = v_uint8() self._pad000c = v_bytes(size=2) class COMPRESSED_DATA_INFO(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.CompressionFormatAndEngine = v_uint16() self.CompressionUnitShift = v_uint8() self.ChunkShift = v_uint8() self.ClusterShift = v_uint8() self.Reserved = v_uint8() self.NumberOfChunks = v_uint16() self.CompressedChunkSizes = vstruct.VArray([ v_uint32() for i in xrange(1) ]) class BASEOBJECT(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.hHmgr = v_ptr32() self.ulShareCount = v_uint32() self.cExclusiveLock = v_uint16() self.BaseFlags = v_uint16() self.Tid = v_ptr32() class HSEMAPHORE(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.unused = v_uint32() class LUID(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.LowPart = v_uint32() self.HighPart = v_uint32() class LARGE_INTEGER(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.LowPart = v_uint32() self.HighPart = v_uint32() class tagPOOLRECORD(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.ExtraData = v_ptr32() self.size = v_uint32() self.trace = vstruct.VArray([ v_ptr32() for i in xrange(6) ]) class GUID(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Data1 = v_uint32() self.Data2 = v_uint16() self.Data3 = v_uint16() self.Data4 = vstruct.VArray([ v_uint8() for i in xrange(8) ]) class OBJECT_DUMP_CONTROL(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Stream = v_ptr32() self.Detail = v_uint32() class NPAGED_LOOKASIDE_LIST(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.L = GENERAL_LOOKASIDE() self.Lock__ObsoleteButDoNotDelete = v_uint32() self._pad0050 = v_bytes(size=4) class ULARGE_INTEGER::__unnamed(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.LowPart = v_uint32() self.HighPart = v_uint32() class OBJECTOWNER(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Share = OBJECTOWNER_S() class tagWin32PoolHead(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.size = v_uint32() self.pPrev = v_ptr32() self.pNext = v_ptr32() self.pTrace = v_ptr32() class TL(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.next = v_ptr32() self.pobj = v_ptr32() self.pfnFree = v_ptr32() class IO_STACK_LOCATION::__unnamed::__unnamed(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Argument1 = v_ptr32() self.Argument2 = v_ptr32() self.Argument3 = v_ptr32() self.Argument4 = v_ptr32() class CM_PARTIAL_RESOURCE_DESCRIPTOR::__unnamed::__unnamed(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.DataSize = v_uint32() self.Reserved1 = v_uint32() self.Reserved2 = v_uint32() class ERESOURCE::__unnamed(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Address = v_ptr32() class IO_STACK_LOCATION(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.MajorFunction = v_uint8() self.MinorFunction = v_uint8() self.Flags = v_uint8() self.Control = v_uint8() self.Parameters = IO_STACK_LOCATION::__unnamed() self.DeviceObject = v_ptr32() self.FileObject = v_ptr32() self.CompletionRoutine = v_ptr32() self.Context = v_ptr32() class IO_RESOURCE_DESCRIPTOR::__unnamed::__unnamed(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Priority = v_uint32() self.Reserved1 = v_uint32() self.Reserved2 = v_uint32() class STRING(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Length = v_uint16() self.MaximumLength = v_uint16() self.Buffer = v_ptr32() class GENERIC_MAPPING(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.GenericRead = v_uint32() self.GenericWrite = v_uint32() self.GenericExecute = v_uint32() self.GenericAll = v_uint32() class IRP(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Type = v_uint16() self.Size = v_uint16() self.MdlAddress = v_ptr32() self.Flags = v_uint32() self.AssociatedIrp = IRP::__unnamed() self.ThreadListEntry = LIST_ENTRY() self.IoStatus = IO_STATUS_BLOCK() self.RequestorMode = v_uint8() self.PendingReturned = v_uint8() self.StackCount = v_uint8() self.CurrentLocation = v_uint8() self.Cancel = v_uint8() self.CancelIrql = v_uint8() self.ApcEnvironment = v_uint8() self.AllocationFlags = v_uint8() self.UserIosb = v_ptr32() self.UserEvent = v_ptr32() self.Overlay = IRP::__unnamed() self.CancelRoutine = v_ptr32() self.UserBuffer = v_ptr32() self.Tail = IRP::__unnamed() class OBJECT_NAME_INFORMATION(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Name = UNICODE_STRING() class IO_RESOURCE_LIST(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Version = v_uint16() self.Revision = v_uint16() self.Count = v_uint32() self.Descriptors = vstruct.VArray([ IO_RESOURCE_DESCRIPTOR() for i in xrange(1) ]) class DRIVER_OBJECT(vstruct.VStruct): def __init__(self): vstruct.VStruct.__init__(self) self.Type = v_uint16() self.Size = v_uint16() self.DeviceObject =
<reponame>leddartech/pioneer.common<gh_stars>1-10 from pioneer.common import plane, linalg from pioneer.common.logging_manager import LoggingManager from numpy.matlib import repmat import math import numpy as np import os import transforms3d def grid(v, h, v_from, v_to, h_from, h_to, dtype = np.float32): ''' Computes a matrix of all possible pairs of angles in the 2d field of view. \param v vertical resolution \param h horizontal resolution \param v_fov vertical field of view (degrees) \param h_fov horizontal field of view (degrees) \param dtype the numpy data type ''' # If you are wondering why there is a complex number here. Read the # numpy mgrid documentation. The lines below are equivalent to: # a = np.linspace(v_from, v_to, v) # b = np.linspace(h_from, h_to, h) # b, a = np.meshgrid(b, a) a, b = np.mgrid[ v_from:v_to:complex(0,v) , h_from:h_to:complex(0,h)] return np.c_[a.ravel(), b.ravel()].astype(dtype) def from_specs_dict(specs): return (specs[k] for k in ['v', 'h', 'v_fov', 'h_fov']) def angles(v, h = None, v_fov = None, h_fov = None, dtype = np.float32): ''' Computes a matrix of all possible pairs of angles in the 2d field of view. The generated grid follows the LCA axis system convention. That is the bottom-left corner (0, 0) corresponds to (-v_fov/2, -h_fov/2) and the top right corner (v-1, h-1) is (+v_fov/2, +h_fov/2). The grid is generated in a row-major order. \param v vertical resolution (or a dict with keys v', 'h', 'v_fov', 'h_fov') \param h horizontal resolution \param v_fov vertical field of view (degrees) \param h_fov horizontal field of view (degrees) \param dtype the numpy data type ''' if isinstance(v, dict): v, h, v_fov, h_fov = from_specs_dict(v) v_fov_rad = math.radians(v_fov) h_fov_rad = math.radians(h_fov) v_offset = v_fov_rad/v/2 h_offset = h_fov_rad/h/2 return grid(v,h, -v_fov_rad/2 + v_offset, v_fov_rad/2 - v_offset , -h_fov_rad/2 + h_offset, h_fov_rad/2 - h_offset, dtype) def raycast_angles(v, h = None, v_fov = None, h_fov = None, density = 10, dtype = np.float32): ''' Computes a densified matrix of all possible pairs of angles in the 2d field of view. This matrix can be used to cast density * density rays per fov solid angle ('pixel') \return the angle grid, and a mapping matrix m, where, m[dense_ray_i] == channel_i ''' if isinstance(v, dict): v, h, v_fov, h_fov = from_specs_dict(v) v_fov_rad = math.radians(v_fov) h_fov_rad = math.radians(h_fov) dense_to_sparse = np.empty(v*h*density*density, 'u4') sparse_to_dense = np.empty((v*h, density, density), 'u4') dense_to_sub = np.empty((v*h*density*density, 2), 'u4') m_i = 0 for v_i in range(v): for vd_i in range(density): for h_i in range(h): for hd_i in range(density): sparse_i = v_i * h + h_i dense_to_sparse[m_i] = sparse_i sparse_to_dense[sparse_i, vd_i, hd_i] = m_i dense_to_sub[m_i] = [vd_i, hd_i] m_i += 1 return grid(v * density,h * density, -v_fov_rad/2, v_fov_rad/2 , -h_fov_rad/2, h_fov_rad/2, dtype), dense_to_sparse, sparse_to_dense, dense_to_sub def custom_v_angles(v, h = None, v_fov = None, h_fov = None, factor = 1, filename = os.path.join(os.path.dirname(__file__), 'eagle_angles_80.txt'), dtype = np.float32): ''' similar to \a angles() but using a file to define scan direction angles ''' if isinstance(v, dict): v, h, v_fov, h_fov = from_specs_dict(v) h_fov_rad = math.radians(h_fov) h_offset = h_fov_rad/h/2 a = np.genfromtxt(filename, delimiter='\n', converters={_:lambda s: int(s, 16) for _ in range(1)}) a = a[:v] a = a/2**16 * v_fov - v_fov/2 a = np.deg2rad(a) * factor b = np.linspace(-h_fov_rad/2 + h_offset, h_fov_rad/2 - h_offset, num = h, dtype = dtype) b, a = np.meshgrid(b, a) return np.c_[a.ravel(), b.ravel()].astype(dtype) def custom_v_quad_directions(v, h = None, v_fov = None, h_fov = None, factor = 1, filename = os.path.join(os.path.dirname(__file__), 'eagle_angles_80.txt'), dtype = np.float32): ''' similar to \a quad_directions() but using a file to define scan direction angles ''' if isinstance(v, dict): v, h, v_fov, h_fov = from_specs_dict(v) v_fov_rad = math.radians(v_fov) h_fov_rad = math.radians(h_fov) v_cell_size = v_fov_rad/v h_cell_size = h_fov_rad/h file_angles = np.genfromtxt(filename, delimiter='\n', converters={_:lambda s: int(s, 16) for _ in range(1)}) def custom_grid(v, h, v_offset, h_offset_from, h_offset_to, dtype): a = file_angles[:v] a = a/2**16 * v_fov - v_fov/2 a = (np.radians(a) - v_offset) * factor b = np.linspace(-h_fov_rad/2+h_offset_from, h_fov_rad/2+h_offset_to, num = h, dtype = dtype) b, a = np.meshgrid(b, a) return np.c_[a.ravel(), b.ravel()].astype(dtype) return np.vstack(( directions(custom_grid(v,h,-v_cell_size/2 ,h_cell_size , 0 , dtype)) ,directions(custom_grid(v,h,+v_cell_size/2 ,h_cell_size , 0 , dtype)) ,directions(custom_grid(v,h,+v_cell_size/2 ,0 , -h_cell_size, dtype)) ,directions(custom_grid(v,h,-v_cell_size/2 ,0 , -h_cell_size, dtype))) ) def direction(theta_x, theta_y): ''' Convert angles of a spherical axis sytem into a cartesian direction vector. The cartesian axis system is the camera axis system. z +-------> x | | y v The z axis enters your screen (or paper if you are the kind of person that still prints code). Angles go from -fov/2 to fov/2 in both horizontal and vertical direction, always computed using "right hand" convention. In each direction, maximum z component will be attained at angle 0. In the x-z plane (viewed from above): pi/2 x ^ | |<--. |th_y\ ------------(.)-------------> z y | | -pi/2 x = sin(theta_y) z = cos(theta_y) //we want x,z = (0,1) at theta_y = 0 In the y-z plane (view from side): z ^ | |<--. |th_x \ y pi ------------(.)-------------> x y = cos(theta_x + pi/2) z = sin(theta_x + pi/2) //we want (y,z) = (0,1) at theta_x = 0 So the x, y, z coordinates should follow the equations below x = sin(theta_y) y = cos(theta_x + pi/2) z = cos(theta_y) * sin(theta_x + pi/2) ''' x = np.sin(theta_y) y = np.cos(theta_x + np.pi/2) z = np.sin(theta_x + np.pi/2) * np.cos(theta_y) return x, y, z def direction_spherical(thetas_x, thetas_y): ''' LeddarConfig implementation ''' x = np.cos(thetas_x) * np.sin(thetas_y) y = np.sin(thetas_x) z = np.cos(thetas_x) * np.cos(thetas_y) return x, y, z def direction_orthogonal(thetas_x, thetas_y): ''' Simulator implementation using orthogonal camera depth projection ''' x = np.tan(thetas_y) y = np.tan(-thetas_x) z = np.ones_like(x) n = np.sqrt(z**2 + x**2 + y**2) return x/n, y/n, z/n def directions(angles, direction_f = direction): '''Generate a set of cartesian direction vectors from a grid of spherical coordinates angles. This function uses the same convention as the `direction` function. ''' thetas_x, thetas_y = angles.T return np.stack(direction_f(thetas_x, thetas_y), axis=1) def directions_orthogonal(v,h=None,v_fov=None,h_fov=None, dtype = np.float32): '''Generate a set of cartesian direction vectors from a grid of 2D pixels coordinates (eg : camera depth) using Carla Simulator implementation and camera depth projection ''' if isinstance(v, dict): v, h, v_fov, h_fov = from_specs_dict(v) if h_fov > 90: LoggingManager.instance().warning("The projection model is not adapted for horizontal fov greater than 90 degrees. Trying to correct the" \ +" situation by spliting the fov in three parts and re-merging them. Use 'projection: direction_carla_pixell' instead.") return directions_orthogonal_pixell(v=v, h=h, v_fov=v_fov, h_fov=h_fov, dtype=dtype) # (Intrinsic) K Matrix k = np.identity(3) k[0, 2] = h / 2.0 k[1, 2] = v / 2.0 k[0, 0] = k[1, 1] = h / \ (2.0 * math.tan(h_fov * math.pi / 360.0)) # 2d pixel coordinates pixel_length = h * v u_coord = repmat(np.r_[h-1:-1:-1], v, 1).reshape(pixel_length) v_coord = repmat(np.c_[v-1:-1:-1], 1, h).reshape(pixel_length) # pd2 = [u,v,1] p2d = np.array([u_coord, v_coord, np.ones_like(u_coord)]) direction = np.dot(np.linalg.inv(k), p2d).T direction[:,0] = -direction[:,0] v_cell_size, h_cell_size = v_h_cell_size_rad(v, h, v_fov, h_fov) # First face face_a = np.zeros((direction.shape)) face_a[:,0] = direction[:,0] - h_cell_size/2 face_a[:,1] = direction[:,1] - v_cell_size/2 face_a[:,2] = direction[:,2] # Second face face_b = np.zeros((direction.shape)) face_b[:,0] = direction[:,0] + h_cell_size/2 face_b[:,1] = direction[:,1] - v_cell_size/2 face_b[:,2] = direction[:,2] # Third face face_c = np.zeros((direction.shape)) face_c[:,0] = direction[:,0] + h_cell_size/2 face_c[:,1] = direction[:,1] + v_cell_size/2 face_c[:,2] = direction[:,2] # Fourth face face_d = np.zeros((direction.shape)) face_d[:,0] = direction[:,0] - h_cell_size/2 face_d[:,1] = direction[:,1] + v_cell_size/2 face_d[:,2] = direction[:,2] quad_direction = np.vstack((face_a,face_b,face_c,face_d)) return direction,quad_direction def directions_orthogonal_pixell(v, h=None, v_fov=None, h_fov=None, dtype = np.float32): """Returns directions and quad_directions for the carla simulator projection, in the case of a h_fov greater than 90 deg.""" if isinstance(v, dict): v, h, v_fov, h_fov = from_specs_dict(v) directions_central_third, quad_directions_central_third = directions_orthogonal(v=v, h=int(h/3), v_fov=v_fov, h_fov=h_fov/3) rot_left = transforms3d.euler.euler2mat(0,np.deg2rad(h_fov/3),0) rot_right = transforms3d.euler.euler2mat(0,np.deg2rad(-h_fov/3),0) directions_left_third = directions_central_third @ rot_left directions_right_third = directions_central_third @ rot_right quad_directions_left_third = quad_directions_central_third @ rot_left quad_directions_right_third = quad_directions_central_third @ rot_right ind_tpm = np.arange(v*int(h/3)).reshape((v,int(h/3))) ind = np.ravel(np.hstack([ind_tpm,ind_tpm+v*int(h/3),ind_tpm+2*v*int(h/3)])) quad_ind_tpm = np.arange(4*v*int(h/3)).reshape((4*v,int(h/3))) quad_ind = np.ravel(np.hstack([quad_ind_tpm,quad_ind_tpm+4*v*int(h/3),quad_ind_tpm+2*4*v*int(h/3)]))
<reponame>usnistgov/OOF3D # -*- python -*- # This software was produced by NIST, an agency of the U.S. government, # and by statute is not subject to copyright in the United States. # Recipients of this software assume all responsibilities associated # with its operation, modification and maintenance. However, to # facilitate maintenance we ask that before distributing modified # versions of this software, you first contact the authors at # <EMAIL>. from ooflib.SWIG.common import config from ooflib.SWIG.common import crandom from ooflib.SWIG.common import ooferror from ooflib.SWIG.common import pixelgroup from ooflib.SWIG.common import switchboard from ooflib.SWIG.engine import skeletonselectioncourier from ooflib.common import debug from ooflib.common import enum from ooflib.common import primitives from ooflib.common import registeredclass from ooflib.common import selectionoperators from ooflib.common import utils from ooflib.common.IO import parameter from ooflib.common.IO import pixelgroupparam from ooflib.common.IO import whoville from ooflib.common.IO import xmlmenudump from ooflib.engine import materialmanager from ooflib.engine.IO import materialparameter from ooflib.engine.IO import pbcparams from ooflib.engine.IO import skeletongroupparams import types #Interface branch from ooflib.engine.IO import interfaceparameters import ooflib.engine.coverage from ooflib.engine.skeletonselection import \ NodeSelectionModifier, SegmentSelectionModifier, \ FaceSelectionModifier, ElementSelectionModifier, \ NodeSelectionModRegistration, SegmentSelectionModRegistration, \ FaceSelectionModRegistration, ElementSelectionModRegistration ## TODO : Use couriers as in pixel selection. ## TODO 3.1: Add more face selection methods. Select by aspect ratio? ## Area? ## TODO 3.1: Add Region selection methods, in the style of BoxSelection ## for voxels. # TODO 3.1: Can the Segment/Element/Node/Face operations here all be # derived from common SkeletonSelectable classes? #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# # Ordering: The order in which the skeleton selection modifiers appear # in the menus should be as similar as possible for the different # selection modes. The order is determined by the "ordering" arg in # the registrations. ## TODO: These aren't used consistently below. Make sure that all ## orderings use them. _selectGroupOrdering = 0.0 # The "Select from Selected Object" methods have ordering=1.x, where # x is the dimension of the Object. _selectFromNodesOrdering = 1.0 _selectFromSegmentsOrdering = 1.1 _selectFromFacesOrdering = 1.2 _selectFromElementsOrdering = 1.3 # Other selection methods have ordering >= 2.0 _materialOrdering = 2.0 _pixelGroupOrdering = 2.1 _homogeneityOrdering = 3.3 _shapeEnergyOrdering = 3.4 _illegalOrdering = 3.45 _suspectOrdering = 3.46 _internalBoundaryOrdering = 3.5 _namedBoundaryOrdering = 3.6 _interfaceOrdering = 3.7 _expandOrdering = 4.0 _shrinkOrdering = 4.1 _invertOrdering = 5.0 _randomOrdering = 6.0 _periodicPartnerOrdering = 8 #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# # Node selection modifiers #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# class NodeFromSelectedSegments(NodeSelectionModifier): def __init__(self, operator): self.operator = operator def select(self, skelctxt, selection): clist, plist = selection.trackerlist() courier = skeletonselectioncourier.NodesFromSegmentsCourier( skelctxt.getObject(), skelctxt.segmentselection.currentSelectionTracker(), clist, plist) self.operator.operate(selection, courier) NodeSelectionModRegistration( 'From Selected Segments', NodeFromSelectedSegments, ordering=_selectFromSegmentsOrdering, params = [ selectionoperators.SelectionOperatorParam('operator') ], tip="Select nodes from selected segments.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/nodes_from_segments.xml')) #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# class NodeFromSelectedElements(NodeSelectionModifier): def __init__(self, coverage, operator): self.coverage = coverage self.operator = operator def select(self, skelctxt, selection): clist, plist = selection.trackerlist() courier = skeletonselectioncourier.NodesFromElementsCourier( skelctxt.getObject(), self.coverage, skelctxt.elementselection.currentSelectionTracker(), clist, plist) self.operator.operate(selection, courier) NodeSelectionModRegistration( 'From Selected Elements', NodeFromSelectedElements, ordering=_selectFromElementsOrdering, params = [ enum.EnumParameter('coverage', ooflib.engine.coverage.Coverage), selectionoperators.SelectionOperatorParam('operator') ], tip="Select nodes from selected elements.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/nodes_from_elements.xml')) #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# class NodeFromSelectedFaces(NodeSelectionModifier): def __init__(self, coverage, operator): self.coverage = coverage self.operator = operator def select(self, skelctxt, selection): clist, plist = selection.trackerlist() courier = skeletonselectioncourier.NodesFromFacesCourier( skelctxt.getObject(), self.coverage, skelctxt.faceselection.currentSelectionTracker(), clist, plist) self.operator.operate(selection, courier) NodeSelectionModRegistration( 'From Selected Faces', NodeFromSelectedFaces, ordering=_selectFromFacesOrdering, params = [ enum.EnumParameter('coverage', ooflib.engine.coverage.Coverage), selectionoperators.SelectionOperatorParam('operator') ], tip="Select nodes from selected faces.") #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# class SelectInternalBoundaryNodes(NodeSelectionModifier): def __init__(self, operator, ignorePBC=False): self.operator = operator self.ignorePBC = ignorePBC def select(self, skelctxt, selection): clist, plist = selection.trackerlist() courier = skeletonselectioncourier.InternalBoundaryNodesCourier( skelctxt.getObject(), clist, plist) self.operator.operate(selection, courier) if config.dimension() == 2: params=[ selectionoperators.SelectionOperatorParam('operator'), pbcparams.PBCBooleanParameter('ignorePBC', False, tip='Ignore periodicity?')] else: params = [selectionoperators.SelectionOperatorParam('operator')] NodeSelectionModRegistration( 'Internal Boundaries', SelectInternalBoundaryNodes, ordering=_internalBoundaryOrdering, params=params, tip="Select all nodes on material or group boundaries.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/boundary_nodes.xml')) #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# class SelectNamedBoundaryNodes(NodeSelectionModifier): def __init__(self, boundary, operator): self.boundary = boundary self.operator = operator def select(self, skelctxt, selection): clist, plist = selection.trackerlist() bdy = skelctxt.getBoundary(self.boundary) courier = skeletonselectioncourier.PointBoundaryCourier( skelctxt.getObject(), bdy.getBoundarySet(skelctxt.getObject()), clist, plist) self.operator.operate(selection, courier) NodeSelectionModRegistration( 'Named Boundary', SelectNamedBoundaryNodes, ordering=_namedBoundaryOrdering, params=[ skeletongroupparams.SkeletonPointBoundaryParameter( 'boundary', tip="Select nodes in this boundary"), selectionoperators.SelectionOperatorParam('operator') ], tip="Select nodes belonging to the given skeleton point boundary.", discussion="""<para> Select all the &nodes; contained in the given &skel; <link linkend="Section-Concepts-Skeleton-Boundary">boundary</link>. The boundary must be a <link linkend="Section-Concepts-Skeleton-Boundary-Point">point</link> boundary. </para>""" ) #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# ## This 2D method has not been updated to use selection couriers! class SelectPeriodicPartnerNodes(NodeSelectionModifier): def select(self, skeleton, selection): oldnodes = skeleton.nodeselection.retrieve() newnodes = set() for node in oldnodes: for p in node.getPartners(): newnodes.add(p) selection.start() selection.select(newnodes) registeredclass.TwoDOnlyRegistration( 'Periodic Partners', SelectPeriodicPartnerNodes, ordering=_periodicPartnerOrdering, tip="Select nodes whose periodic partners are already selected.", discussion="""<para> If the &skel; is <link linkend="Section-Concepts-Skeleton-Periodicity">periodic</link>, every &node; on a periodic boundary has a partner on the opposite boundary. This command selects the periodic partners of the currently selected &nodes;, without unselecting any &nodes;. </para>""" ) #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# ## Since we only have tetrahedral elements in 3D, there's no ## difference between expanding by shared elements, segments, or ## faces. TODO 3.1: If we ever add non-tetrahedral elements, this ## should be rewritten to look like ExpandElementSelection. class ExpandNodeSelection(NodeSelectionModifier): def select(self, skelctxt, selection): clist, plist = selection.trackerlist() courier = skeletonselectioncourier.ExpandNodeSelectionCourier( skelctxt.getObject(), skelctxt.nodeselection.currentSelectionTracker(), clist, plist); selection.select(courier) NodeSelectionModRegistration( 'Expand', ExpandNodeSelection, ordering=_expandOrdering, tip="Select the neighbors of selected Nodes.") #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# # Select the indicated group. class NodeSelectGroup(NodeSelectionModifier): def __init__(self, group, operator): self.group = group self.operator = operator def select(self, skelctxt, selection): clist, plist = selection.trackerlist() courier = skeletonselectioncourier.SkeletonGroupCourier( skelctxt.getObject(), self.group, skelctxt.nodegroups.getTracker(skelctxt.getObject()), clist, plist) self.operator.operate(selection, courier) NodeSelectionModRegistration( 'Group', NodeSelectGroup, ordering=_selectGroupOrdering, params=[ skeletongroupparams.NodeGroupParameter('group', tip="Node group to select."), selectionoperators.SelectionOperatorParam('operator') ], tip='Select the members of a group.', discussion="""<para> Select all the &nodes; in the given <link linkend='Section-Concepts-Skeleton-Groups'>group</link>.. </para>""") #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# # Segment Selection Modifiers #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# class SegFromSelectedElements(SegmentSelectionModifier): def __init__(self, coverage, operator): self.coverage = coverage self.operator = operator def select(self, skelctxt, selection): clist, plist = selection.trackerlist() courier = skeletonselectioncourier.SegmentsFromElementsCourier( skelctxt.getObject(), self.coverage, skelctxt.elementselection.currentSelectionTracker(), clist, plist) self.operator.operate(selection, courier) SegmentSelectionModRegistration( 'From Selected Elements', SegFromSelectedElements, ordering=_selectFromElementsOrdering, params = [ enum.EnumParameter("coverage", ooflib.engine.coverage.Coverage), selectionoperators.SelectionOperatorParam('operator') ], tip="Select segments from selected elements.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/segments_from_elements.xml')) #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# class SegFromSelectedNodes(SegmentSelectionModifier): def __init__(self, one, two, operator): self.one = one self.two = two self.operator = operator def select(self, skelctxt, selection): clist, plist = selection.trackerlist() courier = skeletonselectioncourier.SegmentsFromNodesCourier( skelctxt.getObject(), self.one, self.two, skelctxt.nodeselection.currentSelectionTracker(), clist, plist) self.operator.operate(selection, courier) SegmentSelectionModRegistration( "From Selected Nodes", SegFromSelectedNodes, params=[ parameter.BooleanParameter( 'one', value=True, tip='Select segments with one selected node.'), parameter.BooleanParameter( 'two', value=True, tip='Select segments with two selected nodes.'), selectionoperators.SelectionOperatorParam('operator') ], ordering=_selectFromNodesOrdering, tip="Select segments from the selected nodes.") #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# class SegFromSelectedFaces(SegmentSelectionModifier): def __init__(self, coverage, operator): self.coverage = coverage self.operator = operator def select(self, skelctxt, selection): clist, plist = selection.trackerlist() courier = skeletonselectioncourier.SegmentsFromFacesCourier( skelctxt.getObject(), self.coverage, skelctxt.faceselection.currentSelectionTracker(), clist, plist) self.operator.operate(selection, courier) SegmentSelectionModRegistration( 'From Selected Faces', SegFromSelectedFaces, ordering=_selectFromFacesOrdering, params=[ enum.EnumParameter('coverage', ooflib.engine.coverage.Coverage), selectionoperators.SelectionOperatorParam('operator') ], tip="Select the edges of the selected faces.") #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# class SelectInternalBoundarySegments(SegmentSelectionModifier): def __init__(self, operator): self.operator = operator def select(self, skelctxt, selection): clist, plist = selection.trackerlist() courier = skeletonselectioncourier.InternalBoundarySegmentsCourier( skelctxt.getObject(), clist, plist) self.operator.operate(selection, courier) SegmentSelectionModRegistration( 'Internal Boundaries', SelectInternalBoundarySegments, params=[selectionoperators.SelectionOperatorParam('operator')], ordering=_internalBoundaryOrdering, tip="Select segments on material or group boundaries.") #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# #Interface branch ## This 2D method has not been updated to use selection couriers! class SelectInterfaceSegments(SegmentSelectionModifier): def __init__(self, interface): self.interface = interface def select(self, skeleton, selection): skel = skeleton.getObject() interfacemsplugin=skel.getMicrostructure().getPlugIn("Interfaces") try: interfacedef=interfacemsplugin.namedinterfaces[self.interface] except KeyError: #Should not happen raise ooferror.ErrPyProgrammingError("Interface not found!") seglist = [] for segment in skel.segments.values(): yes,side1elem=interfacedef.isInterfaceSegment(segment,skel) if yes: seglist.append(segment) selection.start() selection.clear() selection.select(seglist) if config.dimension() == 2: SegmentSelectionModRegistration( 'Interface Segments', SegmentSelectionModifier, SelectInterfaceSegments, ordering=_interfaceOrdering, params=[ interfaceparameters.InterfacesParameter( 'interface', tip='Select segments in this interface.')], tip="Select segments from an interface definition.", discussion="""<para> Select all the &sgmts; that belong to the given interface definition. </para>""" ) #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# class SelectNamedBoundarySegments(SegmentSelectionModifier): def __init__(self, boundary, operator): self.boundary = boundary self.operator = operator def select(self, skelctxt, selection): clist, plist = selection.trackerlist() bdy = skelctxt.getBoundary(self.boundary) # A SkelContextEdgeBoundary courier = skeletonselectioncourier.EdgeBoundaryCourier( skelctxt.getObject(), bdy.getBoundarySet(skelctxt.getObject()), clist, plist) self.operator.operate(selection, courier) SegmentSelectionModRegistration( 'Named Boundary', SelectNamedBoundarySegments, ordering=_namedBoundaryOrdering, params=[ skeletongroupparams.SkeletonEdgeBoundaryParameter( 'boundary', tip="Select segments in this boundary"), selectionoperators.SelectionOperatorParam('operator') ], tip="Select segments belonging to the given skeleton edge boundary.", discussion="""<para> Select all the &sgmts; contained in the given &skel; <link linkend="Section-Concepts-Skeleton-Boundary">boundary</link>. The boundary must be a <link linkend="Section-Concepts-Skeleton-Boundary-Edge">edge</link> boundary. </para>""" ) #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# ## This 2D method has not been updated to use selection couriers! class SelectPeriodicPartnerSegments(SegmentSelectionModifier): def select(self, skeleton, selection): oldsegs = skeleton.segmentselection.retrieve() newsegs = set() skel = skeleton.getObject() for seg in oldsegs: partner = seg.getPartner(skel) if partner: newsegs.add(partner) selection.start() selection.select(newsegs) registeredclass.TwoDOnlyRegistration( 'Periodic Partners', SegmentSelectionModifier, SelectPeriodicPartnerSegments, ordering=_periodicPartnerOrdering, tip="Select the periodic partners of the currently selected Segments.", discussion="""<para> If the &skel; is <link linkend="Section-Concepts-Skeleton-Periodicity">periodic</link>, every &sgmt; on a periodic boundary has a partner on the opposite boundary. This command selects the periodic partners of the currently selected &sgmts;, without unselecting any &sgmts;. </para>""" ) #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# class SegmentHomogeneity(SegmentSelectionModifier): def __init__(self, min_homogeneity, max_homogeneity, operator): self.min_homogeneity = min_homogeneity self.max_homogeneity = max_homogeneity self.operator = operator def select(self, skelctxt, selection): clist, plist = selection.trackerlist() courier = skeletonselectioncourier.SegmentHomogeneityCourier( skelctxt.getObject(), self.min_homogeneity, self.max_homogeneity, clist, plist) self.operator.operate(selection, courier) SegmentSelectionModRegistration( 'By Homogeneity', SegmentHomogeneity, ordering=_homogeneityOrdering, params = [ parameter.FloatRangeParameter( 'min_homogeneity', (0.0, 1.0, 0.01), value=0.0,
<gh_stars>1-10 #!/usr/bin/env python import argparse import itertools import math import numpy as np import random import torch import torch.nn as nn import torch.optim as optim import pickle as pk from discriminator import Discriminator from gan import batch_dataset, train, gen_noise from generator import Generator from utils import load_dataset from logger_utils import Logger from matplotlib import pyplot as plt from torch.autograd import Variable from torchvision import transforms, datasets NUM_EVALUATORS = 10 # ============================================================================== # Distillation GAN # ============================================================================== def get_training_partitions(X): """ Generates column-partitioned training sets for various GANs # TODO: for an extension, we can sample a number of random datasets """ X = torch.tensor(X, dtype=torch.float32) other_idx = [i for i in range(0,7)] other_X = X[:,:,other_idx] atomic_idx = [i for i in range(7,71,4)] atomic_X = X[:,:,atomic_idx] locations_idx = [i for i in range(8,71) if i % 4 != 3] locations_X = X[:,:,locations_idx] return [(other_X, other_idx), (atomic_X, atomic_idx), (locations_X, locations_idx)] def init_population(X, num_batches): """ Initializes a population given the initial training partitions """ partitions = get_training_partitions(X) generation = 0 population = dict() for i, partition in enumerate(partitions): spec_args = args spec_args.g_input_size = args.latent spec_args.g_output_size = len(partition[1]) spec_args.g_hidden_size = int(math.ceil(spec_args.g_output_size / 2)) spec_args.d_input_size = len(partition[1]) spec_args.d_hidden_size = int(math.ceil(spec_args.d_input_size / 2)) G, D, _, evaluations = train( partition[0], num_batches, args.num_particle_samples, set_args=spec_args, train_cols=partition[1] ) MLE_emittance = torch.mean(evaluations) population['gen%dpartition%d' % (generation, i)] = { 'generator': G, 'discriminator': D, 'emittance': MLE_emittance, 'partition': partition } return population def mutate(population, num_batches, generation): """ Trains a GAN for each population element """ i = 0 new_population = dict() for label, map in population.items(): G, D, _, evaluations = train( map['partition'][0], num_batches, args.num_particle_samples, G=map['generator'], D=map['discriminator'], set_args=args, train_cols=map['partition'][1] ) MLE_emittance = torch.mean(evaluations) new_population['gen%dpartition%d' % (generation, i)] = { 'generator': G, 'discriminator': D, 'emittance': MLE_emittance, 'partition': map['partition'] } i += 1 return new_population def select_k_fittest(population, k): """ Select k fittest GANs TODO: debug this function """ if len(population) >= k: return sorted(population.values(), key=lambda v: v['emittance'])[:k] # results in a list of tuples return population def reshape_generator_output(pol1, pol2, pol3): """ Reshapes the output of generators that do not match the original output size """ G_1 = pol1['generator'] p_1 = pol1['partition'] G_2 = pol2['generator'] p_2 = pol2['partition'] G_3 = pol3['generator'] p_3 = pol3['partition'] test_noise_1 = gen_noise(args.crossover_samples, args.latent) test_noise_2 = gen_noise(args.crossover_samples, args.latent) test_noise_3 = gen_noise(args.crossover_samples, args.latent) fake_data_1 = G_1(test_noise_1).detach() # make sure when we create a gan we can set its output shape (critical!) fake_data_2 = G_2(test_noise_2).detach() fake_data_3 = G_3(test_noise_3).detach() # Format back into their appropriate columns d_1 = torch.zeros(args.crossover_samples, 71) d_2 = torch.zeros(args.crossover_samples, 71) d_3 = torch.zeros(args.crossover_samples, 71) d_1[:,p_1[1]] = fake_data_1 d_2[:,p_2[1]] = fake_data_2 d_3[:,p_3[1]] = fake_data_3 # Also format the datasets back into their appropriate columns jp_1 = torch.zeros(p_1[0].shape[0], p_1[0].shape[1], 71) jp_2 = torch.zeros(p_2[0].shape[0], p_2[0].shape[1], 71) jp_3 = torch.zeros(p_3[0].shape[0], p_3[0].shape[1], 71) jp_1[:,:,p_1[1]] = p_1[0] jp_2[:,:,p_2[1]] = p_2[0] jp_3[:,:,p_3[1]] = p_3[0] joint_partition = jp_1.add_(jp_2.add_(jp_3)) return joint_partition, d_1, d_2, d_3, p_1, p_2, p_3 def sample_top_paths(joint_partition, gen_partition, clf): """ Samples the top 50% of training samples from GPO and the previous dataset # Commented out code prints what the top particle representations are # for particle in ind: # print(dataset_particles[ind,:]) """ dataset_particles = joint_partition.view(-1, 71) dataset_particles = torch.cat((dataset_particles, gen_partition), dim=0) percentile_index = math.floor(dataset_particles.shape[0]/2) dataset_particles = dataset_particles.detach().numpy() prediction = torch.tensor(clf.predict(dataset_particles), dtype=torch.float32) res, ind = prediction.topk(percentile_index, largest=False) # There may be a bug later where this fails. That would be because i did batching jankily long ago, fix it top_partition = batch_dataset(dataset_particles[ind,:], args.batch_size) return torch.tensor(top_partition, dtype=torch.float32) def crossover(pol1, pol2, pol3): """ Genetic operator that crosses together two GANs trained separately Specifically for our case, we note our child GANS train on different parts of the dataset. Hence, we combine to create a new good dataset extension to match with a new student GAN. We choose the crossover to operate on 3 GANs for the initial combination of the dataset """ joint_partition, d_1, d_2, d_3, p_1, p_2, p_3 = reshape_generator_output(pol1, pol2, pol3) # Naive approach sequential greedy maximization # file = open('NN_evaluator_0.sav', 'rb') # clf = pk.load(file) gen_partition = torch.zeros(d_1.shape[0], 71, dtype=torch.float32) for col in range(71): grad_d_1 = gen_partition.clone() grad_d_2 = gen_partition.clone() grad_d_3 = gen_partition.clone() grad_d_1[:,col] = d_1[:,col] grad_d_2[:,col] = d_2[:,col] grad_d_3[:,col] = d_3[:,col] d_1_pred = torch.zeros(d_1.shape[0], NUM_EVALUATORS) d_2_pred = torch.zeros(d_1.shape[0], NUM_EVALUATORS) d_3_pred = torch.zeros(d_1.shape[0], NUM_EVALUATORS) for i in range(NUM_EVALUATORS): # Import the evaluator NN file = open('NN_evaluator_'+str(i)+'.sav', 'rb') clf = pk.load(file) # Using the evaluator NN, make a prediction on the generated particle d_1_pred[:,i] = torch.tensor(clf.predict((grad_d_1).detach().numpy()), dtype=torch.float32) d_2_pred[:,i] = torch.tensor(clf.predict((grad_d_2).detach().numpy()), dtype=torch.float32) d_3_pred[:,i] = torch.tensor(clf.predict((grad_d_3).detach().numpy()), dtype=torch.float32) e_1 = torch.mean(d_1_pred) e_2 = torch.mean(d_2_pred) e_3 = torch.mean(d_3_pred) if e_1 < e_2 and e_1 < e_3: gen_partition = grad_d_1 elif e_2 < e_1 and e_2 < e_3: gen_partition = grad_d_2 else: gen_partition = grad_d_3 # ======================================================================== # # For each generated feature col, choose the col that maximizes according to NN_eval (stochastic gradient descent or adam) # After this, we already have a sub-GAN which is SGD optimized GAN combination # This is what Michael was originally interested in investigating # The only problem is this is not a single GAN, so we cannot add it to a population and iterate # Print the results (i.e. mean emittance for the crossover) for sure! # ======================================================================== # top_partition = sample_top_paths(joint_partition, gen_partition, clf) # Now that we have a new dataset, train a new GAN on it for imitation learning GAN. spec_args = args spec_args.g_input_size = args.latent spec_args.g_output_size = top_partition.shape[2] spec_args.g_hidden_size = int(math.ceil(spec_args.g_output_size / 2)) spec_args.d_input_size = top_partition.shape[2] spec_args.d_hidden_size = int(math.ceil(spec_args.d_input_size / 2)) partition_idx = list(set(p_1[1] + p_2[1] + p_3[1])) return train( top_partition, num_batches, args.num_particle_samples, set_args=spec_args, train_cols=partition_idx ), (top_partition, partition_idx) def breed(parents, population): """ Runs crossover and 'dagger'_distillation on pairs of fit parents """ children = dict() triplets = list(itertools.combinations(parents.values(), 3)) while len(population) - len(triplets) > 0: triplets.append(random.choice(triplets)) if len(triplets) - len(population) > 0: triplets = random.sample(triplets, len(population)) w = 0 gen_best_score = None for p1, p2, p3 in triplets: (G, D, _, evaluations), partition = crossover(p1, p2, p3) MLE_emittance = torch.mean(evaluations) if not gen_best_score or MLE_emittance < gen_best_score: gen_best_score = MLE_emittance children['cross%d' % w] = { 'generator': G, 'discriminator': D, 'emittance': MLE_emittance, 'partition': partition } w += 1 print('The best emittance score for this generation is %2f' % gen_best_score) return children def train_GPO_GAN(X, Y, num_batches, k, r): """ Trains a student GAN network from a teacher GAN selected from population and r epochs Specifically for our project, we would like to experiment with generating our atomic numbers and connections separately, to do this, we distill a GAN trained on atomic numbers and a GAN trained on connections into a binary GAN policy and train a student using a framework similar to GPO (https://arxiv.org/pdf/1711.01012.pdf) We have modified this framework specifically to train GANs on various parts of the dataset separately. """ population = init_population(X, num_batches) epoch = 0 while epoch < r and len(population) > 1: if epoch > 0: population = mutate(population, num_batches, epoch) parents = select_k_fittest(population, k) population = breed(parents, population) epoch += 1 # Run a final training on the resultant child to ensure training on full dataset student = select_k_fittest(population, 1)[0] # probably bug, need to isolate a single particle rather than a dict # return student['generator'], student['discriminator'], None, student['emittance'] return train( X, num_batches, args.num_particle_samples, student['generator'], student['discriminator'], set_args=args, model_name='GPO-GAN' ) if __name__ == "__main__": parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--latent', type=int, default=8, help="Latent representation size") parser.add_argument('--g_input_size', type=int, default=8, help="Random noise dimension coming into generator, per output vector") parser.add_argument('--g_hidden_size', type=int, default=32, help="Generator complexity") parser.add_argument('--g_output_size', type=int, default=71, help="Size of generator output vector") parser.add_argument('--d_input_size', type=int, default=71, help="Minibatch size - cardinality of distributions (change)") parser.add_argument('--d_hidden_size', type=int, default=32, help="Discriminator complexity") parser.add_argument('--d_output_size', type=int, default=1, help="Single dimension for real vs fake classification") parser.add_argument('--p', type=float, default=0.2) parser.add_argument('--dropout', type=float, default=0.3) parser.add_argument('--d_learning_rate', type=float, default=1e-3) parser.add_argument('--g_learning_rate', type=float, default=1e-3) parser.add_argument('--sgd_momentum', type=float, default=0.9) parser.add_argument('--num_epochs', type=int, default=200) parser.add_argument('--print_interval', type=int, default=200) parser.add_argument('--optim', type=str, default='SGD') parser.add_argument('--batch_size', type=int, default=10) parser.add_argument('--k', type=int, default=5, help="Number of GANs to select teacher from") parser.add_argument('--num_particle_samples', type=int, default=100, help="Number of sample particles to aggregate fitness estimate over") parser.add_argument('--r_epochs', type=int, default=3, help="Number of epochs of GPO") parser.add_argument('--crossover_samples', type=int, default=1000, help="number of samples for crossover") parser.add_argument('--loss_fn', type=str, default='dflt') # Loss defaults
<reponame>eric11eca/inference-information-probing<filename>jiant/ext/allennlp.py from typing import Optional import torch import torch.nn as nn # noinspection PyTypeChecker # noinspection PyUnusedLocal class SelfAttentiveSpanExtractor(nn.Module): """ Computes span representations by generating an unnormalized attention score for each word in the document. Spans representations are computed with respect to these scores by normalising the attention scores for words inside the span. Given these attention distributions over every span, this module weights the corresponding vector representations of the words in the span by this distribution, returning a weighted representation of each span. Parameters ---------- input_dim : ``int``, required. The final dimension of the ``sequence_tensor``. Returns ------- attended_text_embeddings : ``torch.FloatTensor``. A tensor of shape (batch_size, num_spans, input_dim), which each span representation is formed by locally normalising a global attention over the sequence. The only way in which the attention distribution differs over different spans is in the set of words over which they are normalized. """ def __init__(self, input_dim: int) -> None: super().__init__() self._input_dim = input_dim self._global_attention = TimeDistributed(torch.nn.Linear(input_dim, 1)) def get_input_dim(self) -> int: return self._input_dim def get_output_dim(self) -> int: return self._input_dim def forward( self, sequence_tensor: torch.FloatTensor, span_indices: torch.LongTensor, sequence_mask: torch.LongTensor = None, span_indices_mask: torch.LongTensor = None, ) -> torch.FloatTensor: # both of shape (batch_size, num_spans, 1) span_starts, span_ends = span_indices.split(1, dim=-1) # shape (batch_size, num_spans, 1) # These span widths are off by 1, because the span ends are `inclusive`. span_widths = span_ends - span_starts # We need to know the maximum span width so we can # generate indices to extract the spans from the sequence tensor. # These indices will then get masked below, such that if the length # of a given span is smaller than the max, the rest of the values # are masked. max_batch_span_width = span_widths.max().item() + 1 # shape (batch_size, sequence_length, 1) global_attention_logits = self._global_attention(sequence_tensor) # Shape: (1, 1, max_batch_span_width) max_span_range_indices = get_range_vector( max_batch_span_width, get_device_of(sequence_tensor) ).view(1, 1, -1) # Shape: (batch_size, num_spans, max_batch_span_width) # This is a broadcasted comparison - for each span we are considering, # we are creating a range vector of size max_span_width, but masking values # which are greater than the actual length of the span. # # We're using <= here (and for the mask below) because the span ends are # inclusive, so we want to include indices which are equal to span_widths rather # than using it as a non-inclusive upper bound. span_mask = (max_span_range_indices <= span_widths).float() raw_span_indices = span_ends - max_span_range_indices # We also don't want to include span indices which are less than zero, # which happens because some spans near the beginning of the sequence # have an end index < max_batch_span_width, so we add this to the mask here. span_mask = span_mask * (raw_span_indices >= 0).float() span_indices = torch.nn.functional.relu( raw_span_indices.float()).long() # Shape: (batch_size * num_spans * max_batch_span_width) flat_span_indices = flatten_and_batch_shift_indices( span_indices, sequence_tensor.size(1)) # Shape: (batch_size, num_spans, max_batch_span_width, embedding_dim) span_embeddings = batched_index_select( sequence_tensor, span_indices, flat_span_indices) # Shape: (batch_size, num_spans, max_batch_span_width) span_attention_logits = batched_index_select( global_attention_logits, span_indices, flat_span_indices ).squeeze(-1) # Shape: (batch_size, num_spans, max_batch_span_width) span_attention_weights = masked_softmax( span_attention_logits, span_mask) # Do a weighted sum of the embedded spans with # respect to the normalised attention distributions. # Shape: (batch_size, num_spans, embedding_dim) attended_text_embeddings = weighted_sum( span_embeddings, span_attention_weights) if span_indices_mask is not None: # Above we were masking the widths of spans with respect to the max # span width in the batch. Here we are masking the spans which were # originally passed in as padding. return attended_text_embeddings * span_indices_mask.unsqueeze(-1).float() return attended_text_embeddings class TimeDistributed(torch.nn.Module): """ Given an input shaped like ``(batch_size, time_steps, [rest])`` and a ``Module`` that takes inputs like ``(batch_size, [rest])``, ``TimeDistributed`` reshapes the input to be ``(batch_size * time_steps, [rest])``, applies the contained ``Module``, then reshapes it back. Note that while the above gives shapes with ``batch_size`` first, this ``Module`` also works if ``batch_size`` is second - we always just combine the first two dimensions, then split them. """ def __init__(self, module): super(TimeDistributed, self).__init__() self._module = module def forward(self, *inputs): # pylint: disable=arguments-differ reshaped_inputs = [] for input_tensor in inputs: input_size = input_tensor.size() if len(input_size) <= 2: raise RuntimeError( "No dimension to distribute: " + str(input_size)) # Squash batch_size and time_steps into a single axis; result has shape # (batch_size * time_steps, input_size). squashed_shape = [-1] + [x for x in input_size[2:]] reshaped_inputs.append( input_tensor.contiguous().view(*squashed_shape)) reshaped_outputs = self._module(*reshaped_inputs) # Now get the output back into the right shape. # (batch_size, time_steps, [hidden_size]) # noinspection PyUnboundLocalVariable new_shape = [input_size[0], input_size[1]] + \ [x for x in reshaped_outputs.size()[1:]] outputs = reshaped_outputs.contiguous().view(*new_shape) return outputs def weighted_sum(matrix: torch.Tensor, attention: torch.Tensor) -> torch.Tensor: """ Takes a matrix of vectors and a set of weights over the rows in the matrix (which we call an "attention" vector), and returns a weighted sum of the rows in the matrix. This is the typical computation performed after an attention mechanism. Note that while we call this a "matrix" of vectors and an attention "vector", we also handle higher-order tensors. We always sum over the second-to-last dimension of the "matrix", and we assume that all dimensions in the "matrix" prior to the last dimension are matched in the "vector". Non-matched dimensions in the "vector" must be `directly after the batch dimension`. For example, say I have a "matrix" with dimensions ``(batch_size, num_queries, num_words, embedding_dim)``. The attention "vector" then must have at least those dimensions, and could have more. Both: - ``(batch_size, num_queries, num_words)`` (distribution over words for each query) - ``(batch_size, num_documents, num_queries, num_words)`` (distribution over words in a query for each document) are valid input "vectors", producing tensors of shape: ``(batch_size, num_queries, embedding_dim)`` and ``(batch_size, num_documents, num_queries, embedding_dim)`` respectively. """ # We'll special-case a few settings here, where there are efficient (but poorly-named) # operations in pytorch that already do the computation we need. if attention.dim() == 2 and matrix.dim() == 3: return attention.unsqueeze(1).bmm(matrix).squeeze(1) if attention.dim() == 3 and matrix.dim() == 3: return attention.bmm(matrix) if matrix.dim() - 1 < attention.dim(): expanded_size = list(matrix.size()) for i in range(attention.dim() - matrix.dim() + 1): matrix = matrix.unsqueeze(1) expanded_size.insert(i + 1, attention.size(i + 1)) matrix = matrix.expand(*expanded_size) intermediate = attention.unsqueeze(-1).expand_as(matrix) * matrix return intermediate.sum(dim=-2) def masked_softmax(vector: torch.Tensor, mask: torch.Tensor, dim: int = -1) -> torch.Tensor: """ ``torch.nn.functional.softmax(vector)`` does not work if some elements of ``vector`` should be masked. This performs a softmax on just the non-masked portions of ``vector``. Passing ``None`` in for the mask is also acceptable; you'll just get a regular softmax. ``vector`` can have an arbitrary number of dimensions; the only requirement is that ``mask`` is broadcastable to ``vector's`` shape. If ``mask`` has fewer dimensions than ``vector``, we will unsqueeze on dimension 1 until they match. If you need a different unsqueezing of your mask, do it yourself before passing the mask into this function. In the case that the input vector is completely masked, this function returns an array of ``0.0``. This behavior may cause ``NaN`` if this is used as the last layer of a model that uses categorical cross-entropy loss. """ if mask is None: result = torch.nn.functional.softmax(vector, dim=dim) else: mask = mask.float() while mask.dim() < vector.dim(): mask = mask.unsqueeze(1) # To limit numerical errors from large vector elements outside the mask, we zero these out. result = torch.nn.functional.softmax(vector * mask, dim=dim) result = result * mask result = result / (result.sum(dim=dim, keepdim=True) + 1e-13) return result def batched_index_select( target: torch.Tensor, indices: torch.LongTensor, flattened_indices: Optional[torch.LongTensor] = None, ) -> torch.Tensor: """ The given ``indices`` of size ``(batch_size, d_1, ..., d_n)`` indexes into the sequence dimension (dimension 2) of the target, which has size ``(batch_size, sequence_length, embedding_size)``. This function returns selected values in the target with respect to the provided indices, which have size ``(batch_size, d_1, ..., d_n, embedding_size)``. This can use the optionally precomputed :func:`~flattened_indices` with size ``(batch_size * d_1 * ... * d_n)`` if given. An example use case of this function is looking up the start and end
single word without wrapping it in quotes as an argument # ex: p.inflect("I plural(see)") instead of p.inflect("I plural('see')") raise NameError(f"name '{obj.id}' is not defined") def _string_to_substitute( self, mo: Match, methods_dict: Dict[str, Callable] ) -> str: """ Return the string to be substituted for the match. """ matched_text, f_name = mo.groups() # matched_text is the complete match string. e.g. plural_noun(cat) # f_name is the function name. e.g. plural_noun # Return matched_text if function name is not in methods_dict if f_name not in methods_dict: return matched_text # Parse the matched text a_tree = ast.parse(matched_text) # get the args and kwargs from ast objects args_list = [ self._get_value_from_ast(a) for a in a_tree.body[0].value.args # type: ignore[attr-defined] ] kwargs_list = { kw.arg: self._get_value_from_ast(kw.value) for kw in a_tree.body[0].value.keywords # type: ignore[attr-defined] } # Call the corresponding function return methods_dict[f_name](*args_list, **kwargs_list) # 0. PERFORM GENERAL INFLECTIONS IN A STRING def inflect(self, text: str) -> str: """ Perform inflections in a string. e.g. inflect('The plural of cat is plural(cat)') returns 'The plural of cat is cats' can use plural, plural_noun, plural_verb, plural_adj, singular_noun, a, an, no, ordinal, number_to_words, and prespart """ save_persistent_count = self.persistent_count # Dictionary of allowed methods methods_dict: Dict[str, Callable] = { "plural": self.plural, "plural_adj": self.plural_adj, "plural_noun": self.plural_noun, "plural_verb": self.plural_verb, "singular_noun": self.singular_noun, "a": self.a, "an": self.a, "no": self.no, "ordinal": self.ordinal, "number_to_words": self.number_to_words, "present_participle": self.present_participle, "num": self.num, } # Regular expression to find Python's function call syntax output = FUNCTION_CALL.sub( lambda mo: self._string_to_substitute(mo, methods_dict), text ) self.persistent_count = save_persistent_count return output # ## PLURAL SUBROUTINES def postprocess(self, orig: str, inflected) -> str: inflected = str(inflected) if "|" in inflected: word_options = inflected.split("|") # When two parts of a noun need to be pluralized if len(word_options[0].split(" ")) == len(word_options[1].split(" ")): result = inflected.split("|")[self.classical_dict["all"]].split(" ") # When only the last part of the noun needs to be pluralized else: result = inflected.split(" ") for index, word in enumerate(result): if "|" in word: result[index] = word.split("|")[self.classical_dict["all"]] else: result = inflected.split(" ") # Try to fix word wise capitalization for index, word in enumerate(orig.split(" ")): if word == "I": # Is this the only word for exceptions like this # Where the original is fully capitalized # without 'meaning' capitalization? # Also this fails to handle a capitalizaion in context continue if word.capitalize() == word: result[index] = result[index].capitalize() if word == word.upper(): result[index] = result[index].upper() return " ".join(result) def partition_word(self, text: str) -> Tuple[str, str, str]: mo = PARTITION_WORD.search(text) if mo: return mo.group(1), mo.group(2), mo.group(3) else: return "", "", "" def plural(self, text: str, count: Optional[Union[str, int]] = None) -> str: """ Return the plural of text. If count supplied, then return text if count is one of: 1, a, an, one, each, every, this, that otherwise return the plural. Whitespace at the start and end is preserved. """ pre, word, post = self.partition_word(text) if not word: return text plural = self.postprocess( word, self._pl_special_adjective(word, count) or self._pl_special_verb(word, count) or self._plnoun(word, count), ) return f"{pre}{plural}{post}" def plural_noun(self, text: str, count: Optional[Union[str, int]] = None) -> str: """ Return the plural of text, where text is a noun. If count supplied, then return text if count is one of: 1, a, an, one, each, every, this, that otherwise return the plural. Whitespace at the start and end is preserved. """ pre, word, post = self.partition_word(text) if not word: return text plural = self.postprocess(word, self._plnoun(word, count)) return f"{pre}{plural}{post}" def plural_verb(self, text: str, count: Optional[Union[str, int]] = None) -> str: """ Return the plural of text, where text is a verb. If count supplied, then return text if count is one of: 1, a, an, one, each, every, this, that otherwise return the plural. Whitespace at the start and end is preserved. """ pre, word, post = self.partition_word(text) if not word: return text plural = self.postprocess( word, self._pl_special_verb(word, count) or self._pl_general_verb(word, count), ) return f"{pre}{plural}{post}" def plural_adj(self, text: str, count: str = None) -> str: """ Return the plural of text, where text is an adjective. If count supplied, then return text if count is one of: 1, a, an, one, each, every, this, that otherwise return the plural. Whitespace at the start and end is preserved. """ pre, word, post = self.partition_word(text) if not word: return text plural = self.postprocess(word, self._pl_special_adjective(word, count) or word) return f"{pre}{plural}{post}" def compare(self, word1: str, word2: str) -> Union[str, bool]: """ compare word1 and word2 for equality regardless of plurality return values: eq - the strings are equal p:s - word1 is the plural of word2 s:p - word2 is the plural of word1 p:p - word1 and word2 are two different plural forms of the one word False - otherwise """ return ( self._plequal(word1, word2, self.plural_noun) or self._plequal(word1, word2, self.plural_verb) or self._plequal(word1, word2, self.plural_adj) ) def compare_nouns(self, word1: str, word2: str) -> Union[str, bool]: """ compare word1 and word2 for equality regardless of plurality word1 and word2 are to be treated as nouns return values: eq - the strings are equal p:s - word1 is the plural of word2 s:p - word2 is the plural of word1 p:p - word1 and word2 are two different plural forms of the one word False - otherwise """ return self._plequal(word1, word2, self.plural_noun) def compare_verbs(self, word1: str, word2: str) -> Union[str, bool]: """ compare word1 and word2 for equality regardless of plurality word1 and word2 are to be treated as verbs return values: eq - the strings are equal p:s - word1 is the plural of word2 s:p - word2 is the plural of word1 p:p - word1 and word2 are two different plural forms of the one word False - otherwise """ return self._plequal(word1, word2, self.plural_verb) def compare_adjs(self, word1: str, word2: str) -> Union[str, bool]: """ compare word1 and word2 for equality regardless of plurality word1 and word2 are to be treated as adjectives return values: eq - the strings are equal p:s - word1 is the plural of word2 s:p - word2 is the plural of word1 p:p - word1 and word2 are two different plural forms of the one word False - otherwise """ return self._plequal(word1, word2, self.plural_adj) def singular_noun( self, text: str, count: Optional[Union[int, str]] = None, gender: Optional[str] = None, ) -> Union[str, bool]: """ Return the singular of text, where text is a plural noun. If count supplied, then return the singular if count is one of: 1, a, an, one, each, every, this, that or if count is None otherwise return text unchanged. Whitespace at the start and end is preserved. >>> p = engine() >>> p.singular_noun('horses') 'horse' >>> p.singular_noun('knights') 'knight' Returns False when a singular noun is passed. >>> p.singular_noun('horse') False >>> p.singular_noun('knight') False >>> p.singular_noun('soldier') False """ pre, word, post = self.partition_word(text) if not word: return text sing = self._sinoun(word, count=count, gender=gender) if sing is not False: plural = self.postprocess(word, sing) return f"{pre}{plural}{post}" return False def _plequal(self, word1: str, word2: str, pl) -> Union[str, bool]: # noqa: C901 classval = self.classical_dict.copy() self.classical_dict = all_classical.copy() if word1 == word2: return "eq" if word1 == pl(word2): return "p:s" if pl(word1) == word2: return "s:p" self.classical_dict = no_classical.copy() if word1 == pl(word2): return "p:s" if pl(word1) == word2: return "s:p" self.classical_dict = classval.copy() if pl == self.plural or pl == self.plural_noun: if self._pl_check_plurals_N(word1, word2): return "p:p" if self._pl_check_plurals_N(word2, word1): return "p:p" if pl == self.plural or pl == self.plural_adj: if self._pl_check_plurals_adj(word1, word2): return "p:p" return False def _pl_reg_plurals(self, pair: str, stems: str, end1: str, end2: str) -> bool: pattern = fr"({stems})({end1}\|\1{end2}|{end2}\|\1{end1})" return bool(re.search(pattern, pair)) def _pl_check_plurals_N(self, word1: str, word2: str) -> bool: stem_endings = ( (pl_sb_C_a_ata, "as", "ata"), (pl_sb_C_is_ides, "is", "ides"), (pl_sb_C_a_ae, "s", "e"), (pl_sb_C_en_ina, "ens", "ina"), (pl_sb_C_um_a, "ums", "a"), (pl_sb_C_us_i, "uses", "i"), (pl_sb_C_on_a, "ons", "a"), (pl_sb_C_o_i_stems, "os", "i"), (pl_sb_C_ex_ices, "exes", "ices"), (pl_sb_C_ix_ices, "ixes", "ices"), (pl_sb_C_i, "s", "i"), (pl_sb_C_im, "s", "im"), (".*eau", "s", "x"), (".*ieu", "s",
<filename>codes/dataloader.py<gh_stars>1-10 #!/usr/bin/python3 from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np import torch from torch.utils.data import Dataset from utils import * TIME_TYPE = {'no-time':0, 'point-in-time':1, 'only-begin':2, 'only-end':3, 'full-interval':4} ''' (1) It is meaningless to sample time points for static statements or statements with missing temporal information; (2) For temporal statements, we sample time points that are not within the validity time period * for partial statements, we sample time from the previous part or the afterwards depending on the mention 'until ..., before'; we need to ensure that it is still valid for some boxes but invalid for the intersection of the boxes; * for full-interval statements, excluding them out of the sampled time points; * It is also unknown whether two kinds of negative samples are compementary or completing; * try to train these two negative samples separately; if it does not work, then probably try to do them separately. ''' class TrainDataset(Dataset): def __init__(self, triples, nentity, nrelation, negative_sample_size, train_ans, mode): # assert mode == 'tail-batch' self.len = len(triples) self.triples = triples self.nentity = nentity self.nrelation = nrelation self.negative_sample_size = negative_sample_size self.mode = mode # self.count = self.count_frequency(triples, train_ans, mode) self.true_missing = train_ans self.qtype = self.triples[0][-1] def __len__(self): return self.len def __getitem__(self, idx): if self.mode == 'tail-batch': positive_sample = self.triples[idx][0] # the data format (sub, (rel, ), fake_obj) head, relations = positive_sample candicates = list(self.true_missing[positive_sample]) # tail = np.random.choice(candicates) tail = self.triples[idx][1] subsampling_weight = len(candicates) + 4 subsampling_weight = torch.sqrt(1 / torch.Tensor([subsampling_weight])) negative_sample_list = [] negative_sample_size = 0 while negative_sample_size < self.negative_sample_size: negative_sample = np.random.randint(self.nentity, size=self.negative_sample_size*2) mask = np.in1d( ## mask is used here to filter out other true possibilities negative_sample, self.true_missing[positive_sample], assume_unique=True, invert=True ) negative_sample = negative_sample[mask] negative_sample_list.append(negative_sample) negative_sample_size += negative_sample.size negative_sample = np.concatenate(negative_sample_list)[:self.negative_sample_size] negative_sample = torch.from_numpy(negative_sample) positive_sample = torch.LongTensor([positive_sample[0], positive_sample[1], tail]) return positive_sample, negative_sample, subsampling_weight, self.mode elif self.mode == 'head-batch': positive_sample = self.triples[idx][0] # the data format (fake_sub, ((rel, ), obj)) head, relations, tail = positive_sample head = np.random.choice(list(self.true_missing[(0,(relations, tail))])) subsampling_weight = self.count[(relations, tail)] subsampling_weight = torch.sqrt(1 / torch.Tensor([subsampling_weight])) negative_sample_list = [] negative_sample_size = 0 while negative_sample_size < self.negative_sample_size: negative_sample = np.random.randint(self.nentity, size=self.negative_sample_size*2) mask = np.in1d( negative_sample, self.true_missing[(0,(relations, tail))], assume_unique=True, invert=True ) negative_sample = negative_sample[mask] negative_sample_list.append(negative_sample) negative_sample_size += negative_sample.size negative_sample = np.concatenate(negative_sample_list)[:self.negative_sample_size] negative_sample = torch.from_numpy(negative_sample) positive_sample = torch.LongTensor([head] + [i for i in relations] + [tail]) return positive_sample, negative_sample, subsampling_weight, self.mode @staticmethod def collate_fn(data): positive_sample = torch.stack([_[0] for _ in data], dim=0) negative_sample = torch.stack([_[1] for _ in data], dim=0) subsample_weight = torch.cat([_[2] for _ in data], dim=0) mode = data[0][3] return positive_sample, negative_sample, None, subsample_weight, mode def get_subsampling_weight(new_query, true_missing, start=4): return len(true_missing[new_query]) + start @staticmethod def count_frequency(triples, true_missing, mode, start=4): count = {} # if mode == 'tail-batch': for triple in triples: # head, relations = triple if triple not in count: count[triple] = start + len(true_missing[triple]) return count # elif mode == 'head-batch': # for triple, qtype in triples: # head, relations, tail = triple # assert (relations, tail) not in count # count[(relations, tail)] = start + len(true_missing[(0,(relations, tail))]) # return count class TrainInterDataset(Dataset): def __init__(self, triples, nentity, nrelation, ntimestamps, negative_sample_size, train_ans, mode, ans_t, use_one_sample=False, use_two_sample=False, add_hard_neg=False, double_point_in_time=False, num_time_negatives=0): self.len = len(triples) self.triples = triples self.nentity = nentity self.nrelation = nrelation self.ntimestamps = ntimestamps self.negative_sample_size = negative_sample_size - num_time_negatives self.mode = mode self.true_missing = train_ans self.true_ans_t = ans_t self.qtype = self.triples[0][-1] self.use_one_sample = use_one_sample self.use_two_sample = use_two_sample self.add_hard_neg = add_hard_neg self.num_time_negatives = num_time_negatives if double_point_in_time: self.qtype = '2-3-inter' # if self.qtype == '2-inter' or ((~self.use_one_sample) and (~self.use_two_sample) and self.qtype=='3-inter'): # self.count = self.count_frequency(triples, train_ans) if self.use_one_sample: self.qtype = '2-inter' assert use_one_sample * use_two_sample != 1 def __len__(self): return self.len def __getitem__(self, idx): query = self.triples[idx][0] #[entity, relation, start, end] gold_tail = self.triples[idx][1] time_type = self.triples[idx][2] # flat_query = np.array(query) # ### deal with full interval if time_type == TIME_TYPE['full-interval']: start_date = query[2] end_date = query[3] if self.use_one_sample: # sample one time from the inside assert start_date != end_date # we must make sure we do not consider point in time here, excluding tuples with point-in-time assert start_date != -1 # we must make sure we do not consider point in time here, excluding tuples with point-in-time assert end_date != -1 # we must make sure we do not consider point in time here, excluding tuples with point-in-time date = (np.random.random(1)*(end_date-start_date)+start_date).round() date = int(date[0]) query = (query[0], query[1], date) elif self.use_two_sample: assert start_date != end_date # we must make sure we do not consider point in time here, excluding tuples with point-in-time date_1,date_2 = (np.random.random(2)*(end_date-start_date)+start_date).round() while (date_1 == date_2): date_2 = (np.random.random(1)*(end_date-start_date)+start_date).round() s_date, e_date = sorted([date_1, date_2]) query = (query[0], query[1], int(s_date), int(e_date)) # elif time_type == TIME_TYPE['only-begin']: # query = (query[0], query[1], query[2]) elif time_type in [TIME_TYPE['only-end'], TIME_TYPE['point-in-time'], TIME_TYPE['only-begin']]: query = query else: print("test ", self.triples[idx]) raise NotImplementedError # tail = np.random.choice(list(self.true_missing[query])) positive_sample = torch.LongTensor(list(query)+[gold_tail]) # positive samples include the flat-query but the negative samples just have the tails if 'tail-batch' in self.mode: subsampling_weight = self.get_subsampling_weight(query, self.true_missing) subsampling_weight = torch.sqrt(1 / torch.Tensor([subsampling_weight])) negative_sample_list = [] negative_sample_size = 0 ## in this part, for a query, hard negatives are those not in (s,r,o,t) but in (s, r, o) if self.add_hard_neg: assert len(self.true_missing[(query[0], query[1])]) >= len(self.true_missing[query]) hard_neg = np.array(list(set(self.true_missing[(query[0], query[1])]) - set(self.true_missing[query])), dtype=np.int) # if hard_neg.size != 0: negative_sample_list.append(hard_neg) negative_sample_size += hard_neg.size #print('qtype:', self.qtype) ## while negative_sample_size < self.negative_sample_size: negative_sample = np.random.randint(self.nentity, size=self.negative_sample_size*2) mask = np.in1d( negative_sample, self.true_missing[query], assume_unique=True, invert=True ) negative_sample = negative_sample[mask] negative_sample_list.append(negative_sample) negative_sample_size += negative_sample.size negative_sample = np.concatenate(negative_sample_list)[:self.negative_sample_size] negative_sample = torch.from_numpy(negative_sample) time_negative_sample = None # return positive_sample, negative_sample, subsampling_weight, self.mode if 'time-batch' in self.mode: ## negative timestamps; negative_sample_list_time = [] negative_sample_size = 0 sro = (query[0], query[1], gold_tail) # subsampling_weight = self.get_subsampling_weight(sro, self.true_missing) # subsampling_weight = torch.sqrt(1 / torch.Tensor([subsampling_weight])) groundtruth_ts = self.true_ans_t[sro] if time_type == TIME_TYPE['only-begin']: groundtruth_ts.update(set(np.arange(query[2], min(query[2]+20, self.ntimestamps), 1)) ) elif time_type == TIME_TYPE['only-end']: groundtruth_ts.update(set(np.arange(max(0, query[2]-20), query[2], 1))) # elif time_type in [TIME_TYPE['point-in-time'], TIME_TYPE['full-interval']]: # groundtruth_ts = self.true_ans_t[sro] # else: # raise ValueError while negative_sample_size < self.num_time_negatives: time_negative_sample = np.random.randint(self.ntimestamps, size=self.num_time_negatives*2) mask = np.in1d( time_negative_sample, groundtruth_ts, assume_unique=True, invert=True ) time_negative_sample = time_negative_sample[mask] negative_sample_list_time.append(time_negative_sample) negative_sample_size += time_negative_sample.size time_negative_sample = np.concatenate(negative_sample_list_time)[:self.num_time_negatives] time_negative_sample = torch.from_numpy(time_negative_sample) return positive_sample, negative_sample, time_negative_sample, subsampling_weight, self.mode @staticmethod def collate_fn(data): positive_sample = torch.stack([_[0] for _ in data], dim=0) negative_sample = torch.stack([_[1] for _ in data], dim=0) if data[0][2] == None: time_negative_sample = None else: time_negative_sample = torch.stack([_[2] for _ in data], dim=0) subsample_weight = torch.cat([_[3] for _ in data], dim=0) mode = data[0][4] return positive_sample, negative_sample, time_negative_sample, subsample_weight, mode @staticmethod def get_subsampling_weight(new_query, true_missing, start=4): return len(true_missing[new_query]) + start @staticmethod def count_frequency(triples, true_missing, start=4): count = {} for triple,qtype in triples: # query = triple[:-2] if triple not in count: count[query] = start + len(true_missing[triple]) return count class TestInterDataset(Dataset): def __init__(self, triples, test_ans, test_ans_hard, nentity, nrelation, ntimestamps, mode, use_one_sample=False, use_two_sample=False, enumerate_time=False, double_point_in_time=False, predict_o=True, predict_t=False, predict_r=False): self.len = len(triples) self.triples = triples self.nentity = nentity self.nrelation = nrelation self.ntimestamps = ntimestamps self.mode = mode self.test_ans = test_ans self.test_ans_hard = test_ans_hard self.qtype = self.triples[0][-1] self.use_one_sample = use_one_sample self.use_two_sample = use_two_sample self.enumerate_time = enumerate_time self.predict_o = predict_o self.predict_t = predict_t self.predict_r = predict_r if double_point_in_time: self.qtype = '2-3-inter' if self.use_one_sample: ## Once datasets are fed here, must be 2-inter or 3-inter self.qtype = '2-inter' if self.enumerate_time: ## Once datasets are fed here, must be 2-inter or 3-inter self.qtype = '2-inter' def __len__(self): return self.len def __getitem__(self, idx): query = self.triples[idx][0] # used as keys to search for the filtered set gold_tail = self.triples[idx][1] time_type = self.triples[idx][2] if self.predict_o: # tail = self.triples[idx][-2] # this is not the true tail, used for place holder negative_sample = torch.LongTensor(range(self.nentity)) # negative samples: all the entities # flat_query = np.array(query) # flat_query =
<filename>openmdao/jacobians/tests/test_jacobian.py """ Test the Jacobian objects.""" import itertools import sys import unittest import numpy as np from scipy.sparse import coo_matrix, csr_matrix from openmdao.api import IndepVarComp, Group, Problem, \ ExplicitComponent, ImplicitComponent, ExecComp, \ NewtonSolver, ScipyKrylov, \ LinearBlockGS, DirectSolver from openmdao.utils.assert_utils import assert_rel_error from openmdao.test_suite.components.paraboloid import Paraboloid from openmdao.api import ScipyOptimizeDriver try: from parameterized import parameterized except ImportError: from openmdao.utils.assert_utils import SkipParameterized as parameterized class MyExplicitComp(ExplicitComponent): def __init__(self, jac_type): super(MyExplicitComp, self).__init__() self._jac_type = jac_type def setup(self): self.add_input('x', val=np.zeros(2)) self.add_input('y', val=np.zeros(2)) self.add_output('f', val=np.zeros(2)) val = self._jac_type(np.array([[1., 1.], [1., 1.]])) if isinstance(val, list): self.declare_partials('f', ['x','y'], rows=val[1], cols=val[2], val=val[0]) else: self.declare_partials('f', ['x','y'], val=val) def compute(self, inputs, outputs): x = inputs['x'] y = inputs['y'] outputs['f'][0] = (x[0]-3.0)**2 + x[0]*x[1] + (x[1]+4.0)**2 - 3.0 + \ y[0]*17. - y[0]*y[1] + 2.*y[1] outputs['f'][1] = outputs['f'][0]*3.0 def compute_partials(self, inputs, partials): x = inputs['x'] y = inputs['y'] jac1 = self._jac_type(np.array([ [2.0*x[0] - 6.0 + x[1], 2.0*x[1] + 8.0 + x[0]], [(2.0*x[0] - 6.0 + x[1])*3., (2.0*x[1] + 8.0 + x[0])*3.] ])) if isinstance(jac1, list): jac1 = jac1[0] partials['f', 'x'] = jac1 jac2 = self._jac_type(np.array([ [17.-y[1], 2.-y[0]], [(17.-y[1])*3., (2.-y[0])*3.] ])) if isinstance(jac2, list): jac2 = jac2[0] partials['f', 'y'] = jac2 class MyExplicitComp2(ExplicitComponent): def __init__(self, jac_type): super(MyExplicitComp2, self).__init__() self._jac_type = jac_type def setup(self): self.add_input('w', val=np.zeros(3)) self.add_input('z', val=0.0) self.add_output('f', val=0.0) val = self._jac_type(np.array([[7.]])) if isinstance(val, list): self.declare_partials('f', 'z', rows=val[1], cols=val[2], val=val[0]) else: self.declare_partials('f', 'z', val=val) val = self._jac_type(np.array([[1., 1., 1.]])) if isinstance(val, list): self.declare_partials('f', 'w', rows=val[1], cols=val[2], val=val[0]) else: self.declare_partials('f', 'w', val=val) def compute(self, inputs, outputs): w = inputs['w'] z = inputs['z'] outputs['f'] = (w[0]-5.0)**2 + (w[1]+1.0)**2 + w[2]*6. + z*7. def compute_partials(self, inputs, partials): w = inputs['w'] z = inputs['z'] jac = self._jac_type(np.array([[ 2.0*w[0] - 10.0, 2.0*w[1] + 2.0, 6. ]])) if isinstance(jac, list): jac = jac[0] partials['f', 'w'] = jac class ExplicitSetItemComp(ExplicitComponent): def __init__(self, dtype, value, shape, constructor): self._dtype = dtype self._shape = shape self._value = value self._constructor = constructor super(ExplicitSetItemComp, self).__init__() def setup(self): if self._shape == 'scalar': in_val = 1 out_val = 1 elif self._shape == '1D_array': in_val = np.array([1]) out_val = np.array([1, 2, 3, 4, 5]) elif self._shape == '2D_array': in_val = np.array([1, 2, 3]) out_val = np.array([1, 2, 3]) if self._dtype == 'int': scale = 1 elif self._dtype == 'float': scale = 1. elif self._dtype == 'complex': scale = 1j self.add_input('in', val=in_val*scale) self.add_output('out', val=out_val*scale) self.declare_partials(of='*', wrt='*') def compute_partials(self, inputs, partials): partials['out', 'in'] = self._constructor(self._value) class SimpleCompWithPrintPartials(ExplicitComponent): def setup(self): self.add_input('x', val=0.0) self.add_input('y', val=0.0) self.add_output('f_xy', val=0.0, upper=1.0) self.declare_partials(of='*', wrt='*') self.count = 0 self.partials_name_pairs = [] self.partials_values = [] def compute(self, inputs, outputs): x = inputs['x'] y = inputs['y'] outputs['f_xy'] = (x-3.0)**2 + x*y + (y+4.0)**2 - 3.0 def compute_partials(self, inputs, partials): x = inputs['x'] y = inputs['y'] partials['f_xy', 'x'] = 2.0*x - 6.0 + y partials['f_xy', 'y'] = 2.0*y + 8.0 + x if self.count < 1: # Only want to save these this once for the test for k in partials: self.partials_name_pairs.append(k) for k, v in partials.items(): self.partials_values.append((k,v)) self.count += 1 def arr2list(arr): """Convert a numpy array to a 'sparse' list.""" data = [] rows = [] cols = [] for row in range(arr.shape[0]): for col in range(arr.shape[1]): rows.append(row) cols.append(col) data.append(arr[row, col]) return [np.array(data), np.array(rows), np.array(cols)] def arr2revlist(arr): """Convert a numpy array to a 'sparse' list in reverse order.""" lst = arr2list(arr) return [lst[0][::-1], lst[1][::-1], lst[2][::-1]] def inverted_coo(arr): """Convert an ordered coo matrix into one with columns in reverse order so we can test unsorted coo matrices. """ shape = arr.shape arr = coo_matrix(arr) return coo_matrix((arr.data[::-1], (arr.row[::-1], arr.col[::-1])), shape=shape) def inverted_csr(arr): """Convert an ordered coo matrix into a csr with columns in reverse order so we can test unsorted csr matrices. """ return inverted_coo(arr).tocsr() def _test_func_name(func, num, param): args = [] for p in param.args: try: arg = p.__name__ except: arg = str(p) args.append(arg) return 'test_jacobian_src_indices_' + '_'.join(args) class TestJacobian(unittest.TestCase): @parameterized.expand(itertools.product( ['dense', 'csc'], [np.array, coo_matrix, csr_matrix, inverted_coo, inverted_csr, arr2list, arr2revlist], [False, True], # not nested, nested [0, 1], # extra calls to linearize ), name_func=_test_func_name ) def test_src_indices(self, assembled_jac, comp_jac_class, nested, lincalls): self._setup_model(assembled_jac, comp_jac_class, nested, lincalls) # if we multiply our jacobian (at x,y = ones) by our work vec of 1's, # we get fwd_check fwd_check = np.array([-1.0, -1.0, -1.0, -1.0, -1.0, 24., 74., 8.]) # if we multiply our jacobian's transpose by our work vec of 1's, # we get rev_check rev_check = np.array([35., 5., -9., 63., 3., -1., 6., -1.]) self._check_fwd(self.prob, fwd_check) # to catch issues with constant subjacobians, repeatedly call linearize for i in range(lincalls): self.prob.model.run_linearize() self._check_fwd(self.prob, fwd_check) self._check_rev(self.prob, rev_check) def _setup_model(self, assembled_jac, comp_jac_class, nested, lincalls): self.prob = prob = Problem() if nested: top = prob.model.add_subsystem('G1', Group()) else: top = prob.model indep = top.add_subsystem('indep', IndepVarComp()) indep.add_output('a', val=np.ones(3)) indep.add_output('b', val=np.ones(2)) top.add_subsystem('C1', MyExplicitComp(comp_jac_class)) top.add_subsystem('C2', MyExplicitComp2(comp_jac_class)) top.connect('indep.a', 'C1.x', src_indices=[2,0]) top.connect('indep.b', 'C1.y') top.connect('indep.a', 'C2.w', src_indices=[0,2,1]) top.connect('C1.f', 'C2.z', src_indices=[1]) top.nonlinear_solver = NewtonSolver(solve_subsystems=False) top.nonlinear_solver.linear_solver = ScipyKrylov(maxiter=100) top.linear_solver = ScipyKrylov( maxiter=200, atol=1e-10, rtol=1e-10, assemble_jac=True) top.options['assembled_jac_type'] = assembled_jac prob.set_solver_print(level=0) prob.setup() prob.run_model() def _check_fwd(self, prob, check_vec): d_inputs, d_outputs, d_residuals = prob.model.get_linear_vectors() work = d_outputs._clone() work.set_const(1.0) # fwd apply_linear test d_outputs.set_const(1.0) prob.model.run_apply_linear(['linear'], 'fwd') d_residuals._data[:] = d_residuals._data - check_vec self.assertAlmostEqual(d_residuals.get_norm(), 0) # fwd solve_linear test d_outputs.set_const(0.0) d_residuals._data[:] = check_vec prob.model.run_solve_linear(['linear'], 'fwd') d_outputs -= work self.assertAlmostEqual(d_outputs.get_norm(), 0, delta=1e-6) def _check_rev(self, prob, check_vec): d_inputs, d_outputs, d_residuals = prob.model.get_linear_vectors() work = d_outputs._clone() work.set_const(1.0) # rev apply_linear test d_residuals.set_const(1.0) prob.model.run_apply_linear(['linear'], 'rev') d_outputs._data[:] = d_outputs._data - check_vec self.assertAlmostEqual(d_outputs.get_norm(), 0) # rev solve_linear test d_residuals.set_const(0.0) d_outputs._data[:] = check_vec prob.model.run_solve_linear(['linear'], 'rev') d_residuals -= work self.assertAlmostEqual(d_residuals.get_norm(), 0, delta=1e-6) dtypes = [ ('int', 1), ('float', 2.1), # ('complex', 3.2 + 1.1j), # TODO: enable when Vectors support complex entries. ] shapes = [ ('scalar', lambda x: x, (1, 1)), ('1D_array', lambda x: np.array([x + i for i in range(5)]), (5, 1)), ('2D_array', lambda x: np.array([[x + i + 2 * j for i in range(3)] for j in range(3)]), (3, 3)) ] @parameterized.expand(itertools.product(dtypes, shapes), name_func= lambda f, n, p: '_'.join(['test_jacobian_set_item', p.args[0][0], p.args[1][0]])) def test_jacobian_set_item(self, dtypes, shapes): shape, constructor, expected_shape = shapes dtype, value = dtypes prob = Problem() comp = ExplicitSetItemComp(dtype, value, shape, constructor) prob.model.add_subsystem('C1', comp) prob.setup() prob.set_solver_print(level=0) prob.run_model() prob.model.run_apply_nonlinear() prob.model.run_linearize() expected = constructor(value) J = prob.model._subsystems_allprocs[0]._jacobian jac_out = J['out', 'in'] self.assertEqual(len(jac_out.shape), 2) expected_dtype = np.promote_types(dtype, float) self.assertEqual(jac_out.dtype, expected_dtype) assert_rel_error(self, jac_out, np.atleast_2d(expected).reshape(expected_shape), 1e-15) def test_group_assembled_jac_with_ext_mat(self): class TwoSellarDis1(ExplicitComponent): """ Component containing Discipline 1 -- no derivatives version. """ def setup(self): self.add_input('z', val=np.zeros(2)) self.add_input('x', val=np.zeros(2)) self.add_input('y2', val=np.ones(2)) self.add_output('y1', val=np.ones(2)) self.declare_partials(of='*', wrt='*') def compute(self, inputs, outputs): z1 = inputs['z'][0] z2 = inputs['z'][1] x1 = inputs['x'] y2 = inputs['y2'] outputs['y1'][0] = z1**2 + z2 + x1[0] - 0.2*y2[0] outputs['y1'][1] = z1**2 + z2 + x1[0] - 0.2*y2[0] def compute_partials(self, inputs, partials): """ Jacobian for Sellar discipline 1. """ partials['y1', 'y2'] =np.array([[-0.2, 0.], [0., -0.2]]) partials['y1', 'z'] = np.array([[2.0 * inputs['z'][0], 1.0], [2.0 * inputs['z'][0], 1.0]]) partials['y1', 'x'] = np.eye(2) class TwoSellarDis2(ExplicitComponent): def setup(self): self.add_input('z', val=np.zeros(2)) self.add_input('y1', val=np.ones(2)) self.add_output('y2', val=np.ones(2)) self.declare_partials('*', '*', method='fd') def compute(self, inputs, outputs): z1 = inputs['z'][0] z2 = inputs['z'][1] y1 = inputs['y1'] # Note: this may cause some issues. However, y1 is constrained to be # above 3.16, so lets just let it converge, and the optimizer will # throw it out if y1[0].real < 0.0: y1[0] *= -1 if y1[1].real < 0.0: y1[1] *= -1 outputs['y2'][0] = y1[0]**.5 + z1 + z2 outputs['y2'][1] = y1[1]**.5 + z1 + z2 def compute_partials(self, inputs, J): y1 = inputs['y1'] if y1[0].real < 0.0: y1[0] *= -1 if y1[1].real < 0.0: y1[1] *= -1 J['y2', 'y1'] = np.array([[.5*y1[0]**-.5, 0.], [0., .5*y1[1]**-.5]]) J['y2', 'z'] = np.array([[1.0, 1.0], [1.0, 1.0]]) prob = Problem() model = prob.model model.add_subsystem('px', IndepVarComp('x', np.array([1.0, 1.0])), promotes=['x']) model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0])), promotes=['z']) sup = model.add_subsystem('sup', Group(), promotes=['*']) sub1 = sup.add_subsystem('sub1', Group(), promotes=['*']) sub2 = sup.add_subsystem('sub2', Group(), promotes=['*']) d1 = sub1.add_subsystem('d1', TwoSellarDis1(), promotes=['x', 'z', 'y1', 'y2']) sub2.add_subsystem('d2', TwoSellarDis2(), promotes=['z', 'y1', 'y2']) model.add_subsystem('con_cmp1', ExecComp('con1 = 3.16 - y1[0] - y1[1]', y1=np.array([0.0, 0.0])), promotes=['con1', 'y1']) model.add_subsystem('con_cmp2', ExecComp('con2 = y2[0] + y2[1] - 24.0', y2=np.array([0.0, 0.0])), promotes=['con2', 'y2']) model.linear_solver = LinearBlockGS() sup.linear_solver = LinearBlockGS() sub1.linear_solver = DirectSolver(assemble_jac=True) sub2.linear_solver = DirectSolver(assemble_jac=True) prob.set_solver_print(level=0) prob.setup(check=False, mode='rev')
import discord from discord.ext import commands from cogs.utils import hypixel from datetime import datetime import json import aiohttp from concurrent.futures import ThreadPoolExecutor import asyncio import requests class staff(commands.Cog, name="Staff"): def __init__(self, bot): self.bot = bot @commands.command(aliases=['req', 'requirement']) async def requirements(self, ctx): """Lists the requirements """ embed = discord.Embed(title="Miscellaneous Guild Requirements", description="These requirements are subject to change!", color=0x8368ff) embed.add_field(name="Active", value=f"• {format(self.bot.active, ',d')} Weekly Guild Experience", inline=False) embed.add_field(name="Do Not Kick List Eligibility", value=f"• {format(self.bot.dnkl, ',d')} Weekly Guild Experience", inline=False) embed.add_field(name="Resident", value=f"• {format(self.bot.resident_req, ',d')} Weekly Guild Experience", inline=False) embed.add_field(name="Member", value=f"• {format(self.bot.inactive, ',d')} Weekly Guild Experience", inline=False) embed.add_field(name="New Member", value=f"• {format(self.bot.new_member, ',d')} Daily Guild Experience", inline=False) embed.set_footer(text="You are considered a New Member for the first 7 days after joining the guild" "\nIf you fail to meet the New Member/Member requirements, you will be kicked!") await ctx.send(embed=embed) @commands.command(aliases=['res']) async def resident(self, ctx): """Lists the methods to get the resident rank """ embed = discord.Embed(title='How to get Resident?', description='To be eligible for Resident, you must be one of the following', color=0x8368ff) embed.add_field(name="Veteran", value="Be in the guild for more than 1 year", inline=False) embed.add_field(name="Youtuber", value="If you're a youtuber with more than 5,000 subscribers, you aren't subject to any guild requirements.", inline=False) embed.add_field(name="<NAME>", value="Spend Money on the guild by doing giveaways, sponsoring events!", inline=False) embed.add_field(name="GvG Team", value="Be an exceptional GvG player.", inline=False) embed.set_footer( text=f"Everyone who has the resident rank must get {format(self.bot.resident_req, ',d')} weekly guild experience! (Except YouTubers)") await ctx.send(embed=embed) @commands.command(aliases=['ticket']) async def tickets(self, ctx): """Explains the entire ticket system """ embed = discord.Embed(title="How to create a ticket?", color=0x8368ff) embed.add_field(name="Go to #🎟-tickets-🎟", value="#🎟-tickets-🎟 is located in the noticeboard category", inline=False) embed.add_field(name="Tickets can be created for the following reasons", value="> Discord Nick/Role & Tag Change/\n" "> Do not kick list\n" "> Problems/Queries/Complaint/Suggestion\n" "> Reporting a player\n" "> Milestone\n" "> Staff Application\n" "> Event\n" "> Other", inline=False) embed.add_field(name="Click the button under the message sent by @Miscellaneous", value="The following image shows you what you need to click.", inline=False) embed.set_image( url=f"https://media.discordapp.net/attachments/813075018820222976/870799273892147230/unknown.png?width=1316&height=671") await ctx.send(embed=embed) @commands.command() @commands.has_role(538015368782807040) async def inactive(self, ctx): """Prints a list of users who need to be promoted, demoted, warned and kicked! """ msg = await ctx.send("**Please wait!**\n `Approximate wait time: Calculating`") api = hypixel.get_api() async with aiohttp.ClientSession() as session: async with session.get(f'https://api.hypixel.net/guild?key={api}&name=Miscellaneous') as resp: g = await resp.json() await session.close() with open('dnkl.json') as f: data = json.load(f) dnkl_names = data.keys() activearray = {} activedemotearray = {} inactivearray = {} veteranarray = {} exp = 0 await msg.edit(content=f"**Please wait!**\n `Approximate wait time: 15 seconds`") async with ctx.channel.typing(): for i in range(len(g['guild']['members'])): expHistory = sum(g['guild']['members'][i]['expHistory'].values()) rank = g['guild']['members'][i]['rank'] joined = g['guild']['members'][i]['joined'] if expHistory >= self.bot.active and rank == "Member": uuid = g['guild']['members'][i]['uuid'] async with aiohttp.ClientSession() as session: async with session.get( f'https://sessionserver.mojang.com/session/minecraft/profile/{uuid}') as resp: a = await resp.json() await session.close() name = a['name'] time = str(datetime.fromtimestamp(int(str(joined)[:-3]))) dt = (time[0:10]) if name in dnkl_names: name = name + f'[DNKL]\n{dt}' else: name = name + f'[{rank}]\n{dt}' exp += expHistory activearray[name] = exp exp = 0 elif expHistory < self.bot.active and rank == "Active": uuid = g['guild']['members'][i]['uuid'] async with aiohttp.ClientSession() as session: async with session.get( f'https://sessionserver.mojang.com/session/minecraft/profile/{uuid}') as resp: a = await resp.json() await session.close() name = a['name'] time = str(datetime.fromtimestamp(int(str(joined)[:-3]))) dt = (time[0:10]) if name in dnkl_names: name = name + f'[DNKL]\n{dt}' else: name = name + f'[{rank}]\n{dt}' exp += expHistory activedemotearray[name] = exp exp = 0 elif expHistory < self.bot.inactive: if rank == "Member": uuid = g['guild']['members'][i]['uuid'] async with aiohttp.ClientSession() as session: async with session.get( f'https://sessionserver.mojang.com/session/minecraft/profile/{uuid}') as resp: a = await resp.json() time = str(datetime.fromtimestamp(int(str(joined)[:-3]))) name = a['name'] dt = (time[0:10]) if name in dnkl_names: name = name + f'[DNKL]\n{dt}' else: name = name + f'[{rank}]\n{dt}' exp += expHistory inactivearray[name] = exp exp = 0 elif rank == "Resident": if expHistory < self.bot.resident_req: uuid = g['guild']['members'][i]['uuid'] async with aiohttp.ClientSession() as session: async with session.get( f'https://sessionserver.mojang.com/session/minecraft/profile/{uuid}') as resp: a = await resp.json() time = str(datetime.fromtimestamp(int(str(joined)[:-3]))) name = a['name'] dt = (time[0:10]) if name in dnkl_names: name = name + f'[DNKL]\n{dt}' else: name = name + f'[{rank}]\n{dt}' exp += expHistory veteranarray[name] = exp exp = 0 else: pass ActivesortedList = sorted(activearray.items(), key=lambda x: x[1], reverse=True) ActiveDemoteSortedList = sorted(activedemotearray.items(), key=lambda x: x[1], reverse=True) VeteransortedList = sorted(veteranarray.items(), key=lambda x: x[1], reverse=True) InactivesortedList = sorted(inactivearray.items(), key=lambda x: x[1], reverse=True) await msg.edit(content="**Please wait!**\n `The embeds are being sent!`") '---------------------------------------------------------------ACTIVE PROMOTION------------------------------------------------------------------------------' embed = discord.Embed(title=f"Promote the following users:", description=f"Total: {len(ActivesortedList)}", color=0x43b581) y = 0 if len(ActivesortedList) <= 25: for user in ActivesortedList: embed.add_field(name=f"{user[0]}", value=f"```cs\n{format(user[1], ',d')}```", inline=True) await ctx.send(embed=embed) else: for user in ActivesortedList: y = y + 1 embed.add_field(name=f"{user[0]}", value=f"```cs\n{format(user[1], ',d')}```", inline=True) if len(embed.fields) >= 25: await ctx.send(embed=embed) embed.clear_fields() embed = discord.Embed(title="", color=0x43b581) elif y == len(ActivesortedList): await ctx.send(embed=embed) '---------------------------------------------------------------ACTIVE DEMOTION-------------------------------------------------------------------------------' embed = discord.Embed(title=f"Demote the following users:", description=f"Total: {len(ActiveDemoteSortedList)}", color=0xf04747) z = 0 if len(ActiveDemoteSortedList) <= 25: for user in ActiveDemoteSortedList: embed.add_field(name=f"{user[0]}", value=f"```cs\n{format(user[1], ',d')}```", inline=True) await ctx.send(embed=embed) else: for user in ActiveDemoteSortedList: z = z + 1 embed.add_field(name=f"{user[0]}", value=f"```cs\n{format(user[1], ',d')}```", inline=True) if len(embed.fields) >= 25: await ctx.send(embed=embed) embed.clear_fields() embed = discord.Embed(title="", color=0xf04747) elif z == len(ActiveDemoteSortedList): await ctx.send(embed=embed) '---------------------------------------------------------------VETERAN WARNING-------------------------------------------------------------------------------' embed = discord.Embed( title=f"Following are the residents who don't meet the requirements:", description=f"Total: {len(VeteransortedList)}", color=0xe5ba6c) w = 0 if len(VeteransortedList) <= 25: for user in VeteransortedList: embed.add_field(name=f"{user[0]}", value=f"```\n{format(user[1], ',d')}```", inline=True) await ctx.send(embed=embed) else: for user in VeteransortedList: w = w + 1 embed.add_field(name=f"{user[0]}", value=f"```\n{format(user[1], ',d')}```", inline=True) if len(embed.fields) >= 25: await ctx.send(embed=embed) embed.clear_fields() embed = discord.Embed(title="", color=0xe5ba6c) elif w == len(VeteransortedList): await ctx.send(embed=embed) '---------------------------------------------------------------INACTIVE MEMBERS------------------------------------------------------------------------------' embed = discord.Embed(title=f"The users to be kicked are as follows:", description=f"Total: {len(InactivesortedList)}", color=0xf04747) x = 0 if len(InactivesortedList) <= 25: for user in InactivesortedList: embed.add_field(name=f"{user[0]}", value=f"```cs\n{format(user[1], ',d')}```", inline=True) await ctx.send(embed=embed) else: for user in InactivesortedList: x = x + 1 embed.add_field(name=f"{user[0]}", value=f"```cs\n{format(user[1], ',d')}```", inline=True) if len(embed.fields) >= 25: await ctx.send(embed=embed) embed.clear_fields() embed = discord.Embed(title="", color=0xf04747) elif x == len(InactivesortedList): await ctx.send(embed=embed) await msg.delete() @commands.command() @commands.has_role(538015368782807040) async def rolecheck(self, ctx, send_ping=None): """Checks the roles of all the users and changes them on the basis of their guild """ msg = await ctx.send("**Processing all the prerequisites**") misc_uuids = await hypixel.get_guild_members("Miscellaneous") misc_members, ally_members, ally_uuids = [], [], [] for x in self.bot.misc_allies: ally_uuids = ally_uuids + await hypixel.get_guild_members(x) # Miscellaneous Member Names await msg.edit(content="**Processing** - 1/2") with ThreadPoolExecutor(max_workers=10) as executor: with requests.Session() as session: # Set any session parameters here before calling `fetch` loop = asyncio.get_event_loop() tasks = [ loop.run_in_executor( executor, hypixel.fetch, *(session, individual_misc_uuid) # Allows us to pass in multiple arguments to `fetch` ) for individual_misc_uuid in misc_uuids ] for response in await asyncio.gather(*tasks): # Puts the result into a list misc_members.append(response) # Ally Member Names await msg.edit(content="**Processing** - 2/2") with ThreadPoolExecutor(max_workers=10) as executor: with requests.Session() as session: # Set any session parameters here before calling `fetch` loop = asyncio.get_event_loop() tasks = [ loop.run_in_executor( executor, hypixel.fetch, *(session, individual_ally_uuid) # Allows us to pass in multiple arguments to `fetch` ) for individual_ally_uuid in ally_uuids ] for response in await asyncio.gather(*tasks): # Puts the result into a list ally_members.append(response) for guild in self.bot.guilds: if str(guild) == "Miscellaneous [MISC]": # Check if the Discord is Miscellaneous for member in guild.members: # For loop for all members in the Discord if member.id not in self.bot.adminids and member.bot is False: name = await hypixel.name_grabber(member) message = await ctx.send(f"Checking {name}") async with aiohttp.ClientSession() as session: async with session.get(f'https://api.mojang.com/users/profiles/minecraft/{name}') as mojang: if mojang.status != 200: # If the IGN is invalid await member.remove_roles(self.bot.member_role, self.bot.guest) await member.add_roles(self.bot.new_member_role) await message.edit(content= f"{name} ||{member}|| Player doesn't exist. **++New Member | --Member | -- Guest**") continue elif self.bot.guild_master not in member.roles: mojang_json = await mojang.json() ign = mojang_json["name"] uuid = mojang_json['id'] await session.close() # Miscellaneous if ign in misc_members and ign not in ( "Rowdies", "PolarPowah", "LBROz", "Fantastic_Doge", "ElijahRus", "BotTyler"): async with aiohttp.ClientSession() as session: async with session.get( f"https://api.hypixel.net/guild?key={hypixel.get_api()}&player={uuid}") as resp: req = await resp.json() await session.close() if self.bot.member_role not in member.roles: await member.add_roles(self.bot.member_role) await member.remove_roles(self.bot.new_member_role, self.bot.guest) has_tag_perms = any(role in ctx.author.roles for role in self.bot.tag_allowed_roles) for user in req['guild']["members"]: if
<reponame>colebrooke/adventure #!/usr/bin/env python3 # # "Adventure Game" # # This is a text based science fiction themed adventure game, written in Python 3. # The database back end is created in SQLite3. # # Main authors <NAME> and <NAME>. # Contributions welcome. # # Github page: https://github.com/colebrooke/adventure # # For setup instructions, see README.md # debug = 0 import sqlite3 as sqlitedb import sys import os import time import fnmatch # this is for pattern matching files import re # for regex string matching import random # for battles and npc moves os.system('cls') os.system('clear') conection = sqlitedb.connect('game.db') def p(debugstring): if (debug == 1): print ("%s" % debugstring) #conection.text_factory = str def db(sqlstring): conection = sqlitedb.connect('game.db') #--------------------------------------------------------- with conection: cursor = conection.cursor() cursor.execute("%s" % sqlstring) row = cursor.fetchone() return ("%s" % (row)) cursor.close() #--------------------------------------------------------- def db_print_rows(sqlstring, colour='none'): #--------------------------------------------------------- with conection: cursor = conection.cursor() cursor.execute("%s" % sqlstring) for row in cursor: if colour == 'none': print ("%s" % (row)) if colour == 'yellow': print ('\033[1;33m%s\033[1;m' % (row)) if colour == 'magenta': print ('\033[1;35m%s\033[1;m' % (row)) if colour == 'grey': print ('\033[1;30m%s\033[1;m' % (row)) if colour == 'bold': print ('\033[1;37m%s\033[1;m' % (row)) cursor.close() #--------------------------------------------------------- def db_print_rows_numbered(sqlstring): #--------------------------------------------------------- with conection: cursor = conection.cursor() cursor.execute("%s" % sqlstring) a = 1 for row in cursor: print ( " ", row[0], " ", row[1]) cursor.close() #--------------------------------------------------------- def db_return_rows(sqlstring): #--------------------------------------------------------- with conection: cursor = conection.cursor() cursor.execute("%s" % sqlstring) row = cursor.fetchall() return row cursor.close() #--------------------------------------------------------- def db_query(sqlstring): #--------------------------------------------------------- with conection: cursor = conection.cursor() cursor.execute("%s" % sqlstring) rows = cursor.fetchall() cursor.close() # First need to convert each tuple in the list to a list within a list: row_list = [list(row) for row in rows ] #This gets the length of the list of items: #print ("number of items: %s" % len(item_list) ) # Now need to convert each list within the list to a normal string... for i, row_text in enumerate(row_list): row_list[i] = row_text[0] return row_list #--------------------------------------------------------- def scroll(lines): #---------------------------------------------------------------------- for x in range (0, lines): print ("") time.sleep(0.1) #---------------------------------------------------------------------- def where_am_i(userid): #---------------------------------------------------------------------- current_room = db("select location from user where userid=%s" % ( userid )) current_room_name = db("select roomname from rooms where roomid=%s" % current_room) print ("Your current location is: %s" % current_room_name ) time.sleep(0.3) print ("") #---------------------------------------------------------------------- def print_current_room(userid): #--------------------------------------------------------- current_room = db("select location from user where userid=%s" % ( userid )) #print ("current location for this user is %s" % (current_room)) #current_room = get_current_room ( userid ) print ("") print ("*********************************************************************") print ("") # print room name... db_print_rows("select roomname from rooms where roomid=%s" % current_room, 'bold') print ("") time.sleep(0.3) # print room description... db_print_rows("select roomdesc from rooms where roomid=%s" % current_room, 'grey' ) print ("") time.sleep(0.3) # print available routes to other rooms... db_print_rows("select route_desc from route where from_id=%s" % current_room ) time.sleep(0.3) print ("") # print any NPCs that may be in the room... db_print_rows("select npcshortdesc from npc where npcroom=%s and npcstatus=1" % current_room, 'yellow' ) print ("") # print any non-living npcs in the room... db_print_rows("select npcdeaddesc from npc where npcroom=%s and npcstatus=0" % current_room, 'yellow' ) print ("") time.sleep(0.3) # print any objects in the room #db_print_rows("select objectdesc_short from object where roomid=%s" % current_room ) #print ("") #time.sleep(0.3) # print any items in the room, if they are not in the users inventory... db_print_rows( "select itemdesc_short from item where currentroom = %s \ and itemid not in ( select distinct itemid from inventory \ where userid = %s ) order by static desc" % ( current_room, userid ), 'magenta') time.sleep(0.3) #--------------------------------------------------------- def get_current_room( userid ): #---------------------------------------------------------------------- current_room = db("select location from user where userid=%s" % ( userid )) return current_room #---------------------------------------------------------------------- def move( direction, userid ): #--------------------------------------------------------- room = get_current_room ( userid ) p("current room %s " % room) p("chosen direciton %s " % direction) p("userid %s " % userid) #illegal = 0 next_room = db("select to_id from route where from_id=%s and direction='%s'" % ( room, direction )) p ("next room query result: %s " % next_room ) #time.sleep(3) # current_room = next_room if (next_room == "None") or (not next_room): #current_room = room #illegal = 1 print("You can't go in that direction!") else: # add one to the user moves db("update user set moves = moves + 1 where userid = %s" % ( userid )) # set the users current location in the db db("update user set location = %s where userid = %s" % ( next_room, userid )) # print the room description for the user scroll (5) print_current_room( userid ) # return (current_room,illegal) #-------------------------------------------------------- def examine (): #--------------------------------------------------------- current_room = db("select location from user where userid=%s" % ( userid )) available_items = db_query("select lower(itemname) from item where currentroom=%s" % current_room ) # available_objects = db_query("select lower(objectname) from object where roomid=%s" % current_room ) available_npcs = db_query("select lower(npcname) from npc where npcroom =%s" % current_room ) available_inventory = ( "select lower(itemname) from user as U join \ inventory as I on U.userid=I.userid join \ item as D on I.itemid=D.itemid \ where I.userid=%s" % ( userid )) # strip the action term from the user input to leave the item your examining. if re.match (r'look at', userinput ): thing_to_examine = userinput.replace('look at ', '') else: thing_to_examine = userinput.replace('examine ', '') if thing_to_examine in available_items: print ("") print ("You examine the %s..." % thing_to_examine ) time.sleep(1.3) print ("") db_print_rows("select itemdesc from item where lower(itemname)='%s'" % thing_to_examine) print ("") time.sleep(0.8) elif thing_to_examine in available_inventory: print ("") print ("You examine the %s..." % thing_to_examine ) time.sleep(1.3) print ("") db_print_rows("select objectdesc from object where lower(objectname)='%s'" % thing_to_examine) elif thing_to_examine in available_npcs: npc_id = db("select npcid from npc where lower(npcname)='%s'" % thing_to_examine) npc_alive = db("select npcstatus from npc where lower(npcname)='%s'" % thing_to_examine) print ("") print ("You examine the %s..." % thing_to_examine ) time.sleep(1.3) print ("") if int(npc_alive) == 1: db_print_rows("select npclongdesc from npc where lower(npcname)='%s'" % thing_to_examine) else: db_print_rows("select npcdeaddesc from npc where lower(npcname)='%s'" % thing_to_examine) print ("The %s is carrying the following items:" % thing_to_examine) db_print_rows( "select lower(itemname) from npc as U join npc_inventory as I on U.npcid=I.npcid join \ item as D on I.itemid=D.itemid \ where I.npcid=%s" % ( npc_id )) else: print ("You can't do that.") #--------------------------------------------------------- def inventory (): #--------------------------------------------------------- print ("You have the following items in your inventory:-") db_print_rows( "select itemname from user as U join \ inventory as I on U.userid=I.userid join \ item as D on I.itemid=D.itemid \ where I.userid=%s" % (userid)) #--------------------------------------------------------- def take (): #--------------------------------------------------------- current_room = db("select location from user where userid=%s" % ( userid )) available_items = db_return_rows("select itemname from item where currentroom=%s" % current_room ) inventory = db_return_rows("select itemname from user as U join \ inventory as I on U.userid=I.userid join \ item as D on I.itemid=D.itemid \ where I.userid=%s" % (userid)) # For the inventory... # First need to convert each tuple in the list to a list within a list: inventory_list = [list(i) for i in inventory ] # Now need to convert each list within the list to a normal string... for i, item_name in enumerate(inventory_list): inventory_list[i] = item_name[0] # For the items in the room... # First need to convert each tuple in the list to a list within a list: item_list = [list(i) for i in available_items ] # Now need to convert each list within the list to a normal string... for i, item_name in enumerate(item_list): item_list[i] = item_name[0] # So that the list can be searched with the 'in' command... # strip the action term from the user input to leave the item you want to take. if re.match (r'take', userinput ): thing_to_take = userinput.replace('take ', '') elif re.match (r'pick up', userinput ): thing_to_take = userinput.replace('pick up ', '') elif re.match (r'get', userinput ): thing_to_take = userinput.replace('get ', '') if re.match (r'the', thing_to_take ): thing_to_take = thing_to_take.replace('the ', '') if thing_to_take in item_list: if thing_to_take in inventory_list: print ("The %s looks similar to one you already have." % thing_to_take ) print ("You decide to leave it for another adventurer to find.") else: thing_to_take_id = db("select itemid from item where itemname = '%s'" % thing_to_take ) item_is_static = db("select static from item where itemid = %s" % thing_to_take_id ) if item_is_static == '1': print ("The %s is too heavy for you to take with you!" % thing_to_take ) else: print ("You take the %s." % thing_to_take ) db("insert into inventory (userid, itemid) values ( '%s', '%s' )" % (userid, thing_to_take_id) ) else: print ("You can't do that!") #-------------------------------------------------------- def drop (): #-------------------------------------------------------- inventory = db_query("select itemname from user as U join \ inventory as I on U.userid=I.userid join \ item as D on I.itemid=D.itemid \ where I.userid=%s" % (userid)) if re.match (r'drop', userinput ): thing_to_drop = userinput.replace('drop ', '') elif re.match (r'put down', userinput ): thing_to_drop = userinput.replace('put down ', '') if thing_to_drop in inventory: print ("You drop the %s." % thing_to_drop ) # find the id of the item... thing_to_drop_id = db("select itemid from item where itemname = '%s'" % thing_to_drop ) # delete the item from our inventory... db("delete from inventory where userid = %s and itemid = %s" % (userid, thing_to_drop_id) ) current_room = db("select location from user where userid=%s" % ( userid )) db("update item set currentroom = %s where itemid = %s" % (current_room, thing_to_drop_id) ) else: print ("You can't do that!") def open (): #-------------------------------------------------------- current_room = db("select location from user where userid=%s" % ( userid )) if current_room == "1": # you must be in the appartment, so you must be opening the trophy cabinet # TODO: do you have the key? time.sleep(0.3) print ("You
# pylint: disable=missing-function-docstring """Tests for '_continuous.py' file""" import numpy as np from numpy.testing import assert_array_equal, assert_array_almost_equal import scipy.stats.distributions as distrs from scipy.stats.kde import gaussian_kde from scipy.integrate import quad import pytest from randomvars._continuous import Cont from randomvars.tests.commontests import ( DECIMAL, _test_equal_rand, _test_equal_seq, _test_from_rv_rand, _test_from_sample_rand, _test_input_coercion, _test_log_fun, _test_one_value_input, _test_rvs_method, declass, h, ) from randomvars.options import config DISTRIBUTIONS_COMMON = { "beta": distrs.beta(a=10, b=20), "chi_sq": distrs.chi2(df=10), "expon": distrs.expon(), "f": distrs.f(dfn=20, dfd=20), "gamma": distrs.gamma(a=10), "laplace": distrs.laplace(), "lognorm": distrs.lognorm(s=0.5), "norm": distrs.norm(), "norm2": distrs.norm(loc=10), "norm3": distrs.norm(scale=0.1), "norm4": distrs.norm(scale=10), "norm5": distrs.norm(loc=10, scale=0.1), "t": distrs.t(df=10), "uniform": distrs.uniform(), "uniform2": distrs.uniform(loc=10, scale=0.1), "weibull_max": distrs.weibull_max(c=2), "weibull_min": distrs.weibull_min(c=2), } DISTRIBUTIONS_INF_DENSITY = { "inf_beta_both": distrs.beta(a=0.4, b=0.6), "inf_beta_left": distrs.beta(a=0.5, b=2), "inf_beta_right": distrs.beta(a=2, b=0.5), "inf_chi_sq": distrs.chi2(df=1), "inf_weibull_max": distrs.weibull_max(c=0.5), "inf_weibull_min": distrs.weibull_min(c=0.5), } DISTRIBUTIONS_HEAVY_TAILS = { "heavy_cauchy": distrs.cauchy(), "heavy_lognorm": distrs.lognorm(s=1), "heavy_t": distrs.t(df=2), } DISTRIBUTIONS = { **DISTRIBUTIONS_COMMON, **DISTRIBUTIONS_HEAVY_TAILS, **DISTRIBUTIONS_INF_DENSITY, } def augment_grid(x, n_inner_points): test_arr = [ np.linspace(x[i], x[i + 1], n_inner_points + 1, endpoint=False) for i in np.arange(len(x) - 1) ] test_arr.append([x[-1]]) return np.concatenate(test_arr) def from_sample_cdf_max_error(x): rv = Cont.from_sample(x) density = config.estimator_cont(x) x_grid = augment_grid(rv.x, 10) # Efficient way of computing `quad(density, -np.inf, x_grid)` x_grid_ext = np.concatenate([[-np.inf], x_grid]) cdf_intervals = np.array( [ quad(density, x_l, x_r)[0] for x_l, x_r in zip(x_grid_ext[:-1], x_grid_ext[1:]) ] ) cdf_grid = np.cumsum(cdf_intervals) err = cdf_grid - rv.cdf(x_grid) return np.max(np.abs(err)) def circle_fun(x, low, high): x = np.array(x) center = 0.5 * (high + low) radius = 0.5 * (high - low) res = np.zeros_like(x) center_dist = np.abs(x - center) is_in = center_dist <= radius res[is_in] = np.sqrt(radius ** 2 - center_dist[is_in] ** 2) return res def make_circ_density(intervals): """Construct circular density Density looks like half-circles with diameters lying in elements of `intervals`. Total integral is equal to 1. Parameters ---------- intervals : iterable with elements being 2-element iterables Iterable of intervals with non-zero density. Returns ------- density : callable Function which returns density values. """ def density(x): res = np.zeros_like(x) tot_integral = 0 for low, high in intervals: res += circle_fun(x, low, high) # There is only half of circle tot_integral += np.pi * (high - low) ** 2 / 8 return res / tot_integral return density class TestCont: """Regression tests for `Cont` class""" def test_init_errors(self): def check_one_input(def_args, var): with pytest.raises(TypeError, match=f"`{var}`.*numpy array"): def_args[var] = {"a": None} Cont(**def_args) with pytest.raises(TypeError, match=f"`{var}`.*float"): def_args[var] = ["a", "a"] Cont(**def_args) with pytest.raises(TypeError, match=f"`{var}`.*finite values"): def_args[var] = [0, np.nan] Cont(**def_args) with pytest.raises(TypeError, match=f"`{var}`.*finite values"): def_args[var] = [0, np.inf] Cont(**def_args) with pytest.raises(ValueError, match=f"`{var}`.*1d array"): def_args[var] = [[0, 1]] Cont(**def_args) check_one_input({"y": [1, 1]}, "x") check_one_input({"x": [0, 1]}, "y") with pytest.raises(ValueError, match="[Ll]engths.*match"): Cont([0, 1], [1, 1, 1]) with pytest.raises(ValueError, match="two"): Cont([1], [1]) with pytest.warns(UserWarning, match="`x`.*not sorted.*`x` and `y`"): rv = Cont([1, 0], [0, 2]) rv_ref = Cont([0, 1], [2, 0]) _test_equal_rand(rv, rv_ref) with pytest.raises(ValueError, match="`y`.*negative"): Cont([0, 1], [1, -1]) with pytest.raises(ValueError, match="`y`.*no positive"): Cont([0, 1], [0, 0]) def test_init(self): x_ref = np.array([0, 1, 2]) y_ref = np.array([0, 1, 0]) rv_ref = Cont(x_ref, y_ref) # Simple case with non-numpy input rv_1 = Cont(x=x_ref.tolist(), y=y_ref.tolist()) _test_equal_rand(rv_1, rv_ref) # Check if `y` is normalized rv_2 = Cont(x=x_ref, y=10 * y_ref) _test_equal_rand(rv_2, rv_ref) # Check if `x` and `y` are rearranged if not sorted with pytest.warns(UserWarning, match="`x`.*not sorted"): rv_3 = Cont(x=x_ref[[1, 0, 2]], y=y_ref[[1, 0, 2]]) _test_equal_rand(rv_3, rv_ref) # Check if duplicated values are removed from `x` with pytest.warns(UserWarning, match="duplicated"): # First pair of xy-grid is taken among duplicates rv_4 = Cont(x=x_ref[[0, 1, 1, 2]], y=y_ref[[0, 1, 2, 2]]) _test_equal_rand(rv_4, rv_ref) def test_str(self): rv = Cont([0, 2, 4], [0, 1, 0]) assert str(rv) == "Continuous RV with 2 intervals (support: [0.0, 4.0])" # Uses singular noun with one interval rv = Cont([0, 1], [1, 1]) assert str(rv) == "Continuous RV with 1 interval (support: [0.0, 1.0])" def test_properties(self): x = np.arange(11) y = np.repeat(0.1, 11) rv = Cont(x, y) assert list(rv.params.keys()) == ["x", "y"] assert_array_equal(rv.params["x"], x) assert_array_equal(rv.params["y"], y) assert_array_equal(rv.x, x) assert_array_equal(rv.y, y) assert rv.a == 0.0 assert rv.b == 10.0 def test_support(self): rv = Cont([0.5, 1.5, 4.5], [0, 0.5, 0]) assert rv.support() == (0.5, 4.5) def test_compress(self): # Zero tails ## Left tail _test_equal_rand( Cont([0, 1, 2, 3], [0, 0, 0, 2]).compress(), Cont([2, 3], [0, 2]) ) _test_equal_rand( Cont([0, 1, 2, 3], [0, 0, 1, 0]).compress(), Cont([1, 2, 3], [0, 1, 0]) ) ## Right tail _test_equal_rand( Cont([0, 1, 2, 3], [2, 0, 0, 0]).compress(), Cont([0, 1], [2, 0]) ) _test_equal_rand( Cont([0, 1, 2, 3], [0, 1, 0, 0]).compress(), Cont([0, 1, 2], [0, 1, 0]) ) ## Both tails _test_equal_rand( Cont([0, 1, 2, 3, 4], [0, 0, 1, 0, 0]).compress(), Cont([1, 2, 3], [0, 1, 0]), ) # Extra linearity ## Non-zero slope _test_equal_rand( Cont([0, 1, 2, 3, 4], [0.5, 0.25, 0, 0.25, 0.5]).compress(), Cont([0, 2, 4], [0.5, 0, 0.5]), ) ## Zero slope, non-zero y _test_equal_rand( Cont([0, 1, 2], [0.5, 0.5, 0.5]).compress(), Cont([0, 2], [0.5, 0.5]) ) ## Zero slope, zero y, outside of tails _test_equal_rand( Cont([0, 1, 2, 3, 4], [1, 0, 0, 0, 1]).compress(), Cont([0, 1, 3, 4], [1, 0, 0, 1]), ) # All features _test_equal_rand( Cont(np.arange(14), [0, 0, 0, 1, 2, 2, 2, 1, 0, 0, 0, 1, 0, 0]).compress(), Cont([2, 4, 6, 8, 10, 11, 12], [0, 2, 2, 0, 0, 1, 0]), ) # If nothing to compress, self should be returned rv = Cont([0, 1], [1, 1]) assert rv.compress() is rv def test_ground(self): w = config.small_width # Basic usage rv = Cont([0, 1], [1, 1]) _test_equal_rand( rv.ground(), Cont([-w, 0, w, 1 - w, 1, 1 + w], [0, 0.5, 1, 1, 0.5, 0]) ) # Argument `direction` _test_equal_rand( rv.ground(direction="both"), Cont([-w, 0, w, 1 - w, 1, 1 + w], [0, 0.5, 1, 1, 0.5, 0]), ) _test_equal_rand( rv.ground(direction="left"), Cont([-w, 0, w, 1], [0, 0.5, 1, 1]) ) _test_equal_rand( rv.ground(direction="right"), Cont([0, 1 - w, 1, 1 + w], [1, 1, 0.5, 0]) ) _test_equal_rand(rv.ground(direction="none"), rv) # Argument `w` w2 = 0.1 _test_equal_rand( rv.ground(w=w2, direction="both"), Cont([-w2, 0, w2, 1 - w2, 1, 1 + w2], [0, 0.5, 1, 1, 0.5, 0]), ) # Close neighbors rv2 = Cont([0, 0.25 * w, 0.5, 1 - 0.1 * w, 1], [1, 1, 1, 1, 1]) rv2_grounded = rv2.ground(direction="both") ## Check that only outer points were added assert_array_equal(rv2_grounded.x[1:-1], rv2.x) ## Check that grounded actually happend assert_array_equal(rv2_grounded.y[[0, -1]], 0.0) ## Check that non-edge x-values havae same y-values assert_array_equal(rv2_grounded.pdf(rv2.x[1:-1]), rv2.pdf(rv2.x[1:-1])) def test_ground_options(self): rv = Cont([0, 1], [1, 1]) with config.context({"small_width": 0.1}): w = config.small_width _test_equal_rand( rv.ground(), Cont([-w, 0, w, 1 - w, 1, 1 + w], [0, 0.5, 1, 1, 0.5, 0]) ) def test_ground_errors(self): rv = Cont([0, 1], [1, 1]) with pytest.raises(ValueError, match="one of"): rv.ground(direction="aaa") def test__coeffs_by_ind(self): # All coefficients are returned if no `ind` is specified rv = Cont([0, 1, 2], [0, 1, 0]) inter, slope = rv._coeffs_by_ind() assert_array_equal(inter, [0, 2]) assert_array_equal(slope, [1, -1]) def test__grid_by_ind(self): # All grid elements are returned if no `ind` is specified rv = Cont([0, 1, 2], [0, 1, 0]) x_out, y_out, p_out = rv._grid_by_ind() x_ref, y_ref = rv.x, rv.y assert_array_equal(x_out, x_ref) assert_array_equal(y_out, y_ref) def test_pdf_coeffs(self): rv = Cont([0, 1, 2], [0, 1, 0]) x = np.array([-1, 0, 0.5, 1, 1.5, 2, 2.5]) with pytest.raises(ValueError, match="one of"): rv.pdf_coeffs(x, side="a") _test_equal_seq( rv.pdf_coeffs(x), (np.array([0, 0, 0, 2, 2, 2, 0]), np.array([0, 1, 1, -1, -1, -1, 0])), ) _test_equal_seq( rv.pdf_coeffs(x, side="left"), (np.array([0, 0, 0, 0, 2, 2, 0]), np.array([0, 1, 1, 1, -1, -1, 0])), ) _test_equal_seq( rv.pdf_coeffs(np.array([-np.inf, np.nan, np.inf])), (np.array([0, np.nan, 0]), np.array([0, np.nan, 0])), ) def test_from_rv_basic(self): uniform = distrs.uniform norm = distrs.norm # Basic usage rv_unif = Cont.from_rv(uniform) rv_unif_test = Cont(x=[0, 1], y=[1, 1]) _test_equal_rand(rv_unif, rv_unif_test, decimal=DECIMAL) # Objects of `Rand` class should be `convert()`ed _test_from_rv_rand(cls=Cont, to_class="Cont") # Forced support edges rv_right = Cont.from_rv(uniform, supp=(0.5, None)) rv_right_test = Cont([0.5, 1], [2, 2]) _test_equal_rand(rv_right, rv_right_test, decimal=DECIMAL) rv_left = Cont.from_rv(uniform, supp=(None, 0.5)) rv_left_test = Cont([0, 0.5], [2, 2]) _test_equal_rand(rv_left, rv_left_test, decimal=DECIMAL) rv_mid = Cont.from_rv(uniform, supp=(0.25, 0.75)) rv_mid_test = Cont([0.25, 0.75], [2, 2]) _test_equal_rand(rv_mid, rv_mid_test, decimal=DECIMAL) def test_from_rv_errors(self): # Absence of either `cdf` or `ppf` method should result intro error class Tmp: pass tmp1 = Tmp()
__init__(SimTK::Mat<(3,3)> self, double const & e0, double const & e1, double const & e2, double const & e3, double const & e4, double const & e5, double const & e6, double const & e7, double const & e8, double const & e9, double const & e10, double const & e11, double const & e12, double const & e13, double const & e14, double const & e15) -> Mat33 Parameters ---------- e0: double const & e1: double const & e2: double const & e3: double const & e4: double const & e5: double const & e6: double const & e7: double const & e8: double const & e9: double const & e10: double const & e11: double const & e12: double const & e13: double const & e14: double const & e15: double const & """ this = _simbody.new_Mat33(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def setToNaN(self): """ setToNaN(Mat33 self) Parameters ---------- self: SimTK::Mat< 3,3 > * """ return _simbody.Mat33_setToNaN(self) def setToZero(self): """ setToZero(Mat33 self) Parameters ---------- self: SimTK::Mat< 3,3 > * """ return _simbody.Mat33_setToZero(self) def isNaN(self): """ isNaN(Mat33 self) -> bool Parameters ---------- self: SimTK::Mat< 3,3 > const * """ return _simbody.Mat33_isNaN(self) def isInf(self): """ isInf(Mat33 self) -> bool Parameters ---------- self: SimTK::Mat< 3,3 > const * """ return _simbody.Mat33_isInf(self) def isFinite(self): """ isFinite(Mat33 self) -> bool Parameters ---------- self: SimTK::Mat< 3,3 > const * """ return _simbody.Mat33_isFinite(self) def getDefaultTolerance(): """getDefaultTolerance() -> double""" return _simbody.Mat33_getDefaultTolerance() getDefaultTolerance = staticmethod(getDefaultTolerance) def isNumericallyEqual(self, *args): """ isNumericallyEqual(Mat33 self, double const & e, double tol) -> bool Parameters ---------- e: double const & tol: double isNumericallyEqual(Mat33 self, double const & e) -> bool Parameters ---------- e: double const & """ return _simbody.Mat33_isNumericallyEqual(self, *args) def isNumericallySymmetric(self, *args): """ isNumericallySymmetric(Mat33 self, double tol) -> bool Parameters ---------- tol: double isNumericallySymmetric(Mat33 self) -> bool Parameters ---------- self: SimTK::Mat< 3,3 > const * """ return _simbody.Mat33_isNumericallySymmetric(self, *args) def isExactlySymmetric(self): """ isExactlySymmetric(Mat33 self) -> bool Parameters ---------- self: SimTK::Mat< 3,3 > const * """ return _simbody.Mat33_isExactlySymmetric(self) def toString(self): """ toString(Mat33 self) -> std::string Parameters ---------- self: SimTK::Mat< 3,3 > const * """ return _simbody.Mat33_toString(self) def get(self, i, j): """ get(Mat33 self, int i, int j) -> double const & Parameters ---------- i: int j: int """ return _simbody.Mat33_get(self, i, j) def set(self, i, j, value): """ set(Mat33 self, int i, int j, double const & value) Parameters ---------- i: int j: int value: double const & """ return _simbody.Mat33_set(self, i, j, value) __swig_destroy__ = _simbody.delete_Mat33 __del__ = lambda self: None Mat33_swigregister = _simbody.Mat33_swigregister Mat33_swigregister(Mat33) def Mat33_size(): """Mat33_size() -> int""" return _simbody.Mat33_size() def Mat33_nrow(): """Mat33_nrow() -> int""" return _simbody.Mat33_nrow() def Mat33_ncol(): """Mat33_ncol() -> int""" return _simbody.Mat33_ncol() def Mat33_getDefaultTolerance(): """Mat33_getDefaultTolerance() -> double""" return _simbody.Mat33_getDefaultTolerance() class CoordinateAxis(_object): """Proxy of C++ SimTK::CoordinateAxis class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CoordinateAxis, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CoordinateAxis, name) __repr__ = _swig_repr def __init__(self, i): """ __init__(SimTK::CoordinateAxis self, int i) -> CoordinateAxis Parameters ---------- i: int """ this = _simbody.new_CoordinateAxis(i) try: self.this.append(this) except __builtin__.Exception: self.this = this def getNextAxis(self): """ getNextAxis(CoordinateAxis self) -> CoordinateAxis Parameters ---------- self: SimTK::CoordinateAxis const * """ return _simbody.CoordinateAxis_getNextAxis(self) def getPreviousAxis(self): """ getPreviousAxis(CoordinateAxis self) -> CoordinateAxis Parameters ---------- self: SimTK::CoordinateAxis const * """ return _simbody.CoordinateAxis_getPreviousAxis(self) def getThirdAxis(self, axis2): """ getThirdAxis(CoordinateAxis self, CoordinateAxis axis2) -> CoordinateAxis Parameters ---------- axis2: SimTK::CoordinateAxis const & """ return _simbody.CoordinateAxis_getThirdAxis(self, axis2) def isXAxis(self): """ isXAxis(CoordinateAxis self) -> bool Parameters ---------- self: SimTK::CoordinateAxis const * """ return _simbody.CoordinateAxis_isXAxis(self) def isYAxis(self): """ isYAxis(CoordinateAxis self) -> bool Parameters ---------- self: SimTK::CoordinateAxis const * """ return _simbody.CoordinateAxis_isYAxis(self) def isZAxis(self): """ isZAxis(CoordinateAxis self) -> bool Parameters ---------- self: SimTK::CoordinateAxis const * """ return _simbody.CoordinateAxis_isZAxis(self) def isNextAxis(self, axis2): """ isNextAxis(CoordinateAxis self, CoordinateAxis axis2) -> bool Parameters ---------- axis2: SimTK::CoordinateAxis const & """ return _simbody.CoordinateAxis_isNextAxis(self, axis2) def isPreviousAxis(self, axis2): """ isPreviousAxis(CoordinateAxis self, CoordinateAxis axis2) -> bool Parameters ---------- axis2: SimTK::CoordinateAxis const & """ return _simbody.CoordinateAxis_isPreviousAxis(self, axis2) def isSameAxis(self, axis2): """ isSameAxis(CoordinateAxis self, CoordinateAxis axis2) -> bool Parameters ---------- axis2: SimTK::CoordinateAxis const & """ return _simbody.CoordinateAxis_isSameAxis(self, axis2) def areAllSameAxes(self, axis2, axis3): """ areAllSameAxes(CoordinateAxis self, CoordinateAxis axis2, CoordinateAxis axis3) -> bool Parameters ---------- axis2: SimTK::CoordinateAxis const & axis3: SimTK::CoordinateAxis const & """ return _simbody.CoordinateAxis_areAllSameAxes(self, axis2, axis3) def isDifferentAxis(self, axis2): """ isDifferentAxis(CoordinateAxis self, CoordinateAxis axis2) -> bool Parameters ---------- axis2: SimTK::CoordinateAxis const & """ return _simbody.CoordinateAxis_isDifferentAxis(self, axis2) def areAllDifferentAxes(self, axis2, axis3): """ areAllDifferentAxes(CoordinateAxis self, CoordinateAxis axis2, CoordinateAxis axis3) -> bool Parameters ---------- axis2: SimTK::CoordinateAxis const & axis3: SimTK::CoordinateAxis const & """ return _simbody.CoordinateAxis_areAllDifferentAxes(self, axis2, axis3) def isForwardCyclical(self, axis2): """ isForwardCyclical(CoordinateAxis self, CoordinateAxis axis2) -> bool Parameters ---------- axis2: SimTK::CoordinateAxis const & """ return _simbody.CoordinateAxis_isForwardCyclical(self, axis2) def isReverseCyclical(self, axis2): """ isReverseCyclical(CoordinateAxis self, CoordinateAxis axis2) -> bool Parameters ---------- axis2: SimTK::CoordinateAxis const & """ return _simbody.CoordinateAxis_isReverseCyclical(self, axis2) def dotProduct(self, axis2): """ dotProduct(CoordinateAxis self, CoordinateAxis axis2) -> int Parameters ---------- axis2: SimTK::CoordinateAxis const & """ return _simbody.CoordinateAxis_dotProduct(self, axis2) def crossProductSign(self, axis2): """ crossProductSign(CoordinateAxis self, CoordinateAxis axis2) -> int Parameters ---------- axis2: SimTK::CoordinateAxis const & """ return _simbody.CoordinateAxis_crossProductSign(self, axis2) def crossProductAxis(self, axis2): """ crossProductAxis(CoordinateAxis self, CoordinateAxis axis2) -> CoordinateAxis Parameters ---------- axis2: SimTK::CoordinateAxis const & """ return _simbody.CoordinateAxis_crossProductAxis(self, axis2) def crossProduct(self, axis2, sign): """ crossProduct(CoordinateAxis self, CoordinateAxis axis2, int & sign) -> CoordinateAxis Parameters ---------- axis2: SimTK::CoordinateAxis const & sign: int & """ return _simbody.CoordinateAxis_crossProduct(self, axis2, sign) def getCoordinateAxis(i): """ getCoordinateAxis(int i) -> CoordinateAxis Parameters ---------- i: int """ return _simbody.CoordinateAxis_getCoordinateAxis(i) getCoordinateAxis = staticmethod(getCoordinateAxis) def isIndexInRange(i): """ isIndexInRange(int i) -> bool Parameters ---------- i: int """ return _simbody.CoordinateAxis_isIndexInRange(i) isIndexInRange = staticmethod(isIndexInRange) __swig_destroy__ = _simbody.delete_CoordinateAxis __del__ = lambda self: None CoordinateAxis_swigregister = _simbody.CoordinateAxis_swigregister CoordinateAxis_swigregister(CoordinateAxis) def CoordinateAxis_getCoordinateAxis(i): """ CoordinateAxis_getCoordinateAxis(int i) -> CoordinateAxis Parameters ---------- i: int """ return _simbody.CoordinateAxis_getCoordinateAxis(i) def CoordinateAxis_isIndexInRange(i): """ CoordinateAxis_isIndexInRange(int i) -> bool Parameters ---------- i: int """ return _simbody.CoordinateAxis_isIndexInRange(i) def __eq__(a1, a2): """ __eq__(CoordinateAxis a1, CoordinateAxis a2) -> bool Parameters ---------- a1: SimTK::CoordinateAxis const & a2: SimTK::CoordinateAxis const & """ return _simbody.__eq__(a1, a2) def __ne__(a1, a2): """ __ne__(CoordinateAxis a1, CoordinateAxis a2) -> bool Parameters ---------- a1: SimTK::CoordinateAxis const & a2: SimTK::CoordinateAxis const & """ return _simbody.__ne__(a1, a2) class CoordinateDirection(_object): """Proxy of C++ SimTK::CoordinateDirection class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CoordinateDirection, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CoordinateDirection, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(SimTK::CoordinateDirection self, CoordinateAxis axis) -> CoordinateDirection Parameters ---------- axis: SimTK::CoordinateAxis const & __init__(SimTK::CoordinateDirection self, CoordinateAxis axis, int direction) -> CoordinateDirection Parameters ---------- axis: SimTK::CoordinateAxis const & direction: int """ this = _simbody.new_CoordinateDirection(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def getAxis(self): """ getAxis(CoordinateDirection self) -> CoordinateAxis Parameters ---------- self: SimTK::CoordinateDirection const * """ return _simbody.CoordinateDirection_getAxis(self) def getDirection(self): """ getDirection(CoordinateDirection self) -> int Parameters ---------- self: SimTK::CoordinateDirection const * """ return _simbody.CoordinateDirection_getDirection(self) def hasSameAxis(self, dir2): """ hasSameAxis(CoordinateDirection self, CoordinateDirection dir2) -> bool Parameters ---------- dir2: SimTK::CoordinateDirection const & """ return _simbody.CoordinateDirection_hasSameAxis(self, dir2) def isSameAxisAndDirection(self, dir2): """ isSameAxisAndDirection(CoordinateDirection self, CoordinateDirection dir2) -> bool Parameters ---------- dir2: SimTK::CoordinateDirection const & """ return _simbody.CoordinateDirection_isSameAxisAndDirection(self, dir2) def dotProduct(self, dir2): """ dotProduct(CoordinateDirection self, CoordinateDirection dir2) -> int Parameters ---------- dir2: SimTK::CoordinateDirection const & """ return _simbody.CoordinateDirection_dotProduct(self, dir2) def crossProductSign(self, dir2): """ crossProductSign(CoordinateDirection self, CoordinateDirection dir2) -> int Parameters ---------- dir2: SimTK::CoordinateDirection const & """ return _simbody.CoordinateDirection_crossProductSign(self, dir2) def crossProductAxis(self, dir2): """ crossProductAxis(CoordinateDirection self, CoordinateDirection dir2) -> CoordinateAxis Parameters ---------- dir2: SimTK::CoordinateDirection const & """ return _simbody.CoordinateDirection_crossProductAxis(self, dir2) def crossProduct(self, dir2, sign): """ crossProduct(CoordinateDirection self, CoordinateDirection dir2, int & sign) -> CoordinateAxis Parameters ---------- dir2: SimTK::CoordinateDirection const & sign: int & """ return _simbody.CoordinateDirection_crossProduct(self, dir2, sign) __swig_destroy__ = _simbody.delete_CoordinateDirection __del__ = lambda self: None CoordinateDirection_swigregister = _simbody.CoordinateDirection_swigregister CoordinateDirection_swigregister(CoordinateDirection) class UnitVec3(Vec3): """Proxy of C++ SimTK::UnitVec<(double,1)> class.""" __swig_setmethods__ = {} for _s in [Vec3]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, UnitVec3, name, value) __swig_getmethods__ = {} for _s in [Vec3]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, UnitVec3, name) __repr__ = _swig_repr def asVec3(self): """ asVec3(UnitVec3 self) -> Vec3 Parameters ---------- self: SimTK::UnitVec< double,1
= s1.replace('"', '\\"') if s1.find('\n') == -1: return '"%s"' % s1 else: return '"""%s"""' % s1 def get_all_text_(node): if node.text is not None: text = node.text else: text = '' for child in node: if child.tail is not None: text += child.tail return text def find_attr_value_(attr_name, node): attrs = node.attrib attr_parts = attr_name.split(':') value = None if len(attr_parts) == 1: value = attrs.get(attr_name) elif len(attr_parts) == 2: prefix, name = attr_parts namespace = node.nsmap.get(prefix) if namespace is not None: value = attrs.get('{%s}%s' % (namespace, name, )) return value class GDSParseError(Exception): pass def raise_parse_error(node, msg): msg = '%s (element %s/line %d)' % (msg, node.tag, node.sourceline, ) raise GDSParseError(msg) class MixedContainer: # Constants for category: CategoryNone = 0 CategoryText = 1 CategorySimple = 2 CategoryComplex = 3 # Constants for content_type: TypeNone = 0 TypeText = 1 TypeString = 2 TypeInteger = 3 TypeFloat = 4 TypeDecimal = 5 TypeDouble = 6 TypeBoolean = 7 TypeBase64 = 8 def __init__(self, category, content_type, name, value): self.category = category self.content_type = content_type self.name = name self.value = value def getCategory(self): return self.category def getContenttype(self, content_type): return self.content_type def getValue(self): return self.value def getName(self): return self.name def export(self, outfile, level, name, namespace, pretty_print=True): if self.category == MixedContainer.CategoryText: # Prevent exporting empty content as empty lines. if self.value.strip(): outfile.write(self.value) elif self.category == MixedContainer.CategorySimple: self.exportSimple(outfile, level, name) else: # category == MixedContainer.CategoryComplex self.value.export(outfile, level, namespace, name, pretty_print) def exportSimple(self, outfile, level, name): if self.content_type == MixedContainer.TypeString: outfile.write('<%s>%s</%s>' % ( self.name, self.value, self.name)) elif self.content_type == MixedContainer.TypeInteger or \ self.content_type == MixedContainer.TypeBoolean: outfile.write('<%s>%d</%s>' % ( self.name, self.value, self.name)) elif self.content_type == MixedContainer.TypeFloat or \ self.content_type == MixedContainer.TypeDecimal: outfile.write('<%s>%f</%s>' % ( self.name, self.value, self.name)) elif self.content_type == MixedContainer.TypeDouble: outfile.write('<%s>%g</%s>' % ( self.name, self.value, self.name)) elif self.content_type == MixedContainer.TypeBase64: outfile.write('<%s>%s</%s>' % ( self.name, base64.b64encode(self.value), self.name)) def to_etree(self, element): if self.category == MixedContainer.CategoryText: # Prevent exporting empty content as empty lines. if self.value.strip(): if len(element) > 0: if element[-1].tail is None: element[-1].tail = self.value else: element[-1].tail += self.value else: if element.text is None: element.text = self.value else: element.text += self.value elif self.category == MixedContainer.CategorySimple: subelement = etree_.SubElement(element, '%s' % self.name) subelement.text = self.to_etree_simple() else: # category == MixedContainer.CategoryComplex self.value.to_etree(element) def to_etree_simple(self): if self.content_type == MixedContainer.TypeString: text = self.value elif (self.content_type == MixedContainer.TypeInteger or self.content_type == MixedContainer.TypeBoolean): text = '%d' % self.value elif (self.content_type == MixedContainer.TypeFloat or self.content_type == MixedContainer.TypeDecimal): text = '%f' % self.value elif self.content_type == MixedContainer.TypeDouble: text = '%g' % self.value elif self.content_type == MixedContainer.TypeBase64: text = '%s' % base64.b64encode(self.value) return text def exportLiteral(self, outfile, level, name): if self.category == MixedContainer.CategoryText: showIndent(outfile, level) outfile.write( 'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % ( self.category, self.content_type, self.name, self.value)) elif self.category == MixedContainer.CategorySimple: showIndent(outfile, level) outfile.write( 'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % ( self.category, self.content_type, self.name, self.value)) else: # category == MixedContainer.CategoryComplex showIndent(outfile, level) outfile.write( 'model_.MixedContainer(%d, %d, "%s",\n' % ( self.category, self.content_type, self.name,)) self.value.exportLiteral(outfile, level + 1) showIndent(outfile, level) outfile.write(')\n') class MemberSpec_(object): def __init__(self, name='', data_type='', container=0): self.name = name self.data_type = data_type self.container = container def set_name(self, name): self.name = name def get_name(self): return self.name def set_data_type(self, data_type): self.data_type = data_type def get_data_type_chain(self): return self.data_type def get_data_type(self): if isinstance(self.data_type, list): if len(self.data_type) > 0: return self.data_type[-1] else: return 'xs:string' else: return self.data_type def set_container(self, container): self.container = container def get_container(self): return self.container def _cast(typ, value): if typ is None or value is None: return value return typ(value) # # Data representation classes. # class qcMLType(GeneratedsSuper): """The type of the root elementVersion number of qcML document. Pattern is \d+\.\d+\.\d+""" subclass = None superclass = None def __init__(self, version=None, runQuality=None, setQuality=None, cvList=None, embeddedStylesheetList=None): self.original_tagname_ = None self.version = _cast(None, version) if runQuality is None: self.runQuality = [] else: self.runQuality = runQuality if setQuality is None: self.setQuality = [] else: self.setQuality = setQuality self.cvList = cvList self.embeddedStylesheetList = embeddedStylesheetList def factory(*args_, **kwargs_): if qcMLType.subclass: return qcMLType.subclass(*args_, **kwargs_) else: return qcMLType(*args_, **kwargs_) factory = staticmethod(factory) def get_runQuality(self): return self.runQuality def set_runQuality(self, runQuality): self.runQuality = runQuality def add_runQuality(self, value): self.runQuality.append(value) def insert_runQuality_at(self, index, value): self.runQuality.insert(index, value) def replace_runQuality_at(self, index, value): self.runQuality[index] = value def get_setQuality(self): return self.setQuality def set_setQuality(self, setQuality): self.setQuality = setQuality def add_setQuality(self, value): self.setQuality.append(value) def insert_setQuality_at(self, index, value): self.setQuality.insert(index, value) def replace_setQuality_at(self, index, value): self.setQuality[index] = value def get_cvList(self): return self.cvList def set_cvList(self, cvList): self.cvList = cvList def get_embeddedStylesheetList(self): return self.embeddedStylesheetList def set_embeddedStylesheetList(self, embeddedStylesheetList): self.embeddedStylesheetList = embeddedStylesheetList def get_version(self): return self.version def set_version(self, version): self.version = version def hasContent_(self): if ( self.runQuality or self.setQuality or self.cvList is not None or self.embeddedStylesheetList is not None ): return True else: return False def export(self, outfile, level, namespace_='', name_='qcMLType', namespacedef_='', pretty_print=True): if pretty_print: eol_ = '\n' else: eol_ = '' if self.original_tagname_ is not None: name_ = self.original_tagname_ showIndent(outfile, level, pretty_print) outfile.write('<?xml-stylesheet type="text/xml" href="#to_html"?>%s' % (eol_, )) outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) already_processed = set() self.exportAttributes(outfile, level, already_processed, namespace_, name_='qcMLType') if self.hasContent_(): outfile.write('>%s' % (eol_, )) self.exportChildren(outfile, level + 1, namespace_='', name_='qcMLType', pretty_print=pretty_print) showIndent(outfile, level, pretty_print) outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) else: outfile.write('/>%s' % (eol_, )) def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='qcMLType'): if self.version is not None and 'version' not in already_processed: already_processed.add('version') outfile.write(' version=%s' % (self.gds_format_string(quote_attrib(self.version), input_name='version'), )) def exportChildren(self, outfile, level, namespace_='', name_='qcMLType', fromsubclass_=False, pretty_print=True): if pretty_print: eol_ = '\n' else: eol_ = '' for runQuality_ in self.runQuality: runQuality_.export(outfile, level, namespace_, name_='runQuality', pretty_print=pretty_print) for setQuality_ in self.setQuality: setQuality_.export(outfile, level, namespace_, name_='setQuality', pretty_print=pretty_print) if self.cvList is not None: self.cvList.export(outfile, level, namespace_, name_='cvList', pretty_print=pretty_print) if self.embeddedStylesheetList is not None: self.embeddedStylesheetList.export(outfile, level, namespace_, name_='embeddedStylesheetList', pretty_print=pretty_print) def build(self, node): already_processed = set() self.buildAttributes(node, node.attrib, already_processed) for child in node: nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] self.buildChildren(child, node, nodeName_) return self def buildAttributes(self, node, attrs, already_processed): value = find_attr_value_('version', node) if value is not None and 'version' not in already_processed: already_processed.add('version') self.version = value def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): if nodeName_ == 'runQuality': obj_ = RunQualityAssessmentType.factory() obj_.build(child_) self.runQuality.append(obj_) obj_.original_tagname_ = 'runQuality' elif nodeName_ == 'setQuality': obj_ = SetQualityAssessmentType.factory() obj_.build(child_) self.setQuality.append(obj_) obj_.original_tagname_ = 'setQuality' elif nodeName_ == 'cvList': obj_ = CVListType.factory() obj_.build(child_) self.cvList = obj_ obj_.original_tagname_ = 'cvList' elif nodeName_ == 'embeddedStylesheetList': obj_ = embeddedStylesheetListType.factory() obj_.build(child_) self.embeddedStylesheetList = obj_ obj_.original_tagname_ = 'embeddedStylesheetList' # end class qcMLType class QualityAssessmentType(GeneratedsSuper): """The abstract base type for qualityParameter and attachment container""" subclass = None superclass = None def __init__(self, metaDataParameter=None, qualityParameter=None, attachment=None, extensiontype_=None): self.original_tagname_ = None if metaDataParameter is None: self.metaDataParameter = [] else: self.metaDataParameter = metaDataParameter if qualityParameter is None: self.qualityParameter = [] else: self.qualityParameter = qualityParameter if attachment is None: self.attachment = [] else: self.attachment = attachment self.extensiontype_ = extensiontype_ def factory(*args_, **kwargs_): if QualityAssessmentType.subclass: return QualityAssessmentType.subclass(*args_, **kwargs_) else: return QualityAssessmentType(*args_, **kwargs_) factory = staticmethod(factory) def get_metaDataParameter(self): return self.metaDataParameter def set_metaDataParameter(self, metaDataParameter): self.metaDataParameter = metaDataParameter def add_metaDataParameter(self, value): self.metaDataParameter.append(value) def insert_metaDataParameter_at(self, index, value): self.metaDataParameter.insert(index, value) def replace_metaDataParameter_at(self, index, value): self.metaDataParameter[index] = value def get_qualityParameter(self): return self.qualityParameter def set_qualityParameter(self, qualityParameter): self.qualityParameter = qualityParameter def add_qualityParameter(self, value): self.qualityParameter.append(value) def insert_qualityParameter_at(self, index, value): self.qualityParameter.insert(index, value) def replace_qualityParameter_at(self, index, value): self.qualityParameter[index] = value def get_attachment(self): return self.attachment def set_attachment(self, attachment): self.attachment = attachment def add_attachment(self, value): self.attachment.append(value) def insert_attachment_at(self, index, value): self.attachment.insert(index, value) def replace_attachment_at(self, index, value): self.attachment[index] = value def get_extensiontype_(self): return self.extensiontype_ def set_extensiontype_(self, extensiontype_): self.extensiontype_ = extensiontype_ def hasContent_(self): if ( self.metaDataParameter or self.qualityParameter or self.attachment ): return True else: return False def export(self, outfile, level, namespace_='', name_='QualityAssessmentType', namespacedef_='', pretty_print=True): if pretty_print: eol_ = '\n' else: eol_ = '' if self.original_tagname_ is not None: name_ = self.original_tagname_ showIndent(outfile, level, pretty_print) outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) already_processed = set() self.exportAttributes(outfile, level, already_processed, namespace_, name_='QualityAssessmentType') if self.hasContent_(): outfile.write('>%s' % (eol_, )) self.exportChildren(outfile, level + 1, namespace_='', name_='QualityAssessmentType', pretty_print=pretty_print) showIndent(outfile, level, pretty_print) outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) else: outfile.write('/>%s' % (eol_, )) def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='QualityAssessmentType'): if self.extensiontype_ is not None and 'xsi:type' not in already_processed: already_processed.add('xsi:type') outfile.write(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') outfile.write(' xsi:type="%s"' % self.extensiontype_) pass
= self._estimate_error_norm(self.E1, h, scale) # reject step if needed if error_norm > 1: step_rejected = True h_abs *= max(MIN_FACTOR, SAFETY*error_norm**self.error_exponent) continue # calculate solution self._rk_stage(h, 6) # stage 6 y_new = y + self.K[:-1].T @ self.B * h # calculate second error estimate # now use y_new for scale f_new = self.fun(t_new, y_new) self.K[7] = f_new # stage 7 (FSAL) scale = atol + rtol * np.maximum(np.abs(y), np.abs(y_new)) error_norm = self._estimate_error_norm(self.E2, h, scale) # continue as usual if error_norm < 1: step_accepted = True if error_norm == 0.0: factor = MAX_FACTOR else: factor = min(MAX_FACTOR, SAFETY * error_norm**self.error_exponent) if step_rejected: factor = min(1.0, factor) h_abs *= factor else: step_rejected = True h_abs *= max(MIN_FACTOR, SAFETY * error_norm**self.error_exponent) # after sucessful step; as usual self.h_previous = h self.y_old = y self.t = t_new self.y = y_new self.h_abs = h_abs self.f = f_new return True, None def _rk_stage(self, h, i): dy = self.K[:i,:].T @ self.A[i,:i] * h self.K[i] = self.fun(self.t + self.C[i]*h, self.y + dy) def _estimate_error(self, E, h): # pass E instead of K return self.K[:E.size,:].T @ E * h def _estimate_error_norm(self, E, h, scale): # pass E instead of K return norm(self._estimate_error(E, h) / scale) def _dense_output_impl(self): if self.dense_output_order=='high': # default h = self.h_previous K = self.K_extended # calculate the required extra stages for s, (a, c) in enumerate(zip(self.A_extra, self.C_extra), start=self.n_stages+1): dy = K[:s,:].T @ a[:s] * h K[s] = self.fun(self.t_old + c * h, self.y_old + dy) # form Q. Usually: Q = K.T @ self.P # but rksuite recommends to group summations to mitigate roundoff: Q = np.empty((K.shape[1], self.P.shape[1]), dtype=K.dtype) Q[:,0] = K[7,:] # term for t**1 KP = K*self.P[:,1,np.newaxis] # term for t**2 Q[:,1] = ( KP[4] + ((KP[5]+KP[7]) + KP[0]) + ((KP[2]+KP[8]) + KP[9]) + ((KP[3]+KP[10]) + KP[6]) ) KP = K*self.P[:,2,np.newaxis] # term for t**3 Q[:,2] = ( KP[4] + KP[5] + ((KP[2]+KP[8]) + (KP[9]+KP[7]) + KP[0]) + ((KP[3]+KP[10]) + KP[6]) ) KP = K*self.P[:,3,np.newaxis] # term for t**4 Q[:,3] = ( ((KP[3]+KP[7]) + (KP[6]+KP[5]) + KP[4]) + ((KP[9]+KP[8]) + (KP[2]+KP[10]) + KP[0]) ) KP = K*self.P[:,4,np.newaxis] # term for t**5 Q[:,4] = ( (KP[9]+KP[8]) + ((KP[6]+KP[5]) + KP[4]) + ((KP[3]+KP[7]) + (KP[2]+KP[10]) + KP[0]) ) KP = K*self.P[:,5,np.newaxis] # term for t**6 Q[:,5] = ( KP[4] + ((KP[9]+KP[7]) + (KP[6]+KP[5])) + ((KP[3]+KP[8]) + (KP[2]+KP[10]) + KP[0]) ) # this is almost the same as Q usual # Rksuite uses horners rule to evaluate the polynomial. Moreover, # the polynomial definition is different: looking back from the end # of the step instead of forward from the start. # The call is modified accordingly: return HornerDenseOutput(self.t, self.t+h, self.y, Q) else: # self.dense_output_order=='low' # for BS45_i # as usual: Q = self.K.T @ self.Pfree return RkDenseOutput(self.t_old, self.t, self.y_old, Q) class BS45_i(BS45): """As BS45, but with free 4th order interpolant for dense output. Suffix _i for interpolant. The source [1]_ refers to the thesis of Bogacki for a free interpolant, but this could not be found. Instead, the interpolant is constructed following the steps in [3]_. Parameters ---------- fun : callable Right-hand side of the system. The calling signature is ``fun(t, y)``. Here ``t`` is a scalar, and there are two options for the ndarray ``y``: It can either have shape (n,); then ``fun`` must return array_like with shape (n,). Alternatively it can have shape (n, k); then ``fun`` must return an array_like with shape (n, k), i.e., each column corresponds to a single column in ``y``. The choice between the two options is determined by `vectorized` argument (see below). t0 : float Initial time. y0 : array_like, shape (n,) Initial state. t_bound : float Boundary time - the integration won't continue beyond it. It also determines the direction of the integration. first_step : float or None, optional Initial step size. Default is ``None`` which means that the algorithm should choose. max_step : float, optional Maximum allowed step size. Default is np.inf, i.e., the step size is not bounded and determined solely by the solver. rtol, atol : float and array_like, optional Relative and absolute tolerances. The solver keeps the local error estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a relative accuracy (number of correct digits). But if a component of `y` is approximately below `atol`, the error only needs to fall within the same `atol` threshold, and the number of correct digits is not guaranteed. If components of y have different scales, it might be beneficial to set different `atol` values for different components by passing array_like with shape (n,) for `atol`. Default values are 1e-3 for `rtol` and 1e-6 for `atol`. vectorized : bool, optional Whether `fun` is implemented in a vectorized fashion. Default is False. Attributes ---------- n : int Number of equations. status : string Current status of the solver: 'running', 'finished' or 'failed'. t_bound : float Boundary time. direction : float Integration direction: +1 or -1. t : float Current time. y : ndarray Current state. t_old : float Previous time. None if no steps were made yet. step_size : float Size of the last successful step. None if no steps were made yet. nfev : int Number evaluations of the system's right-hand side. njev : int Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian. nlu : int Number of LU decompositions. Is always 0 for this solver. References ---------- .. [1] <NAME>, <NAME>, "An efficient Runge-Kutta (4,5) pair", Computers & Mathematics with Applications, Vol. 32, No. 6, 1996, pp. 15-28, ISSN 0898-1221. https://doi.org/10.1016/0898-1221(96)00141-1 .. [2] RKSUITE: https://www.netlib.org/ode/rksuite/ .. [3] <NAME>, "Runge-Kutta pairs of order 5(4) satisfying only the first column simplifying assumption", Computers & Mathematics with Applications, Vol. 62, No. 2, pp. 770 - 775, 2011. https://doi.org/10.1016/j.camwa.2011.06.002 """ dense_output_order = 'low' class HornerDenseOutput(RkDenseOutput): """use Horner's rule for the evaluation of the polynomials""" def _call_impl(self, t): # scaled time x = (t - self.t_old) / self.h # Horner's rule: y = np.zeros((self.Q.shape[0], x.size), dtype=self.Q.dtype) for q in reversed(self.Q.T): y += q[:,np.newaxis] y *= x # finish: y *= self.h y += self.y_old[:,np.newaxis] # need this `if` to pass scipy's unit tests. I'm not sure why. if t.shape: return y else: return y[:,0] if __name__ == '__main__': """Construction of a free interpolant of the BS45 pair. The approach from "Runge-Kutta pairs of order 5(4) satisfying only the first column simplifying assumption" by <NAME> is followed. Bogacki has derived an interpolant for this method as well, but I was not able to find a copy of his thesis that contains this interpolant. """ import numpy as np import matplotlib.pyplot as plt import sympy from sympy.solvers.solveset import linsolve from sympy import Rational as R from pprint import pprint n_stages = 8 # including derivative evaluation at end of step order = 5 # of interpolation in t (not h) T5_method4 = 1.06e-4 # error of embedded fourth order method t = sympy.symbols('t', real=True) bi = sympy.symbols(f'bi0:{n_stages}', real=True) bi_vec = sympy.Matrix(bi) # Method A = sympy.Matrix([ # full A matrix, including last line [0, 0, 0, 0, 0, 0, 0, 0], [R(1,6), 0, 0, 0, 0, 0, 0, 0], [R(2,27), R(4,27), 0, 0, 0, 0, 0, 0], [R(183,1372), R(-162,343), R(1053,1372), 0, 0, 0, 0, 0], [R(68,297), R(-4,11), R(42,143), R(1960,3861), 0, 0, 0, 0], [R(597,22528), R(81,352), R(63099,585728), R(58653,366080), R(4617,20480), 0, 0, 0], [R(174197,959244), R(-30942,79937), R(8152137,19744439), R(666106,1039181), R(-29421,29068), R(482048,414219), 0, 0], [R(587,8064), 0, R(4440339,15491840), R(24353,124800), R(387,44800), R(2152,5985), R(7267,94080), 0]]) c = sympy.Matrix([0, R(1,6), R(2,9), R(3,7),
"3": # speed stat_name = "Speed" test_bounds = (20, 256) stat_values = loaddata.non_legendary_ghost_types['speed'] stat_stats = loaddata.non_legendary_ghost_types['speed'].describe() unit = '' elif stat_set == "4": # attack stat_name = "Attack" test_bounds = (20, 256) stat_values = loaddata.non_legendary_ghost_types['attack'] stat_stats = loaddata.non_legendary_ghost_types['attack'].describe() unit = '' elif stat_set == "5": # defense stat_name = "Defense" test_bounds = (20, 256) stat_values = loaddata.non_legendary_ghost_types['defense'] stat_stats = loaddata.non_legendary_ghost_types['defense'].describe() unit = '' elif stat_set == "6": # sp.attack stat_name = "Special Attack" test_bounds = (20, 256) stat_values = loaddata.non_legendary_ghost_types['sp_attack'] stat_stats = loaddata.non_legendary_ghost_types['sp_attack'].describe() unit = '' elif stat_set == "7": # sp.defense stat_name = "Special Defense" test_bounds = (20, 256) stat_values = loaddata.non_legendary_ghost_types['sp_defense'] stat_stats = loaddata.non_legendary_ghost_types['sp_defense'].describe() unit = '' elif stat_set == "8": # height stat_name = "Height(m)" test_bounds = (0, 20) stat_values = loaddata.non_legendary_ghost_types['height_m'] stat_stats = loaddata.non_legendary_ghost_types['height_m'].describe() unit = '(m)' elif stat_set == "9": # weight stat_name = "Weight(kg)" test_bounds = (1, 800) stat_values = loaddata.non_legendary_ghost_types['weight_kg'] stat_stats = loaddata.non_legendary_ghost_types['weight_kg'].describe() unit = '(kg)' else: return # steel pokemon elif type_set == "18": if stat_set == "1": # stat totals stat_name = "Stat Total" test_bounds = (100, 600) stat_values = loaddata.non_legendary_steel_types['total_points'] stat_stats = loaddata.non_legendary_steel_types['total_points'].describe() unit = '' elif stat_set == "2": # hp stat_name = "HP" test_bounds = (20, 256) stat_values = loaddata.non_legendary_steel_types['hp'] stat_stats = loaddata.non_legendary_steel_types['hp'].describe() unit = '' elif stat_set == "3": # speed stat_name = "Speed" test_bounds = (20, 256) stat_values = loaddata.non_legendary_steel_types['speed'] stat_stats = loaddata.non_legendary_steel_types['speed'].describe() unit = '' elif stat_set == "4": # attack stat_name = "Attack" test_bounds = (20, 256) stat_values = loaddata.non_legendary_steel_types['attack'] stat_stats = loaddata.non_legendary_steel_types['attack'].describe() unit = '' elif stat_set == "5": # defense stat_name = "Defense" test_bounds = (20, 256) stat_values = loaddata.non_legendary_steel_types['defense'] stat_stats = loaddata.non_legendary_steel_types['defense'].describe() unit = '' elif stat_set == "6": # sp.attack stat_name = "Special Attack" test_bounds = (20, 256) stat_values = loaddata.non_legendary_steel_types['sp_attack'] stat_stats = loaddata.non_legendary_steel_types['sp_attack'].describe() unit = '' elif stat_set == "7": # sp.defense stat_name = "Special Defense" test_bounds = (20, 256) stat_values = loaddata.non_legendary_steel_types['sp_defense'] stat_stats = loaddata.non_legendary_steel_types['sp_defense'].describe() unit = '' elif stat_set == "8": # height stat_name = "Height(m)" test_bounds = (0, 20) stat_values = loaddata.non_legendary_steel_types['height_m'] stat_stats = loaddata.non_legendary_steel_types['height_m'].describe() unit = '(m)' elif stat_set == "9": # weight stat_name = "Weight(kg)" test_bounds = (1, 800) stat_values = loaddata.non_legendary_steel_types['weight_kg'] stat_stats = loaddata.non_legendary_steel_types['weight_kg'].describe() unit = '(kg)' else: return # all pokemon (trimmed h & w) elif type_set == "19": if stat_set == "1": # stat totals stat_name = "Stat Total" test_bounds = (100, 600) stat_values = loaddata.non_legendary_total_points stat_stats = loaddata.non_legendary_total_points_stats unit = '' elif stat_set == "2": # hp stat_name = "HP" test_bounds = (20, 256) stat_values = loaddata.non_legendary_hp stat_stats = loaddata.non_legendary_hp_stats unit = '' elif stat_set == "3": # speed stat_name = "Speed" test_bounds = (20, 256) stat_values = loaddata.non_legendary_speed stat_stats = loaddata.non_legendary_speed_stats unit = '' elif stat_set == "4": # attack stat_name = "Attack" test_bounds = (20, 256) stat_values = loaddata.non_legendary_attack stat_stats = loaddata.non_legendary_attack_stats unit = '' elif stat_set == "5": # defense stat_name = "Defense" test_bounds = (20, 256) stat_values = loaddata.non_legendary_defense stat_stats = loaddata.non_legendary_defense_stats unit = '' elif stat_set == "6": # sp.attack stat_name = "Special Attack" test_bounds = (20, 256) stat_values = loaddata.non_legendary_sp_attack stat_stats = loaddata.non_legendary_sp_attack_stats unit = '' elif stat_set == "7": # sp.defense stat_name = "Special Defense" test_bounds = (20, 256) stat_values = loaddata.non_legendary_sp_defense stat_stats = loaddata.non_legendary_sp_defense_stats unit = '' elif stat_set == "8": # height stat_name = "Height(m)" test_bounds = (0, 20) stat_values = loaddata.non_legendary_height stat_stats = loaddata.non_legendary_height_stats unit = '(m)' elif stat_set == "9": # weight stat_name = "Weight(kg)" test_bounds = (1, 800) stat_values = loaddata.non_legendary_weight stat_stats = loaddata.non_legendary_weight_stats unit = '(kg)' else: return else: return elif data_set == "4": # legendary pokemon set_name = "Legendary Pokemon" modifier = '(legendary)' if type_set == "1": if stat_set == "1": # stat totals stat_name = "Stat Total" test_bounds = (100, 600) stat_values = loaddata.legendary_grass_types['total_points'] stat_stats = loaddata.legendary_grass_types['total_points'].describe() unit = '' elif stat_set == "2": # hp stat_name = "HP" test_bounds = (20, 256) stat_values = loaddata.legendary_grass_types['hp'] stat_stats = loaddata.legendary_grass_types['hp'].describe() unit = '' elif stat_set == "3": # speed stat_name = "Speed" test_bounds = (20, 256) stat_values = loaddata.legendary_grass_types['speed'] stat_stats = loaddata.legendary_grass_types['speed'].describe() unit = '' elif stat_set == "4": # attack stat_name = "Attack" test_bounds = (20, 256) stat_values = loaddata.legendary_grass_types['attack'] stat_stats = loaddata.legendary_grass_types['attack'].describe() unit = '' elif stat_set == "5": # defense stat_name = "Defense" test_bounds = (20, 256) stat_values = loaddata.legendary_grass_types['defense'] stat_stats = loaddata.legendary_grass_types['defense'].describe() unit = '' elif stat_set == "6": # sp.attack stat_name = "Special Attack" test_bounds = (20, 256) stat_values = loaddata.legendary_grass_types['sp_attack'] stat_stats = loaddata.legendary_grass_types['sp_attack'].describe() unit = '' elif stat_set == "7": # sp.defense stat_name = "Special Defense" test_bounds = (20, 256) stat_values = loaddata.legendary_grass_types['sp_defense'] stat_stats = loaddata.legendary_grass_types['sp_defense'].describe() unit = '' elif stat_set == "8": # height stat_name = "Height(m)" test_bounds = (0, 20) stat_values = loaddata.legendary_grass_types['height_m'] stat_stats = loaddata.legendary_grass_types['height_m'].describe() unit = '(m)' elif stat_set == "9": # weight stat_name = "Weight(kg)" test_bounds = (1, 800) stat_values = loaddata.legendary_grass_types['weight_kg'] stat_stats = loaddata.legendary_grass_types['weight_kg'].describe() unit = '(kg)' else: return # fire pokemon elif type_set == "2": if stat_set == "1": # stat totals stat_name = "Stat Total" test_bounds = (100, 600) stat_values = loaddata.legendary_fire_types['total_points'] stat_stats = loaddata.legendary_fire_types['total_points'].describe() unit = '' elif stat_set == "2": # hp stat_name = "HP" test_bounds = (20, 256) stat_values = loaddata.legendary_fire_types['hp'] stat_stats = loaddata.legendary_fire_types['hp'].describe() unit = '' elif stat_set == "3": # speed stat_name = "Speed" test_bounds = (20, 256) stat_values = loaddata.legendary_fire_types['speed'] stat_stats = loaddata.legendary_fire_types['speed'].describe() unit = '' elif stat_set == "4": # attack stat_name = "Attack" test_bounds = (20, 256) stat_values = loaddata.legendary_fire_types['attack'] stat_stats = loaddata.legendary_fire_types['attack'].describe() unit = '' elif stat_set == "5": # defense stat_name = "Defense" test_bounds = (20, 256) stat_values = loaddata.legendary_fire_types['defense'] stat_stats = loaddata.legendary_fire_types['defense'].describe() unit = '' elif stat_set == "6": # sp.attack stat_name = "Special Attack" test_bounds = (20, 256) stat_values = loaddata.legendary_fire_types['sp_attack'] stat_stats = loaddata.legendary_fire_types['sp_attack'].describe() unit = '' elif stat_set == "7": # sp.defense stat_name = "Special Defense" test_bounds = (20, 256) stat_values = loaddata.legendary_fire_types['sp_defense'] stat_stats = loaddata.legendary_fire_types['sp_defense'].describe() unit = '' elif stat_set == "8": # height stat_name = "Height(m)" test_bounds = (0, 20) stat_values = loaddata.legendary_fire_types['height_m'] stat_stats = loaddata.legendary_fire_types['height_m'].describe() unit = '(m)' elif stat_set == "9": # weight stat_name = "Weight(kg)" test_bounds = (1, 800) stat_values = loaddata.legendary_fire_types['weight_kg'] stat_stats = loaddata.legendary_fire_types['weight_kg'].describe() unit = '(kg)' else: return # water pokemon elif type_set == "3": if stat_set == "1": # stat totals stat_name = "Stat Total" test_bounds = (100, 600) stat_values = loaddata.legendary_water_types['total_points'] stat_stats = loaddata.legendary_water_types['total_points'].describe() unit = '' elif stat_set == "2": # hp stat_name = "HP" test_bounds = (20, 256) stat_values = loaddata.legendary_water_types['hp'] stat_stats = loaddata.legendary_water_types['hp'].describe() unit = '' elif stat_set == "3": # speed stat_name = "Speed" test_bounds = (20, 256) stat_values = loaddata.legendary_water_types['speed'] stat_stats = loaddata.legendary_water_types['speed'].describe() unit = '' elif stat_set == "4": # attack stat_name = "Attack" test_bounds = (20, 256) stat_values = loaddata.legendary_water_types['attack'] stat_stats = loaddata.legendary_water_types['attack'].describe() unit = '' elif stat_set == "5": # defense stat_name = "Defense" test_bounds = (20, 256) stat_values = loaddata.legendary_water_types['defense'] stat_stats = loaddata.legendary_water_types['defense'].describe() unit = '' elif stat_set == "6": # sp.attack stat_name = "Special Attack" test_bounds = (20, 256) stat_values = loaddata.legendary_water_types['sp_attack'] stat_stats = loaddata.legendary_water_types['sp_attack'].describe() unit = '' elif stat_set == "7": # sp.defense stat_name = "Special Defense" test_bounds = (20, 256) stat_values = loaddata.legendary_water_types['sp_defense'] stat_stats = loaddata.legendary_water_types['sp_defense'].describe() unit = '' elif stat_set == "8": # height stat_name = "Height(m)" test_bounds = (0, 20) stat_values = loaddata.legendary_water_types['height_m'] stat_stats = loaddata.legendary_water_types['height_m'].describe() unit = '(m)' elif stat_set == "9": # weight stat_name = "Weight(kg)" test_bounds = (1, 800) stat_values = loaddata.legendary_water_types['weight_kg'] stat_stats = loaddata.legendary_water_types['weight_kg'].describe() unit = '(kg)' else: return # electric pokemon elif type_set == "4": if stat_set == "1": # stat totals stat_name = "Stat Total" test_bounds = (100, 600) stat_values = loaddata.legendary_electric_types['total_points'] stat_stats = loaddata.legendary_electric_types['total_points'].describe() unit = '' elif stat_set == "2": # hp stat_name = "HP" test_bounds = (20, 256) stat_values = loaddata.legendary_electric_types['hp'] stat_stats = loaddata.legendary_electric_types['hp'].describe() unit = ''
cons.idtabla = nodo.idnuevo consola += "La tabla " + nodo.idactual + \ " se cambio a " + nodo.idnuevo + " exitosamente \n" elif lib == 1: listaSemanticos.append(Error.ErrorS( "Error Semantico", "Error en la operacion.")) elif lib == 2: listaSemanticos.append(Error.ErrorS( "Error Semantico", "La base de datos " + useActual + " no existe")) elif lib == 3: listaSemanticos.append(Error.ErrorS( "Error Semantico", "La tabla " + nodo.idactual + " no existe")) elif lib == 4: listaSemanticos.append(Error.ErrorS( "Error Semantico", "La tabla " + nodo.idnuevo + " ya existe")) elif op == 1: listaSemanticos.append(Error.ErrorS( "Error Semantico", "La tabla con nombre " + nodo.idnuevo + " ya existe")) elif op == 2: listaSemanticos.append(Error.ErrorS( "Error Semantico", "La tabla con nombre " + nodo.idactual + " no existe")) def AlterTableCheck(nodo, tablaSimbolos): global useActual base = tablaSimbolos.get(useActual) tabla = base.getTabla(nodo.idtabla) condicion = nodo.expresion opIzq = condicion.opIzq idcol = opIzq.valor result = False global consola if nodo.idcons == None: result = tabla.modificarCheck(idcol, condicion, idcol + "_check") listaConstraint.append(TS.Constraints( useActual, nodo.idtabla, idcol + "_check", idcol, "check")) consola += "Se agrego el check a la columna " + idcol + " exitosamente \n" else: result = tabla.modificarCheck(idcol, condicion, nodo.idcons) listaConstraint.append(TS.Constraints( useActual, nodo.idtabla, nodo.idcons, idcol, "check")) consola += "Se agrego el check a la columna " + idcol + " exitosamente \n" if result != True: listaSemanticos.append(Error.ErrorS( "Error Semantico", "No se encontró la columna con id " + idcol)) def AlterTableUnique(nodo, tablaSimbolos): global consola global useActual base = tablaSimbolos.get(useActual) tabla = base.getTabla(nodo.idtabla) if tabla.modificarUnique(nodo.idcolumna, True, nodo.idconstraint): listaConstraint.append(TS.Constraints( useActual, nodo.idtabla, nodo.idconstraint, nodo.idcolumna, "unique")) consola += "Se agrego el unique a la columna " + \ nodo.idcolumna + " exitosamente \n" else: listaSemanticos.append( Error.ErrorS("Error Semantico", "No se encontró la columna con id " + nodo.idcolumna)) def AlterTableFK(nodo, tablaSimbolos): global useActual global consola base = tablaSimbolos.get(useActual) tabla = base.getTabla(nodo.idtabla) for i in range(len(nodo.idlocal)): idlocal = nodo.idlocal[i].valor idfk = nodo.idfk[i].valor columnafk = tablaSimbolos.getColumna(useActual, nodo.idtablafk, idfk) columnalocal = tabla.getColumna(idlocal) if columnafk != None and columnalocal != None: if columnafk.tipo.tipo == columnalocal.tipo.tipo: tabla.modificarFk(idlocal, nodo.idtablafk, idfk) if nodo.idconstraint != None: listaConstraint.append( TS.Constraints(useActual, nodo.idtabla, nodo.idconstraint, columnalocal, "FK")) listaFK.append(TS.llaveForanea( useActual, nodo.idtabla, nodo.idtablafk, idlocal, idfk)) consola += "Se agrego la llave foranea a " + idlocal + " exitosamente \n" else: listaSemanticos.append(Error.ErrorS("Error Semantico", "La columna %s y la columna %s no tienen el mismo tipo" % ( idlocal, idfk))) else: listaSemanticos.append( Error.ErrorS("Error Semantico", "No se encontró la columna")) def AlterTableDropColumn(nodo, tablaSimbolos): global useActual global consola base = tablaSimbolos.get(useActual) tabla = base.getTabla(nodo.idtabla) for col in nodo.listaColumnas: if jBase.alterDropColumn(useActual, nodo.idtabla, tabla.getIndex(col.idcolumna)) == 0: if tabla.deleteColumn(col.idcolumna): consola += "Se eliminó con exito la columna " + col.idcolumna + "\n" else: listaSemanticos.append(Error.ErrorS( "Error Semantico", "La columna " + col.idcolumna + " no existe")) def AlterTableDropConstraint(nodo, tablaSimbolos): global useActual global consola base = tablaSimbolos.get(useActual) tabla = base.getTabla(nodo.idtabla) bandera = False for cons in listaConstraint: if cons.idconstraint == nodo.listaColumnas: bandera = True if cons.tipo == "unique": if tabla.deleteUnique(cons.idcol): consola += "Se eliminó con éxito el constraint " + nodo.listaColumnas + "\n" else: consola += "Error no se pudo eliminar el constraint " + nodo.listaColumnas + "\n" elif cons.tipo == "check": if tabla.deleteCheck(cons.idcol): consola += "Se eliminó con éxito el constraint " + nodo.listaColumnas + "\n" else: consola += "Error no se pudo eliminar el constraint " + nodo.listaColumnas + "\n" elif cons.tipo == "FK": if tabla.deleteFk(cons.idcol): consola += "Se eliminó con éxito el constraint " + nodo.listaColumnas + "\n" else: consola += "Error no se pudo eliminar el constraint " + nodo.listaColumnas + "\n" if bandera == False: listaSemanticos.append(Error.ErrorS( "Error Semantico", "No se encontro el constraint " + nodo.listaColumnas)) def AlterColumnNotNull(nodo, tablaSimbolos): global useActual global consola base = tablaSimbolos.get(useActual) tabla = base.getTabla(nodo.idtabla) for col in nodo.columnas: if tabla.modificarNull(col.idcolumna): consola += "Se cambió a not null con exito la columna " + col.idcolumna + " \n" else: listaSemanticos.append(Error.ErrorS( "Error Semantico", "No se encontro la columna" + col.idcolumna)) def AlterColumnCTipo(nodo, tablaSimbolos): global useActual global consola base = tablaSimbolos.get(useActual) tabla = base.getTabla(nodo.idtabla) for col in nodo.columnas: b = tabla.modificarTipo( col.idcolumna, col.valcambio.tipo, col.valcambio.cantidad) if b == 0: consola += "Se modificó el tipo exitosamente a la columna " + col.idcolumna + " \n" elif b == 1: listaSemanticos.append(Error.ErrorS( "Error Semantico", "El valor es menor al actual")) elif b == 2: listaSemanticos.append(Error.ErrorS( "Error Semantico", "Los tipos no coinciden")) elif b == 3: listaSemanticos.append(Error.ErrorS( "Error Semantico", "la columna no existe " + col.idcolumna)) def InsertTable(nodo, tablaSimbolos): global consola flag = False base = tablaSimbolos.get(useActual) if base != None: tabla = base.getTabla(nodo.id) if tabla != None: if nodo.listaColumnas != None: if len(nodo.listaColumnas) == len(nodo.listValores): result = False # se comprueba la cantidad de columnas y las que tienen valor null b = tabla.comprobarNulas(nodo.listaColumnas) if b["cod"] == 0: # se validan tipos for i in range(len(nodo.listaColumnas)): col = tabla.getColumna(nodo.listaColumnas[i].valor) val = Interpreta_Expresion(nodo.listValores[i], tablaSimbolos, tabla) if col.tipo.tipo == TipoDato.NUMERICO: result = validarTiposNumericos( col.tipo.dato.lower(), val) elif col.tipo.tipo == TipoDato.CHAR: if val.tipo == Expresion.CADENA: result = validarTiposChar(col.tipo, val) else: result = False listaSemanticos.append(Error.ErrorS( "Error Semantico", "Error de tipos: tipo " + col.tipo.dato + " columna " + col.nombre + " valor a insertar " + str( val.tipo))) elif col.tipo.tipo == TipoDato.FECHA: result = validarTiposFecha( col.tipo.dato.lower(), val) elif col.tipo.tipo == TipoDato.BOOLEAN: if val.tipo == Expresion.BOOLEAN: result = True if not result: listaSemanticos.append(Error.ErrorS("Error Semantico", "Error de tipos: tipo " + col.tipo.dato + " columna " + col.nombre + " valor a insertar " + str( val.tipo))) flag = False break else: bas1 = validaCheck( col, val, nodo.listaColumnas, nodo.listValores) if (bas1 == 0): if validarUnique(col, val.valor, tabla): if validarPK(col, val.valor, tabla): if validarFK(col, val.valor, tabla, tablaSimbolos): flag = True else: listaSemanticos.append(Error.ErrorS( "Error Semantico", "El valor " + str( val.valor) + " no corresponde a ningún valor de llave foránea")) else: listaSemanticos.append(Error.ErrorS( "Error Semantico", "El valor " + str( val.valor) + " infringe la condición de llave primaria")) else: listaSemanticos.append(Error.ErrorS( "Error Semantico", "El valor " + val.valor + " infringe la condición de columna única")) elif bas1 == 1: listaSemanticos.append(Error.ErrorS( "Error Semantico", "La columna " + col.nombre + " no superó la condición CHECK")) return elif bas1 == 2: flag = False listaSemanticos.append(Error.ErrorS("Error Semantico", "La columna " + col.nombre + " en su condición CHECK contienen un operario inexistente dentro de la tabla actual ")) return if flag: flag = False tupla = validarDefault(nodo.listaColumnas, nodo.listValores, tabla, tablaSimbolos) rs = jBase.insert(useActual, tabla.nombre, tupla) if rs == 0: consola += "Se insertó con éxito la tupla" + str(tupla) + "\n" elif rs == 1: listaSemanticos.append( Error.ErrorS("Error Semantico", "Fallo al insertar la tupla: " + str(tupla))) elif rs == 2: listaSemanticos.append(Error.ErrorS("Error Semantico", "Fallo al insertar, la base de datos '%s' no existe " % useActual)) elif rs == 3: listaSemanticos.append(Error.ErrorS("Error Semantico", "Fallo al insertar, la tabla '%s' no existe" % tabla.nombre)) elif rs == 4: listaSemanticos.append( Error.ErrorS("Error Semantico", "Fallo al insertar, Llaves duplicadas")) elif rs == 5: listaSemanticos.append(Error.ErrorS("Error Semantico", "Fallo al insertar, La tupla excede el número de columnas")) elif b["cod"] == 1: listaSemanticos.append(Error.ErrorS( "Error Semantico", "La columna " + b["col"] + "no existe en la tabla")) elif b["cod"] == 2: listaSemanticos.append(Error.ErrorS( "Error Semantico", "La columna " + b["col"] + " no puede ser nula")) else: listaSemanticos.append( Error.ErrorS("Error Semantico", "El numero de columnas a insertar no coincide")) else: if (len(nodo.listValores) == len(tabla.columnas)): result = False # se comprueba la cantidad de columnas y las que tienen valor null columnas = list(tabla.columnas.keys()) b = tabla.comprobarNulas2(columnas) if b["cod"] == 0: # se validan tipos for i in range(len(columnas)): col = tabla.getColumna(columnas[i]) val = Interpreta_Expresion(nodo.listValores[i], tablaSimbolos, tabla) if col.tipo.tipo == TipoDato.NUMERICO: result = validarTiposNumericos( col.tipo.dato.lower(), val) elif col.tipo.tipo == TipoDato.CHAR: if val.tipo == Expresion.CADENA: result = validarTiposChar(col.tipo, val) else: result = False listaSemanticos.append(Error.ErrorS( "Error Semantico", "Error de tipos: tipo " + col.tipo.dato + " columna " + col.nombre + " valor a insertar " + str( val.tipo))) elif col.tipo.tipo == TipoDato.FECHA: result = validarTiposFecha( col.tipo.dato.lower(), val) elif col.tipo.tipo == TipoDato.BOOLEAN: if val.tipo == Expresion.BOOLEAN: result = True if not
from enum import Enum import numpy as np from cvxopt import matrix, solvers from processing import vector_of_quants import math class KnowledgePatternManager: @staticmethod def checkConsistency(knowledgePattern): return KnowledgePatternManager.__getConsistencyChecker(knowledgePattern.type) \ .isConsistent(knowledgePattern) @staticmethod def __getConsistencyChecker(type): if type == KnowledgePatternType.QUANTS: return QuantConsistencyChecker() elif type == KnowledgePatternType.DISJUNCTS: return DisjunctConsistencyChecker() elif type == KnowledgePatternType.CONJUNCTS: return ConjunctConsistencyChecker() else: raise TypeError("Correct type of knowledge pattern") @staticmethod def getProbabilityFormula(knowledgePattern, formulaPattern): size = knowledgePattern.size matrix = MatrixProducer.getConjunctsToQuantsMatrix(int(math.log(size, 2))) intervals = np.array(knowledgePattern.array, dtype=np.double) vector = FormulaManager.getQuantsVector(formulaPattern, int(math.log(size, 2))) return LinearProgrammingProblemSolver.findOptimalFormulaValues(matrix, intervals, size, vector) @staticmethod def __getEvidenceCorrector(type): if type == EvidencePatternType.DETERMINISTIC: return DeterministicEvidenceCorrector() elif type == EvidencePatternType.STOCHASTIC: return StochasticEvidenceCorrector() elif type == EvidencePatternType.INACCURATE: return InaccurateEvidenceCorrector() @staticmethod def correctEvidenceData(knowledgePattern, evidencePattern): return KnowledgePatternManager.__getEvidenceCorrector(evidencePattern.type).getCorrectData(knowledgePattern, evidencePattern) class FormulaManager: @staticmethod def getQuantsVector(formulaPattern, size): return vector_of_quants(formulaPattern.string, size) @staticmethod def getFormulaForOptimise(knowledgePattern, evidencePattern): size = knowledgePattern.size size_evidence = 2**(evidencePattern.size) result_formula = np.zeros(size) vector = EvidenceManager.getSubIdealProbability(evidencePattern) I = MatrixProducer.getConjunctsToQuantsMatrix(evidencePattern.size) ideal = EvidenceManager.getSubIdeal(evidencePattern) for i in range(0, 2**evidencePattern.size): array = [[ideal[i]], [ideal[size_evidence - 1 - i]]] formula = MatrixProducer.getTMatrix(array, int(math.log(size, 2)))[0] formula = np.dot(formula, np.dot(I, vector)[i]) result_formula += formula return result_formula @staticmethod def getConjunctstoQuantsVector(vector): return np.dot(MatrixProducer.getConjunctsToQuantsMatrix(int(math.log(len(vector), 2))), vector) @staticmethod def getFormulaForOptimiseIn(knowledgePattern, evidencePattern): size = knowledgePattern.size matrix = MatrixProducer.getConjunctsToQuantsMatrix(int(math.log(size, 2))) intervals = np.array(knowledgePattern.array, dtype=np.double) matrix_for_opt = FormulaManager.getSubIdealtoIdealMatrix(evidencePattern, knowledgePattern) size_evidence = 2 ** (evidencePattern.size) result_formula_min = np.zeros(2 **evidencePattern.size) result_formula_max = np.zeros(2 **evidencePattern.size) I = MatrixProducer.getConjunctsToQuantsMatrix(evidencePattern.size) ideal = EvidenceManager.getSubIdeal(evidencePattern) for i in range(0, 2**evidencePattern.size): array = [[ideal[i]], [ideal[size_evidence - 1 - i]]] formula = MatrixProducer.getTMatrix(array, int(math.log(size, 2)))[0] prob = LinearProgrammingProblemSolver.findOptimalConjunctsFormulaValues(matrix, intervals, size, formula).array result_formula_min += I[i]*prob[0] result_formula_max += I[i]*prob[1] result = np.vstack([result_formula_min, result_formula_max]) return result @staticmethod def getSubIdealtoIdealMatrix(evidencePattern, knowledgePattern): I = MatrixProducer.getConjunctsToQuantsMatrix(evidencePattern.size) ideal = EvidenceManager.getSubIdeal(evidencePattern) Matrix = np.zeros((2 ** evidencePattern.size, knowledgePattern.size), dtype = np.double) for i in range(0, 2 ** evidencePattern.size): for j in range(0, 2 **evidencePattern.size): Matrix[i][int(ideal[j])] = I[i][j] return Matrix class EvidenceManager: @staticmethod def getConjunctsVector(evidencePattern): arr_conj = [] num_conj = 0 p_arr = evidencePattern.p_array for i in range(len(p_arr)): if p_arr[i] == 0: continue #? num_conj += pow(2, p_arr[i] - 1) arr_conj.append(num_conj) num_conj = 0 m_arr = evidencePattern.m_array for i in range(len(m_arr)): num_conj += pow(2, p_arr[i] - 1) arr_conj.append(num_conj) return np.array(arr_conj) @staticmethod def getProbabilityOfDeterministicEvidence(knowledgePattern, mas): size = knowledgePattern.size matrix = MatrixProducer.getConjunctsToQuantsMatrix(int(math.log(size, 2))) intervals = np.array(knowledgePattern.array, dtype=np.double) vector = MatrixProducer.getTMatrix(mas, int(math.log(size, 2)))[0].tolist() return LinearProgrammingProblemSolver.findOptimalConjunctsFormulaValues(matrix, intervals, size, vector) @staticmethod def getProbabilityofStochasticEvidence(knowledgePattern, evidencePattern): size = knowledgePattern.size matrix = MatrixProducer.getConjunctsToQuantsMatrix(int(math.log(size, 2))) intervals = np.array(knowledgePattern.array, dtype=np.double) vector = FormulaManager.getFormulaForOptimise(knowledgePattern, evidencePattern) return LinearProgrammingProblemSolver.findOptimalConjunctsFormulaValues(matrix, intervals, size, vector) @staticmethod def getProbabilityofInaccurateEvidence(knowledgePattern, evidencePattern): size = evidencePattern.size matrix = MatrixProducer.getConjunctsToQuantsMatrix(evidencePattern.size) vectors = FormulaManager.getFormulaForOptimiseIn(knowledgePattern, evidencePattern) intervals = EvidenceManager.getSubIdealIntervalProbability(evidencePattern) return LinearProgrammingProblemSolver.findOptimalConjunctsFormulaValuesIn(matrix, intervals, size, vectors) @staticmethod def getSubIdealProbability(evidencePattern): vector = np.ones(2 ** evidencePattern.size) array = evidencePattern.arr for i in range(0, 2**evidencePattern.size-1): vector[i+1] = array[i][1] return vector @staticmethod def getSubIdealIntervalProbability(evidencePattern): vector_min = np.ones(2 ** evidencePattern.size) vector_max = np.ones(2 ** evidencePattern.size) array = evidencePattern.arr for i in range(0, 2**evidencePattern.size-1): vector_min[i+1] = array[i][1] vector_max[i+1] = array[i][2] vector = [] vector.append(vector_min) vector.append(vector_max) return vector @staticmethod def getSubIdeal(evidencePattern): vector = np.zeros(2 ** evidencePattern.size) array = evidencePattern.arr for i in range(0, 2**evidencePattern.size-1): vector[i+1] = array[i][0] return vector class EvidencePatternType(Enum): DETERMINISTIC = 'deterministic', STOCHASTIC = 'stochastic', INACCURATE = 'inaccurate' class KnowledgePatternType(Enum): QUANTS = 'quants', DISJUNCTS = 'disjuncts', CONJUNCTS = 'conjuncts' class ConsistencyChecker: @staticmethod def isConsistent(knowledgePattern): raise NotImplementedError("It's a method of abstract class, use appropriate implementation") class EvidenceCorrector: @staticmethod def getCorrextData(knowledgePattern, evidencePattern): raise NotImplementedError("It's a method of abstract class, use appropriate implementation") class DeterministicEvidenceCorrector(EvidenceCorrector): @staticmethod def getCorrectData(knowledgePattern, evidencePattern): # разобраться с 1 и нулем size = knowledgePattern.size matrix = MatrixProducer.getConjunctsToQuantsMatrix(int(math.log(size, 2))) intervals = np.array(knowledgePattern.array, dtype=np.double) return LinearProgrammingProblemSolver.findOptimalEvidenceValues(matrix, intervals, size, MatrixProducer.getEvidencevector(evidencePattern.arr, int(math.log(size, 2))), intervals, MatrixProducer.getTMatrix(evidencePattern.arr, int(math.log(size, 2)))) class StochasticEvidenceCorrector(EvidenceCorrector): @staticmethod def getCorrectData(knowledgePattern, evidencePattern): size = knowledgePattern.size size_evidence = 2 ** (evidencePattern.size) result = [[0, 0] for i in range(knowledgePattern.size)] vector = EvidenceManager.getSubIdealProbability(evidencePattern) #p_ca I = MatrixProducer.getConjunctsToQuantsMatrix(int(math.log(knowledgePattern.size, 2))) I_1 = MatrixProducer.getConjunctsToQuantsMatrix(evidencePattern.size) vector_quants = np.dot(I_1, vector) ideal = EvidenceManager.getSubIdeal(evidencePattern) intervals = np.array(knowledgePattern.array, dtype=np.double) for i in range(0, 2 ** evidencePattern.size): array = [[ideal[i]], [ideal[size_evidence - 1 - i]]] divider = MatrixProducer.getTMatrix(array, int(math.log(size, 2)))[0] numerator = MatrixProducer.getTMatrix(array, int(math.log(size, 2))) ideal_ = LinearProgrammingProblemSolver.findOptimalStochasticEvidenceValues(I, intervals, size, numerator, divider) if len(ideal_) == 0: return EvidenceCorrectorResult(False, []) for j in range(size): result[j][0] += round(vector_quants[i] * ideal_[j][0], 3) result[j][1] += round(vector_quants[i] * ideal_[j][1], 3) if result[0][0] == 0: return EvidenceCorrectorResult(False, []) return EvidenceCorrectorResult(True, result) class InaccurateEvidenceCorrector(EvidenceCorrector): @staticmethod def getCorrectData(knowledgePattern, evidencePattern): size = knowledgePattern.size size_evidence = 2 ** (evidencePattern.size) result_formula_min = np.zeros((size, size_evidence)) result_formula_max = np.zeros((size, size_evidence)) I = MatrixProducer.getConjunctsToQuantsMatrix(int(math.log(knowledgePattern.size, 2))) I_1 = MatrixProducer.getConjunctsToQuantsMatrix(evidencePattern.size) #vector_quants = np.dot(I_1, vector) ideal = EvidenceManager.getSubIdeal(evidencePattern) intervals = np.array(knowledgePattern.array, dtype=np.double) for i in range(0, 2 ** evidencePattern.size): array = [[ideal[i]], [ideal[size_evidence - 1 - i]]] divider = MatrixProducer.getTMatrix(array, int(math.log(size, 2)))[0] numerator = MatrixProducer.getTMatrix(array, int(math.log(size, 2))) ideal_ = LinearProgrammingProblemSolver.findOptimalStochasticEvidenceValues(I, intervals, size, numerator, divider) if len(ideal_) == 0: return EvidenceCorrectorResult(False, []) for j in range(size): result_formula_min[j] += I_1[i] * ideal_[j][0] result_formula_max[j] += I_1[i] * ideal_[j][1] return LinearProgrammingProblemSolver.findOptimalInaccurateEvidenceValues(I_1, EvidenceManager.getSubIdealIntervalProbability(evidencePattern),size, size_evidence, result_formula_min, result_formula_max) class QuantConsistencyChecker(ConsistencyChecker): @staticmethod def isConsistent(knowledgePattern): size = knowledgePattern.size matrix = MatrixProducer.getIdentityMatrix(size) intervals = np.array(knowledgePattern.array, dtype=np.double) result = LinearProgrammingProblemSolver.findOptimalValues(matrix, intervals, size) if result.consistent: result = LinearProgrammingProblemSolver.findNormalizedOptimalValues(np.array(result.array, dtype=np.double), size) return result class ConjunctConsistencyChecker(ConsistencyChecker): @staticmethod def isConsistent(knowledgePattern): size = knowledgePattern.size matrix = MatrixProducer.getConjunctsToQuantsMatrix(int(math.log(size, 2))) intervals = np.array(knowledgePattern.array, dtype=np.double) return LinearProgrammingProblemSolver.findOptimalValues(matrix, intervals, size) class DisjunctConsistencyChecker(ConsistencyChecker): @staticmethod def isConsistent(knowledgePattern): size = knowledgePattern.size matrix = MatrixProducer.getDisjunctsToQuantsMatrix(int(math.log(size, 2))) intervals = np.array(knowledgePattern.array, dtype=np.double) return LinearProgrammingProblemSolver.findOptimalValues(matrix, intervals, size) class MatrixProducer: @staticmethod def getDisjunctsToQuantsMatrix(n): return np.linalg.inv(MatrixProducer.getQuantsToDisjunctsMatrix(n)) @staticmethod def getQuantsToDisjunctsMatrix(n): if n == 0: return np.array([1], dtype=np.double) elif n == 1: return np.array([[1, 1], [0, 1]], dtype=np.double) else: k = MatrixProducer.getQuantsToDisjunctsMatrix(n - 1) i = np.ones((2 ** (n - 1), 2 ** (n - 1)), dtype=np.double) k_o = k.copy() k_o[0] = [0] * 2 ** (n - 1) return np.block([[k, k], [k_o, i]]) @staticmethod def getConjunctsToQuantsMatrix(n): if n == 0: return np.array([1], dtype=np.double) elif n == 1: return np.array([[1, -1], [0, 1]], dtype=np.double) else: i = MatrixProducer.getConjunctsToQuantsMatrix(n - 1) o = np.zeros((2 ** (n - 1), 2 ** (n - 1)), dtype=np.double) return np.block([[i, (-1) * i], [o, i]]) @staticmethod def getIdentityMatrix(size): return np.eye(size, dtype=np.double) @staticmethod def getTMatrix(mas, size): matrix = np.array([1]) I_1 = MatrixProducer.getConjunctsToQuantsMatrix(1) J_1 = np.linalg.inv(I_1) H_p = np.array([[0, 0], [0, 1]]) H_m = np.array([[1, 0], [0, 0]]) H = MatrixProducer.getIdentityMatrix(2) for i in range(size, 0, -1): if i == 0: matrix = np.kron(matrix, np.dot(np.dot(J_1, H_p), I_1)) continue if i in mas[0]: matrix = np.kron(matrix, np.dot(np.dot(J_1, H_p), I_1)) elif i in mas[1]: matrix = np.kron(matrix, np.dot(np.dot(J_1, H_m), I_1)) else: matrix = np.kron(matrix, np.dot(np.dot(J_1, H), I_1)) return matrix @staticmethod def getEvidencevector(mas, size): return MatrixProducer.getTMatrix(mas, size)[0] class LinearProgrammingProblemSolver: @staticmethod def findOptimalFormulaValues(matrixs, array, size, vector): a = np.vstack(((-1) * matrixs, (-1) * np.eye(size, dtype=np.double), np.eye(size, dtype=np.double))) a = matrix(a) b = np.hstack((np.zeros(size, dtype=np.double), (-1) * array[:, 0], array[:, 1])) b = matrix(b) c = np.dot(np.array(MatrixProducer.getConjunctsToQuantsMatrix(int(math.log(len(vector), 2))).transpose()), vector) c = matrix(c) return LinearProgrammingProblemSolver.optimizeForFormula(a, b, c) @staticmethod def findOptimalConjunctsFormulaValues(matrixs, array, size, vector): a = np.vstack(((-1) * matrixs, (-1) * np.eye(size, dtype=np.double), np.eye(size, dtype=np.double))) a = matrix(a) b = np.hstack((np.zeros(size, dtype=np.double), (-1) * array[:, 0], array[:, 1])) b = matrix(b) c = np.array(vector) c = matrix(c) return LinearProgrammingProblemSolver.optimizeForFormula(a, b, c) @staticmethod def findOptimalValues(matrixs, array, size): a = np.vstack(((-1) * matrixs, (-1) * np.eye(size, dtype=np.double), np.eye(size, dtype=np.double))) a = matrix(a) b = np.hstack((np.zeros(size, dtype=np.double), (-1) * array[:, 0], array[:, 1])) b = matrix(b) c = np.array(np.zeros(size, dtype=np.double)) c = matrix(c) return LinearProgrammingProblemSolver.optimizeForMatrices(a, b, c, size, array) @staticmethod def findNormalizedOptimalValues(array, size): a = np.vstack(((-1) * np.ones(size, dtype=np.double), np.ones(size, dtype=np.double), (-1) * np.eye(size, dtype=np.double), np.eye(size, dtype=np.double))) a = matrix(a) b = np.hstack( ((-1) * np.ones(1, dtype=np.double), np.ones(1, dtype=np.double), (-1) * array[:, 0], array[:, 1])) b = matrix(b) c = np.array(np.zeros(size, dtype=np.double)) c = matrix(c) return LinearProgrammingProblemSolver.optimizeForMatrices(a, b, c, size, array) @staticmethod def optimizeForMatrices(a, b, c, size, intervals): solvers.options['show_progress'] = False _intervals = intervals.copy() for i in range(size): c[i] = 1 sol = solvers.lp(c, a, b) if sol['status'] != 'optimal': return ConsistencyResult(False, []) _intervals[i][0] = round(sol['x'][i], 3) c[i] = -1 sol = solvers.lp(c, a, b) if sol['status'] != 'optimal': return ConsistencyResult(False, []) _intervals[i][1] = round(sol['x'][i], 3) c[i] = 0 return ConsistencyResult(True, _intervals.tolist()) @staticmethod def optimizeForFormula(a, b, c): answer =
<gh_stars>0 # coding=utf-8 import os import torch import mpu import torch.nn.functional as F from collections import defaultdict from tokenization_eva import EVATokenizer class BeamHypotheses(object): def __init__(self, num_beams, max_length, length_penalty, early_stopping, tokenizer=None): """ Initialize n-best list of hypotheses. """ self.max_length = max_length - 1 # ignoring bos_token self.length_penalty = length_penalty self.early_stopping = early_stopping self.num_beams = num_beams self.length_fact = [] self.beams = [] self.worst_score = 1e9 self.raw_worst_score = 1e9 self.tokenizer = tokenizer def __len__(self): """ Number of hypotheses in the list. """ return len(self.beams) def add(self, hyp, sum_logprobs): """ Add a new hypothesis to the list. """ score = sum_logprobs / len(hyp) ** self.length_penalty if len(self) < self.num_beams or score > self.worst_score: self.beams.append((score, hyp)) self.length_fact.append(len(hyp) ** self.length_penalty) if len(self) > self.num_beams: sorted_scores = sorted([(s, idx, _) for idx, (s, _) in enumerate(self.beams)]) del self.beams[sorted_scores[0][1]] self.worst_score = sorted_scores[1][0] self.raw_worst_score = self.worst_score * (len(sorted_scores[1][2]) ** self.length_penalty) else: self.worst_score = min(score, self.worst_score) self.raw_worst_score = sum_logprobs def is_done(self, best_sum_logprobs, cur_len): """ If there are enough hypotheses and that none of the hypotheses being generated can become better than the worst one in the heap, then we are done with this sentence. """ if len(self) < self.num_beams: return False elif self.early_stopping: return True else: cur_score = best_sum_logprobs / cur_len ** self.length_penalty ret = self.worst_score >= cur_score return ret def construct_antonym_dict(args): if args.rule_path is None: return None with open(os.path.join(args.rule_path, './antonym/antonym.txt'), 'r') as f: data = f.read().split("\n") data = [eval(item) for item in data if item] antonym_dict = defaultdict(list) for first, second in data: antonym_dict[first].append(second) antonym_dict[second].append(first) return antonym_dict def calc_banned_antonym_words_ids(input_tokens, tokenizer, antonym_dict): if antonym_dict is None: return [] antonym_words = [set()] * len(input_tokens) # only consider tokens occurring in current sentence for idx, tokens in enumerate(input_tokens): for word in tokenizer.convert_ids_to_tokens(reversed(tokens.tolist())): if word == '<sep>': break antonym_words[idx].update(tokenizer.convert_tokens_to_ids(antonym_dict[word])) return [list(tokens) for tokens in antonym_words] def calc_banned_ngram_tokens(prev_input_ids, num_hypos: int, no_repeat_ngram_size: int, tokenizer: EVATokenizer) -> None: """Copied from fairseq for no_repeat_ngram in beam_search""" generated_ngrams = [{} for _ in range(num_hypos)] prev_input_words = [] for ids in prev_input_ids: tokens = tokenizer.convert_ids_to_tokens(ids.tolist()) words = [] for token in tokens: if token == '<sep>': words.append(token) else: words += list(token) prev_input_words.append(words) for idx in range(num_hypos): gen_words = prev_input_words[idx] generated_ngram = generated_ngrams[idx] for ngram in zip(*[gen_words[i:] for i in range(no_repeat_ngram_size)]): for prefix_len in range(no_repeat_ngram_size): prev_ngram = ''.join(ngram[:prefix_len]) suffix_ngram = ''.join(ngram[prefix_len:]) if tokenizer.check(suffix_ngram): # 在词表中 generated_ngram[prev_ngram] = generated_ngram.get(prev_ngram, set()) | set([suffix_ngram]) def _get_generated_ngrams(hypo_idx): # Before decoding the next token, prevent decoding of ngrams that have already appeared cur_len = len(prev_input_words[hypo_idx]) generated_ngram_idx = [] ''' 3-gram, prefix的长度可以是2/1/0 ''' for prefix_len in range(no_repeat_ngram_size): ngram_words = ''.join(prev_input_words[hypo_idx][cur_len-prefix_len:]) generated_ngram_words = generated_ngrams[hypo_idx].get(ngram_words, []) generated_ngram_idx += tokenizer.convert_tokens_to_ids(generated_ngram_words) if prev_input_words[hypo_idx][-1] in [',', ',', '。']: generated_ngram_idx.append(tokenizer.convert_token_to_id('但')) generated_ngram_idx.append(tokenizer.convert_token_to_id('不过')) return generated_ngram_idx banned_tokens = [_get_generated_ngrams(hypo_idx) for hypo_idx in range(num_hypos)] return banned_tokens def top_k_logits(logits, top_k=0, top_p=0.0, filter_value=-10000): # This function has been mostly taken from huggingface conversational ai code at # https://medium.com/huggingface/how-to-build-a-state-of-the-art-conversational-ai-with-transfer-learning-2d818ac26313 if top_k > 0: # Remove all tokens with a probability less than the last token of the top-k indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None] logits[indices_to_remove] = filter_value batch_size = logits.size()[0] if top_p > 0.0: # logits : (batch_size, vocab_size) logits=logits.view(batch_size, -1).contiguous() # logits : (batch_size, vocab_size) for logit in logits: # logit: (vocab_size) sorted_logits, sorted_indices = torch.sort(logit, descending=True) cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1) # Remove tokens with cumulative probability above the threshold sorted_indices_to_remove = cumulative_probs > top_p # Shift the indices to the right to keep also the first token above the threshold sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone() sorted_indices_to_remove[..., 0] = 0 indices_to_remove = sorted_indices[sorted_indices_to_remove] logit[indices_to_remove] = filter_value logits=logits.view(batch_size, -1).contiguous() return logits def calc_banned_bad_words_ids(prev_input_ids, bad_words_ids): banned_tokens = [] def _tokens_match(prev_tokens, tokens): if len(tokens) == 0: # if bad word tokens is just one token always ban it return True if len(tokens) > len(prev_input_ids): # if bad word tokens are longer then prev input_ids they can't be equal return False if prev_tokens[-len(tokens) :] == tokens: # if tokens match return True else: return False for prev_input_ids_slice in prev_input_ids: banned_tokens_slice = [] for banned_token_seq in bad_words_ids: assert len(banned_token_seq) > 0, "Banned words token sequences {} cannot have an empty list".format( bad_words_ids ) if _tokens_match(prev_input_ids_slice.tolist(), banned_token_seq[:-1]) is False: # if tokens do not match continue continue banned_tokens_slice.append(banned_token_seq[-1]) banned_tokens.append(banned_tokens_slice) return banned_tokens def enforce_repetition_penalty_(tokenizer, lprobs, batch_size, num_beams, prev_output_tokens, repetition_penalty): """repetition penalty (from CTRL paper https://arxiv.org/abs/1909.05858). """ for i in range(batch_size * num_beams): for previous_token in set(prev_output_tokens[i].tolist()): if previous_token != tokenizer.sep_id: # if score < 0 then repetition penalty has to multiplied to reduce the previous token probability if lprobs[i, previous_token] < 0: lprobs[i, previous_token] *= repetition_penalty else: lprobs[i, previous_token] /= repetition_penalty def postprocess_next_token_scores( tokenizer: EVATokenizer, scores, input_ids, no_repeat_ngram_size, bad_words_ids, cur_len, min_length, max_length, eos_token_id, repetition_penalty, batch_size, num_beams, antonym_dict, ): # repetition penalty (from CTRL paper https://arxiv.org/abs/1909.05858) if repetition_penalty != 1.0: enforce_repetition_penalty_( tokenizer, scores, batch_size, num_beams, input_ids, repetition_penalty, ) # set eos token prob to zero if min_length is not reached if eos_token_id is not None and cur_len < min_length: scores[:, eos_token_id] = -10000 if no_repeat_ngram_size > 0: # calculate a list of banned tokens to prevent repetitively generating the same ngrams num_batch_hypotheses = batch_size * num_beams # from fairseq: https://github.com/pytorch/fairseq/blob/a07cb6f40480928c9e0548b737aadd36ee66ac76/fairseq/sequence_generator.py#L345 banned_batch_tokens = calc_banned_ngram_tokens(input_ids, num_batch_hypotheses, no_repeat_ngram_size, tokenizer=tokenizer) for i, banned_tokens in enumerate(banned_batch_tokens): scores[i, banned_tokens] = -10000 if bad_words_ids is not None: # calculate a list of banned tokens according to bad words banned_tokens = calc_banned_bad_words_ids(input_ids, bad_words_ids) for i, banned_tokens in enumerate(banned_tokens): scores[i, banned_tokens] = -10000 # add antonym banned list banned_tokens = calc_banned_antonym_words_ids(input_ids, tokenizer, antonym_dict) for i, banned_tokens in enumerate(banned_tokens): scores[i, banned_tokens] = -10000 scores[:, 0] = -50000 return scores def generate_no_beam(model_batch, full_context, model, tokenizer: EVATokenizer, args, device): target_length = args.max_generation_length dec_init_length = 1 # +1 for s_0 enc_input_ids = model_batch['enc_input_ids'] enc_attention_mask = model_batch['enc_attention_mask'] enc_outputs = model( enc_input_ids=enc_input_ids, enc_attention_mask=enc_attention_mask, only_encoder=True ) enc_hidden_states = enc_outputs["encoder_last_hidden_state"] batch_size = enc_input_ids.size(0) # for generating responses # we only use the <go> token, so truncate other tokens dec_input_ids = model_batch['dec_input_ids'][..., :dec_init_length] dec_attention_mask = model_batch['dec_attention_mask'][..., :dec_init_length, :dec_init_length] # we use past_key_values, so only the current token mask is needed cross_attention_mask = model_batch['cross_attention_mask'][..., :dec_init_length, :] unfinished_sents = enc_input_ids.new(enc_input_ids.size(0)).fill_(1) output_ids = enc_input_ids.new_zeros([enc_input_ids.size(0), 0]) # not include the prompt prob_idx = torch.arange(batch_size) past_key_values = None gen_len = 0 # construct antonym dict antonym_dict = construct_antonym_dict(args) while gen_len < target_length: if unfinished_sents.max() == 0: tokens_to_add = tokenizer.sep_id * (1 - unfinished_sents) output_ids = torch.cat([output_ids, tokens_to_add.unsqueeze(-1)], dim=-1) else: dec_outputs = model( dec_input_ids=dec_input_ids, dec_attention_mask=dec_attention_mask, cross_attention_mask=cross_attention_mask, enc_hidden_states=enc_hidden_states, past_key_values=past_key_values, ) past_key_values = dec_outputs['past_key_values'] lm_logits = dec_outputs['lm_logits'] gathered_lm_logits = [torch.zeros_like(lm_logits).to(device) for _ in range(mpu.get_model_parallel_world_size())] torch.distributed.all_gather(gathered_lm_logits, lm_logits.data, mpu.get_model_parallel_group()) lm_logits = torch.cat(gathered_lm_logits, dim=-1) logits = lm_logits[:, -1, :] / args.temperature prev_output_tokens = torch.cat([full_context, output_ids], dim=-1) logits = postprocess_next_token_scores( tokenizer=tokenizer, scores=logits, input_ids=prev_output_tokens, no_repeat_ngram_size=args.no_repeat_ngram_size, bad_words_ids=[[0]], cur_len=gen_len, min_length=args.min_generation_length, max_length=args.max_generation_length, eos_token_id=tokenizer.sep_id, repetition_penalty=args.repetition_penalty, batch_size=batch_size, num_beams=1, antonym_dict=antonym_dict ) logits = top_k_logits(logits, top_k=args.top_k, top_p=args.top_p) # next_token = torch.argmax(logits, dim=-1) probs = F.softmax(logits.float(), dim=-1) next_token = torch.multinomial(probs, num_samples=1).squeeze(1) tokens_to_add = next_token * unfinished_sents + tokenizer.sep_id * (1 - unfinished_sents) dec_input_ids = tokens_to_add.unsqueeze(-1) output_ids = torch.cat([output_ids, tokens_to_add.unsqueeze(-1)], dim=-1) # let the current token attend to all previous tokens dec_attention_mask = torch.cat([dec_attention_mask[:, :, -1:, :], dec_attention_mask[:, :, -1:, -1:]], dim=-1) cross_attention_mask = cross_attention_mask[:, :, -1:, :] gen_len += 1 unfinished_sents.mul_(tokens_to_add.ne(tokenizer.sep_id).long()) output_ids = output_ids.cpu().tolist() generation_token_ids_list = [] generation_str_list = [] for e in output_ids: generation_token_ids = e[:e.index(tokenizer.sep_id)] if tokenizer.sep_id in e else e generation_token_ids_list.append(generation_token_ids) generation_str_list.append(tokenizer.decode(generation_token_ids)) return generation_str_list, generation_token_ids_list def generate_beam(model_batch, full_context, model, tokenizer: EVATokenizer, args, device): ''' Since the context in model batch is truncated, we need full_context to store the tokens in the entire context. ''' num_beams = args.num_beams target_length = args.max_generation_length do_sample = args.top_p > 0 or args.top_k > 0 vocab_size = tokenizer.vocab_size enc_input_ids = model_batch['enc_input_ids'] enc_attention_mask = model_batch['enc_attention_mask'] enc_input_length = enc_input_ids.size(-1) batch_size = enc_input_ids.size(0) enc_input_ids = enc_input_ids.unsqueeze(1).expand(batch_size, num_beams, enc_input_length) enc_attention_mask = enc_attention_mask.unsqueeze(1).expand(batch_size, num_beams, 1, enc_input_length, enc_input_length) enc_input_ids = enc_input_ids.contiguous().view(batch_size * num_beams, enc_input_length) enc_attention_mask = enc_attention_mask.contiguous().view(batch_size * num_beams, 1, enc_input_length, enc_input_length) full_context = full_context.unsqueeze(1).expand(batch_size, num_beams, full_context.size(-1)) full_context = full_context.contiguous().view(batch_size * num_beams, full_context.size(-1)) enc_outputs = model( enc_input_ids=enc_input_ids, enc_attention_mask=enc_attention_mask, only_encoder=True )
class TestSequence(Enum): _init_ = 'sequence' _order_ = lambda member: member.sequence item_id = 'An$(1,6)', 0 # Item Code warehouse_no = 'An$(9,4)', 2 # Warehouse Number company = 'Hn$(13,6)', 3 # 4 SPACES + COMPANY company_id = 'An$(7,2)', 1 # Company Code inv_units = 'Qn$(7,2)', 10 # Inv Units available = 'Zn$(1,1)', 5 # Available? contract_item = 'Bn(2,1)', 6 # Contract Item? sales_category = 'Fn', 7 # Sales Category key_type = '<KEY>)', 4 # Key Type = '1**' gl_category = 'Rn$(5,1)', 8 # G/L Category warehouse_category = 'Sn$(6,1)', 9 # Warehouse Category def test_order_as_function_in_subclass(self): # class Parent(Enum): _init_ = 'value sequence' _order_ = lambda m: m.sequence # class Child(Parent): item_id = 'An$(1,6)', 0 # Item Code company_id = 'An$(7,2)', 1 # Company Code warehouse_no = 'An$(9,4)', 2 # Warehouse Number company = 'Hn$(13,6)', 3 # 4 SPACES + COMPANY key_type = '<KEY>)', 4 # Key Type = '1**' available = 'Zn$(1,1)', 5 # Available? contract_item = 'Bn(2,1)', 6 # Contract Item? sales_category = 'Fn', 7 # Sales Category gl_category = 'Rn$(5,1)', 8 # G/L Category warehouse_category = 'Sn$(6,1)', 9 # Warehouse Category inv_units = 'Qn$(7,2)', 10 # Inv Units # for i, member in enumerate(Child): self.assertEqual(i, member.sequence) # ts = Child self.assertEqual(ts.item_id.name, 'item_id') self.assertEqual(ts.item_id.value, 'An$(1,6)') self.assertEqual(ts.item_id.sequence, 0) self.assertEqual(ts.company_id.name, 'company_id') self.assertEqual(ts.company_id.value, 'An$(7,2)') self.assertEqual(ts.company_id.sequence, 1) self.assertEqual(ts.warehouse_no.name, 'warehouse_no') self.assertEqual(ts.warehouse_no.value, 'An$(9,4)') self.assertEqual(ts.warehouse_no.sequence, 2) self.assertEqual(ts.company.name, 'company') self.assertEqual(ts.company.value, 'Hn$(13,6)') self.assertEqual(ts.company.sequence, 3) self.assertEqual(ts.key_type.name, 'key_type') self.assertEqual(ts.key_type.value, 'Cn$(19,3)') self.assertEqual(ts.key_type.sequence, 4) self.assertEqual(ts.available.name, 'available') self.assertEqual(ts.available.value, 'Zn$(1,1)') self.assertEqual(ts.available.sequence, 5) self.assertEqual(ts.contract_item.name, 'contract_item') self.assertEqual(ts.contract_item.value, 'Bn(2,1)') self.assertEqual(ts.contract_item.sequence, 6) self.assertEqual(ts.sales_category.name, 'sales_category') self.assertEqual(ts.sales_category.value, 'Fn') self.assertEqual(ts.sales_category.sequence, 7) self.assertEqual(ts.gl_category.name, 'gl_category') self.assertEqual(ts.gl_category.value, 'Rn$(5,1)') self.assertEqual(ts.gl_category.sequence, 8) self.assertEqual(ts.warehouse_category.name, 'warehouse_category') self.assertEqual(ts.warehouse_category.value, 'Sn$(6,1)') self.assertEqual(ts.warehouse_category.sequence, 9) self.assertEqual(ts.inv_units.name, 'inv_units') self.assertEqual(ts.inv_units.value, 'Qn$(7,2)') self.assertEqual(ts.inv_units.sequence, 10) pass if StdlibEnumMeta is not None: def test_stdlib_inheritence(self): self.assertTrue(isinstance(self.Season, StdlibEnumMeta)) self.assertTrue(issubclass(self.Season, StdlibEnum)) def test_multiple_mixin(self): class MaxMixin(object): @classproperty def MAX(cls): max = len(cls) cls.MAX = max return max class StrMixin(object): def __str__(self): return self._name_.lower() class SomeEnum(Enum): def behavior(self): return 'booyah' class AnotherEnum(Enum): def behavior(self): return 'nuhuh!' def social(self): return "what's up?" class Color(MaxMixin, Enum): _order_ = 'RED GREEN BLUE' RED = auto() GREEN = auto() BLUE = auto() self.assertEqual(Color.RED.value, 1) self.assertEqual(Color.GREEN.value, 2) self.assertEqual(Color.BLUE.value, 3) self.assertEqual(Color.MAX, 3) self.assertEqual(str(Color.BLUE), 'Color.BLUE') class Color(MaxMixin, StrMixin, Enum): _order_ = 'RED GREEN BLUE' RED = auto() GREEN = auto() BLUE = auto() self.assertEqual(Color.RED.value, 1) self.assertEqual(Color.GREEN.value, 2) self.assertEqual(Color.BLUE.value, 3) self.assertEqual(Color.MAX, 3) self.assertEqual(str(Color.BLUE), 'blue', '%r is not %r' % (str(Color.BLUE), 'blue')) class Color(StrMixin, MaxMixin, Enum): _order_ = 'RED GREEN BLUE' RED = auto() GREEN = auto() BLUE = auto() self.assertEqual(Color.RED.value, 1) self.assertEqual(Color.GREEN.value, 2) self.assertEqual(Color.BLUE.value, 3) self.assertEqual(Color.MAX, 3) self.assertEqual(str(Color.BLUE), 'blue', '%r is not %r' % (str(Color.BLUE), 'blue')) class CoolColor(StrMixin, SomeEnum, Enum): _order_ = 'RED GREEN BLUE' RED = auto() GREEN = auto() BLUE = auto() self.assertEqual(CoolColor.RED.value, 1) self.assertEqual(CoolColor.GREEN.value, 2) self.assertEqual(CoolColor.BLUE.value, 3) self.assertEqual(str(CoolColor.BLUE), 'blue', '%r is not %r' % (str(Color.BLUE), 'blue')) self.assertEqual(CoolColor.RED.behavior(), 'booyah') class CoolerColor(StrMixin, AnotherEnum, Enum): _order_ = 'RED GREEN BLUE' RED = auto() GREEN = auto() BLUE = auto() self.assertEqual(CoolerColor.RED.value, 1) self.assertEqual(CoolerColor.GREEN.value, 2) self.assertEqual(CoolerColor.BLUE.value, 3) self.assertEqual(str(CoolerColor.BLUE), 'blue', '%r is not %r' % (str(Color.BLUE), 'blue')) self.assertEqual(CoolerColor.RED.behavior(), 'nuhuh!') self.assertEqual(CoolerColor.RED.social(), "what's up?") class CoolestColor(StrMixin, SomeEnum, AnotherEnum): _order_ = 'RED GREEN BLUE' RED = auto() GREEN = auto() BLUE = auto() self.assertEqual(CoolestColor.RED.value, 1) self.assertEqual(CoolestColor.GREEN.value, 2) self.assertEqual(CoolestColor.BLUE.value, 3) self.assertEqual(str(CoolestColor.BLUE), 'blue', '%r is not %r' % (str(Color.BLUE), 'blue')) self.assertEqual(CoolestColor.RED.behavior(), 'booyah') self.assertEqual(CoolestColor.RED.social(), "what's up?") class ConfusedColor(StrMixin, AnotherEnum, SomeEnum): _order_ = 'RED GREEN BLUE' RED = auto() GREEN = auto() BLUE = auto() self.assertEqual(ConfusedColor.RED.value, 1) self.assertEqual(ConfusedColor.GREEN.value, 2) self.assertEqual(ConfusedColor.BLUE.value, 3) self.assertEqual(str(ConfusedColor.BLUE), 'blue', '%r is not %r' % (str(Color.BLUE), 'blue')) self.assertEqual(ConfusedColor.RED.behavior(), 'nuhuh!') self.assertEqual(ConfusedColor.RED.social(), "what's up?") class ReformedColor(StrMixin, IntEnum, SomeEnum, AnotherEnum): _order_ = 'RED GREEN BLUE' RED = auto() GREEN = auto() BLUE = auto() self.assertEqual(ReformedColor.RED.value, 1) self.assertEqual(ReformedColor.GREEN.value, 2) self.assertEqual(ReformedColor.BLUE.value, 3) self.assertEqual(str(ReformedColor.BLUE), 'blue', '%r is not %r' % (str(Color.BLUE), 'blue')) self.assertEqual(ReformedColor.RED.behavior(), 'booyah') self.assertEqual(ConfusedColor.RED.social(), "what's up?") self.assertTrue(issubclass(ReformedColor, int)) def test_multiple_inherited_mixin(self): @unique class Decision1(StrEnum): REVERT = "REVERT" REVERT_ALL = "REVERT_ALL" RETRY = "RETRY" class MyEnum(StrEnum): pass @unique class Decision2(MyEnum): REVERT = "REVERT" REVERT_ALL = "REVERT_ALL" RETRY = "RETRY" def test_enum_of_types(self): """Support using Enum to refer to types deliberately.""" class MyTypes(Enum): i = int f = float s = str self.assertEqual(MyTypes.i.value, int) self.assertEqual(MyTypes.f.value, float) self.assertEqual(MyTypes.s.value, str) class Foo: pass class Bar: pass class MyTypes2(Enum): a = Foo b = Bar self.assertEqual(MyTypes2.a.value, Foo) self.assertEqual(MyTypes2.b.value, Bar) class SpamEnumNotInner: pass class SpamEnum(Enum): spam = SpamEnumNotInner self.assertEqual(SpamEnum.spam.value, SpamEnumNotInner) if pyver < 3.0: def test_nested_classes_in_enum_do_become_members(self): # manually set __qualname__ to remove testing framework noise class Outer(Enum): _order_ = 'a b Inner' __qualname__ = "Outer" a = 1 b = 2 class Inner(Enum): __qualname__ = "Outer.Inner" foo = 10 bar = 11 self.assertTrue(isinstance(Outer.Inner, Outer)) self.assertEqual(Outer.a.value, 1) self.assertEqual(Outer.Inner.value.foo.value, 10) self.assertEqual( list(Outer.Inner.value), [Outer.Inner.value.foo, Outer.Inner.value.bar], ) self.assertEqual( list(Outer), [Outer.a, Outer.b, Outer.Inner], ) def test_really_nested_classes_in_enum_do_become_members(self): class Outer(Enum): _order_ = 'a b Inner' a = 1 b = 2 class Inner(Enum): foo = 10 bar = 11 self.assertTrue(isinstance(Outer.Inner, Outer)) self.assertEqual(Outer.a.value, 1) self.assertEqual(Outer.Inner.value.foo.value, 10) self.assertEqual( list(Outer.Inner.value), [Outer.Inner.value.foo, Outer.Inner.value.bar], ) self.assertEqual( list(Outer), [Outer.a, Outer.b, Outer.Inner], ) def test_nested_classes_in_enum_are_skipped_with_skip(self): """Support locally-defined nested classes using @skip""" # manually set __qualname__ to remove testing framework noise class Outer(Enum): __qualname__ = "Outer" a = 1 b = 2 @skip class Inner(Enum): __qualname__ = "Outer.Inner" foo = 10 bar = 11 self.assertTrue(isinstance(Outer.Inner, type)) self.assertEqual(Outer.a.value, 1) self.assertEqual(Outer.Inner.foo.value, 10) self.assertEqual( list(Outer.Inner), [Outer.Inner.foo, Outer.Inner.bar], ) self.assertEqual( list(Outer), [Outer.a, Outer.b], ) def test_really_nested_classes_in_enum_are_skipped_with_skip(self): """Support locally-defined nested classes using @skip""" class Outer(Enum): a = 1 b = 2 @skip class Inner(Enum): foo = 10 bar = 11 self.assertTrue(isinstance(Outer.Inner, type)) self.assertEqual(Outer.a.value, 1) self.assertEqual(Outer.Inner.foo.value, 10) self.assertEqual( list(Outer.Inner), [Outer.Inner.foo, Outer.Inner.bar], ) self.assertEqual( list(Outer), [Outer.a, Outer.b], ) def test_enum_call_without_arg(self): class Color(Enum): black = 0 red = 1 green = 2 blue = 3 # @classmethod def _missing_value_(cls, value): if value is no_arg: return cls.black self.assertTrue(Color.red is Color(1)) self.assertTrue(Color.black is Color()) def test_init_subclass(self): class MyEnum(Enum): def __init_subclass__(cls, **kwds): super(MyEnum, cls).__init_subclass__(**kwds) self.assertFalse(cls.__dict__.get('_test', False)) cls._test1 = 'MyEnum' # class TheirEnum(MyEnum): def __init_subclass__(cls, **kwds): super(TheirEnum, cls).__init_subclass__(**kwds) cls._test2 = 'TheirEnum' class WhoseEnum(TheirEnum): def __init_subclass__(cls, **kwds): pass class NoEnum(WhoseEnum): ONE = 1 self.assertEqual(TheirEnum.__dict__['_test1'], 'MyEnum') self.assertEqual(WhoseEnum.__dict__['_test1'], 'MyEnum') self.assertEqual(WhoseEnum.__dict__['_test2'], 'TheirEnum') self.assertFalse(NoEnum.__dict__.get('_test1', False)) self.assertFalse(NoEnum.__dict__.get('_test2', False)) # class OurEnum(MyEnum): def __init_subclass__(cls, **kwds): cls._test2 = 'OurEnum' class WhereEnum(OurEnum): def __init_subclass__(cls, **kwds): pass class NeverEnum(WhereEnum): ONE = 'one' self.assertEqual(OurEnum.__dict__['_test1'], 'MyEnum') self.assertFalse(WhereEnum.__dict__.get('_test1', False)) self.assertEqual(WhereEnum.__dict__['_test2'], 'OurEnum') self.assertFalse(NeverEnum.__dict__.get('_test1', False)) self.assertFalse(NeverEnum.__dict__.get('_test2', False)) class TestStrEnum(TestCase): def test_set_name(self): class Descriptor(object): name = None def __get__(self, instance, owner_class=None): if instance is None: return self else: return instance.__dict__[self.name] def __set__(self, instance, value): instance.__dict__[self.name] = value def __set_name__(self, owner, name): self.name = name # class AnEnum(Enum): ONE = 'one' two = Descriptor() # self.assertEqual(list(AnEnum), [AnEnum.ONE]) self.assertEqual(AnEnum.two.name, 'two') AnEnum.ONE.two = 'three' self.assertEqual(AnEnum.ONE.two, 'three') self.assertEqual(AnEnum.ONE.__dict__['two'], 'three') def test_private_names(self): class Private(Enum): __corporal = 'Radar' __major_ = 'Hoolihan' self.assertEqual(len(Private), 0) self.assertEqual(Private._Private__corporal, 'Radar') self.assertFalse(isinstance(Private._Private__corporal, Enum)) self.assertEqual(Private._Private__major_, 'Hoolihan') self.assertFalse(isinstance(Private._Private__major_, Enum)) def test_strenum_inherited_methods(self): class phy(StrEnum): pi = 'Pi' tau = 'Tau' self.assertTrue(phy.pi < phy.tau) self.assertEqual(phy.pi.upper(), 'PI') self.assertEqual(phy.tau.count('a'), 1) def test_strict_strenum(self): with self.assertRaisesRegex(TypeError, r'too many arguments for str'): class Huh(StrEnum): huh = 'this', 'is', 'too', 'many' for uhoh in (object, object(), [], Enum, 9): with self.assertRaisesRegex(TypeError, r'values must be str'): class Huh(StrEnum): huh = uhoh # class Either(StrEnum): _order_ = 'this that Those lower upper' this = auto() that = 'That' Those = auto() lower = 'lower' upper = 'UPPER' self.assertEqual([m.value for m in Either], ['this', 'That', 'those', 'lower', 'UPPER']) # with self.assertRaisesRegex(ValueError, r' is not lower-case'): class Huh(LowerStrEnum): huh = 'What' # class Lower(LowerStrEnum): _order_ = 'this that Those lower upper' this = auto() that = 'that' Those = auto() lower = 'lower' upper = 'upper' self.assertEqual([m.value for m in Lower], ['this', 'that', 'those', 'lower', 'upper']) # with self.assertRaisesRegex(ValueError, r' is not upper-case'): class Huh(UpperStrEnum): huh = 'What' # class Upper(UpperStrEnum): _order_ = 'this that Those lower upper' this = auto() that = 'THAT' Those = auto() lower = 'LOWER' upper = 'UPPER' self.assertEqual([m.value for m in Upper], ['THIS', 'THAT', 'THOSE', 'LOWER', 'UPPER']) def test_init_subclass(self): class MyEnum(StrEnum): def __init_subclass__(cls, **kwds): super(MyEnum, cls).__init_subclass__(**kwds) self.assertFalse(cls.__dict__.get('_test', False)) cls._test1 = 'MyEnum' # class TheirEnum(MyEnum): def __init_subclass__(cls, **kwds): super(TheirEnum, cls).__init_subclass__(**kwds) cls._test2 = 'TheirEnum' class WhoseEnum(TheirEnum): def __init_subclass__(cls, **kwds): pass
121.4*m.x682 == 0) m.c1643 = Constraint(expr= m.x143 - m.x148 + 728.4*m.x673 + 364.2*m.x678 + 121.4*m.x683 == 0) m.c1644 = Constraint(expr= m.x144 - m.x149 + 728.4*m.x674 + 364.2*m.x679 + 121.4*m.x684 == 0) m.c1645 = Constraint(expr= m.x145 - m.x150 + 728.4*m.x675 + 364.2*m.x680 + 121.4*m.x685 == 0) m.c1646 = Constraint(expr= m.x146 - m.x151 + 728.4*m.x686 + 364.2*m.x691 + 121.4*m.x696 == 0) m.c1647 = Constraint(expr= m.x147 - m.x152 + 728.4*m.x687 + 364.2*m.x692 + 121.4*m.x697 == 0) m.c1648 = Constraint(expr= m.x148 - m.x153 + 728.4*m.x688 + 364.2*m.x693 + 121.4*m.x698 == 0) m.c1649 = Constraint(expr= m.x149 - m.x154 + 728.4*m.x689 + 364.2*m.x694 + 121.4*m.x699 == 0) m.c1650 = Constraint(expr= m.x150 - m.x155 + 728.4*m.x690 + 364.2*m.x695 + 121.4*m.x700 == 0) m.c1651 = Constraint(expr= m.x151 - m.x156 + 728.4*m.x701 + 364.2*m.x706 + 121.4*m.x711 == 0) m.c1652 = Constraint(expr= m.x152 - m.x157 + 728.4*m.x702 + 364.2*m.x707 + 121.4*m.x712 == 0) m.c1653 = Constraint(expr= m.x153 - m.x158 + 728.4*m.x703 + 364.2*m.x708 + 121.4*m.x713 == 0) m.c1654 = Constraint(expr= m.x154 - m.x159 + 728.4*m.x704 + 364.2*m.x709 + 121.4*m.x714 == 0) m.c1655 = Constraint(expr= m.x155 - m.x160 + 728.4*m.x705 + 364.2*m.x710 + 121.4*m.x715 == 0) m.c1656 = Constraint(expr= m.x156 - m.x161 + 728.4*m.x716 + 364.2*m.x721 + 121.4*m.x726 == 0) m.c1657 = Constraint(expr= m.x157 - m.x162 + 728.4*m.x717 + 364.2*m.x722 + 121.4*m.x727 == 0) m.c1658 = Constraint(expr= m.x158 - m.x163 + 728.4*m.x718 + 364.2*m.x723 + 121.4*m.x728 == 0) m.c1659 = Constraint(expr= m.x159 - m.x164 + 728.4*m.x719 + 364.2*m.x724 + 121.4*m.x729 == 0) m.c1660 = Constraint(expr= m.x160 - m.x165 + 728.4*m.x720 + 364.2*m.x725 + 121.4*m.x730 == 0) m.c1661 = Constraint(expr= m.x161 - m.x166 + 728.4*m.x731 + 364.2*m.x736 + 121.4*m.x741 == 0) m.c1662 = Constraint(expr= m.x162 - m.x167 + 728.4*m.x732 + 364.2*m.x737 + 121.4*m.x742 == 0) m.c1663 = Constraint(expr= m.x163 - m.x168 + 728.4*m.x733 + 364.2*m.x738 + 121.4*m.x743 == 0) m.c1664 = Constraint(expr= m.x164 - m.x169 + 728.4*m.x734 + 364.2*m.x739 + 121.4*m.x744 == 0) m.c1665 = Constraint(expr= m.x165 - m.x170 + 728.4*m.x735 + 364.2*m.x740 + 121.4*m.x745 == 0) m.c1666 = Constraint(expr= m.x166 - m.x171 + 728.4*m.x746 + 364.2*m.x751 + 121.4*m.x756 == 0) m.c1667 = Constraint(expr= m.x167 - m.x172 + 728.4*m.x747 + 364.2*m.x752 + 121.4*m.x757 == 0) m.c1668 = Constraint(expr= m.x168 - m.x173 + 728.4*m.x748 + 364.2*m.x753 + 121.4*m.x758 == 0) m.c1669 = Constraint(expr= m.x169 - m.x174 + 728.4*m.x749 + 364.2*m.x754 + 121.4*m.x759 == 0) m.c1670 = Constraint(expr= m.x170 - m.x175 + 728.4*m.x750 + 364.2*m.x755 + 121.4*m.x760 == 0) m.c1671 = Constraint(expr= m.x171 - m.x176 + 728.4*m.x761 + 364.2*m.x766 + 121.4*m.x771 == 0) m.c1672 = Constraint(expr= m.x172 - m.x177 + 728.4*m.x762 + 364.2*m.x767 + 121.4*m.x772 == 0) m.c1673 = Constraint(expr= m.x173 - m.x178 + 728.4*m.x763 + 364.2*m.x768 + 121.4*m.x773 == 0) m.c1674 = Constraint(expr= m.x174 - m.x179 + 728.4*m.x764 + 364.2*m.x769 + 121.4*m.x774 == 0) m.c1675 = Constraint(expr= m.x175 - m.x180 + 728.4*m.x765 + 364.2*m.x770 + 121.4*m.x775 == 0) m.c1676 = Constraint(expr= m.x176 - m.x181 + 728.4*m.x776 + 364.2*m.x781 + 121.4*m.x786 == 0) m.c1677 = Constraint(expr= m.x177 - m.x182 + 728.4*m.x777 + 364.2*m.x782 + 121.4*m.x787 == 0) m.c1678 = Constraint(expr= m.x178 - m.x183 + 728.4*m.x778 + 364.2*m.x783 + 121.4*m.x788 == 0) m.c1679 = Constraint(expr= m.x179 - m.x184 + 728.4*m.x779 + 364.2*m.x784 + 121.4*m.x789 == 0) m.c1680 = Constraint(expr= m.x180 - m.x185 + 728.4*m.x780 + 364.2*m.x785 + 121.4*m.x790 == 0) m.c1681 = Constraint(expr= m.x181 - m.x186 + 728.4*m.x791 + 364.2*m.x796 + 121.4*m.x801 == 0) m.c1682 = Constraint(expr= m.x182 - m.x187 + 728.4*m.x792 + 364.2*m.x797 + 121.4*m.x802 == 0) m.c1683 = Constraint(expr= m.x183 - m.x188 + 728.4*m.x793 + 364.2*m.x798 + 121.4*m.x803 == 0) m.c1684 = Constraint(expr= m.x184 - m.x189 + 728.4*m.x794 + 364.2*m.x799 + 121.4*m.x804 == 0) m.c1685 = Constraint(expr= m.x185 - m.x190 + 728.4*m.x795 + 364.2*m.x800 + 121.4*m.x805 == 0) m.c1686 = Constraint(expr= m.x186 - m.x191 + 728.4*m.x806 + 364.2*m.x811 + 121.4*m.x816 == 0) m.c1687 = Constraint(expr= m.x187 - m.x192 + 728.4*m.x807 + 364.2*m.x812 + 121.4*m.x817 == 0) m.c1688 = Constraint(expr= m.x188 - m.x193 + 728.4*m.x808 + 364.2*m.x813 + 121.4*m.x818 == 0) m.c1689 = Constraint(expr= m.x189 - m.x194 + 728.4*m.x809 + 364.2*m.x814 + 121.4*m.x819 == 0) m.c1690 = Constraint(expr= m.x190 - m.x195 + 728.4*m.x810 + 364.2*m.x815 + 121.4*m.x820 == 0) m.c1691 = Constraint(expr= m.x191 - m.x196 + 728.4*m.x821 + 364.2*m.x826 + 121.4*m.x831 == 0) m.c1692 = Constraint(expr= m.x192 - m.x197 + 728.4*m.x822 + 364.2*m.x827 + 121.4*m.x832 == 0) m.c1693 = Constraint(expr= m.x193 - m.x198 + 728.4*m.x823 + 364.2*m.x828 + 121.4*m.x833 == 0) m.c1694 = Constraint(expr= m.x194 - m.x199 + 728.4*m.x824 + 364.2*m.x829 + 121.4*m.x834 == 0) m.c1695 = Constraint(expr= m.x195 - m.x200 + 728.4*m.x825 + 364.2*m.x830 + 121.4*m.x835 == 0) m.c1696 = Constraint(expr= m.x196 - m.x201 + 728.4*m.x836 + 364.2*m.x841 + 121.4*m.x846 == 0) m.c1697 = Constraint(expr= m.x197 - m.x202 + 728.4*m.x837 + 364.2*m.x842 + 121.4*m.x847 == 0) m.c1698 = Constraint(expr= m.x198 - m.x203 + 728.4*m.x838 + 364.2*m.x843 + 121.4*m.x848 == 0) m.c1699 = Constraint(expr= m.x199 - m.x204 + 728.4*m.x839 + 364.2*m.x844 + 121.4*m.x849 == 0) m.c1700 = Constraint(expr= m.x200 - m.x205 + 728.4*m.x840 + 364.2*m.x845 + 121.4*m.x850 == 0) m.c1701 = Constraint(expr= m.x201 - m.x206 + 728.4*m.x851 + 364.2*m.x856 + 121.4*m.x861 == 0) m.c1702 = Constraint(expr= m.x202 - m.x207 + 728.4*m.x852 + 364.2*m.x857 + 121.4*m.x862 == 0) m.c1703 = Constraint(expr= m.x203 - m.x208 + 728.4*m.x853 + 364.2*m.x858 + 121.4*m.x863 == 0) m.c1704 = Constraint(expr= m.x204 - m.x209 + 728.4*m.x854 + 364.2*m.x859 + 121.4*m.x864 == 0) m.c1705 = Constraint(expr= m.x205 - m.x210 + 728.4*m.x855 + 364.2*m.x860 + 121.4*m.x865 == 0) m.c1706 = Constraint(expr= m.x206 - m.x211 + 728.4*m.x866 + 364.2*m.x871 + 121.4*m.x876 == 0) m.c1707 = Constraint(expr= m.x207 - m.x212 + 728.4*m.x867 + 364.2*m.x872 + 121.4*m.x877 == 0) m.c1708 = Constraint(expr= m.x208 - m.x213 + 728.4*m.x868 + 364.2*m.x873 + 121.4*m.x878 == 0) m.c1709 = Constraint(expr= m.x209 - m.x214 + 728.4*m.x869 + 364.2*m.x874 + 121.4*m.x879 == 0) m.c1710 = Constraint(expr= m.x210 - m.x215 + 728.4*m.x870 + 364.2*m.x875 + 121.4*m.x880 == 0) m.c1711 = Constraint(expr= m.x211 - m.x216 + 728.4*m.x881 + 364.2*m.x886 + 121.4*m.x891 == 0) m.c1712 = Constraint(expr= m.x212 - m.x217 + 728.4*m.x882 + 364.2*m.x887 + 121.4*m.x892 == 0) m.c1713 = Constraint(expr= m.x213 - m.x218 + 728.4*m.x883 + 364.2*m.x888 + 121.4*m.x893 == 0) m.c1714 = Constraint(expr= m.x214 - m.x219 + 728.4*m.x884 + 364.2*m.x889 + 121.4*m.x894 == 0) m.c1715 = Constraint(expr= m.x215 - m.x220 + 728.4*m.x885 + 364.2*m.x890 + 121.4*m.x895 == 0) m.c1716 = Constraint(expr= m.x216 - m.x221 + 728.4*m.x896 + 364.2*m.x901 + 121.4*m.x906 == 0) m.c1717 = Constraint(expr= m.x217 - m.x222 + 728.4*m.x897 + 364.2*m.x902 + 121.4*m.x907 == 0) m.c1718 = Constraint(expr= m.x218 - m.x223 + 728.4*m.x898 + 364.2*m.x903 + 121.4*m.x908 == 0) m.c1719 = Constraint(expr= m.x219 - m.x224 + 728.4*m.x899 + 364.2*m.x904 + 121.4*m.x909 == 0) m.c1720 = Constraint(expr= m.x220 - m.x225 + 728.4*m.x900 + 364.2*m.x905 + 121.4*m.x910 == 0) m.c1721 = Constraint(expr= m.x221 - m.x226 + 728.4*m.x911 + 364.2*m.x916 + 121.4*m.x921 == 0) m.c1722 = Constraint(expr= m.x222 - m.x227 + 728.4*m.x912 + 364.2*m.x917 + 121.4*m.x922 == 0) m.c1723 = Constraint(expr= m.x223 - m.x228 + 728.4*m.x913 + 364.2*m.x918 + 121.4*m.x923 == 0) m.c1724 = Constraint(expr= m.x224 - m.x229 + 728.4*m.x914 + 364.2*m.x919 + 121.4*m.x924 == 0) m.c1725 = Constraint(expr= m.x225 - m.x230 + 728.4*m.x915 + 364.2*m.x920 + 121.4*m.x925 == 0) m.c1726 = Constraint(expr= m.x226 - m.x231 + 728.4*m.x926 + 364.2*m.x931 + 121.4*m.x936 == 0) m.c1727 = Constraint(expr= m.x227 - m.x232 + 728.4*m.x927 + 364.2*m.x932 + 121.4*m.x937 == 0) m.c1728 = Constraint(expr= m.x228 - m.x233 + 728.4*m.x928 + 364.2*m.x933 + 121.4*m.x938 == 0) m.c1729 = Constraint(expr= m.x229 - m.x234 + 728.4*m.x929 + 364.2*m.x934 + 121.4*m.x939 == 0) m.c1730 = Constraint(expr= m.x230 - m.x235 + 728.4*m.x930 + 364.2*m.x935 + 121.4*m.x940 == 0) m.c1731 = Constraint(expr= m.x231 - m.x236 + 728.4*m.x941 + 364.2*m.x946 + 121.4*m.x951 == 0) m.c1732 = Constraint(expr= m.x232 - m.x237 + 728.4*m.x942 + 364.2*m.x947 + 121.4*m.x952 == 0) m.c1733 = Constraint(expr= m.x233 - m.x238 + 728.4*m.x943 + 364.2*m.x948 + 121.4*m.x953 == 0) m.c1734 = Constraint(expr= m.x234 - m.x239 + 728.4*m.x944 + 364.2*m.x949 + 121.4*m.x954 == 0) m.c1735 = Constraint(expr= m.x235 - m.x240 + 728.4*m.x945 + 364.2*m.x950 + 121.4*m.x955 == 0) m.c1736 = Constraint(expr= m.x236 - m.x241 + 728.4*m.x956 + 364.2*m.x961 + 121.4*m.x966 == 0) m.c1737 = Constraint(expr= m.x237 - m.x242 + 728.4*m.x957 + 364.2*m.x962 + 121.4*m.x967 == 0) m.c1738 = Constraint(expr= m.x238 - m.x243 + 728.4*m.x958 + 364.2*m.x963 + 121.4*m.x968 == 0) m.c1739 = Constraint(expr= m.x239 - m.x244 + 728.4*m.x959 + 364.2*m.x964 + 121.4*m.x969 == 0) m.c1740 = Constraint(expr= m.x240 - m.x245 + 728.4*m.x960 + 364.2*m.x965 + 121.4*m.x970 == 0) m.c1741 = Constraint(expr= m.x241
'black' `markerfacecolor` = 'white' `marker` = 'o', `markersize` = 4.0. Returns ------- :c:`matplotlib.axes.Axes` The axes that the :a:`nodes` were plotted on. Examples -------- >>> # initialize a mesh and plot the nodes >>> import matplotlib.pyplot as plt >>> import vcfempy.meshgen >>> msh = vcfempy.meshgen.PolyMesh2D('test mesh') >>> msh.add_vertices([[0, 0], [0, 1], [1, 1], [1, 0]]) >>> msh.insert_boundary_vertices(0, [0, 1, 2, 3]) >>> rock = vcfempy.materials.Material('rock', color='xkcd:greenish') >>> mr = vcfempy.meshgen.MaterialRegion2D(msh, msh.boundary_vertices, ... rock, 'rock region') >>> msh.mesh_scale = 0.2 >>> msh.mesh_rand = 0.2 >>> msh.generate_mesh() >>> fig = plt.figure() >>> ax = msh.plot_mesh() >>> ax = msh.plot_vertices() >>> ax = msh.plot_nodes() >>> xmin, xmax, ymin, ymax = ax.axis('equal') >>> xtext = ax.set_xlabel('x') >>> ytext = ax.set_ylabel('y') >>> ttext = ax.set_title('PolyMesh2D Nodes Test Plot') >>> plt.savefig('PolyMesh2D_nodes_test_plot.png') """ if ax is None or not isinstance(ax, plt.Axes): ax = plt.gca() if 'linewidth' not in kwargs.keys(): kwargs['linewidth'] = 0.0 if 'markeredgecolor' not in kwargs.keys(): kwargs['markeredgecolor'] = 'black' if 'markerfacecolor' not in kwargs.keys(): kwargs['markerfacecolor'] = 'white' if 'marker' not in kwargs.keys(): kwargs['marker'] = 'o' if 'markersize' not in kwargs.keys(): kwargs['markersize'] = 4.0 ax.plot(self.nodes[:, 0], self.nodes[:, 1], **kwargs) return ax class MaterialRegion2D(): """A class for defining material regions and their attributes for meshes generated by a :c:`PolyMesh2D`.. Parameters ---------- mesh : :c:`PolyMesh2D` The parent mesh. Sets :a:`mesh`. vertices : list[int], optional Initial list of vertices defining the :c:`MaterialRegion2D`. Passed to :m:`insert_vertices`. material : :c:`vcfempy.materials.Material`, optional The material type of the :c:`MaterialRegion2D`. Sets :a:`material`. name : str, optional A descriptive name for the :c:`MaterialRegion2D`. If not provided, will be set to a default 'Unnamed Material Region {`k`}' where `k` is a counter for how many :c:`MaterialRegion2D` have been created. Other Parameters ---------------- add_to_mesh : bool, optional, default=True Flag for whether to add the :c:`MaterialRegion2D` to its parent mesh. This is done by default when the :c:`MaterialRegion2D` is created. Examples -------- >>> # initialize a mesh, no material regions added >>> import vcfempy.meshgen >>> msh = vcfempy.meshgen.PolyMesh2D('test mesh') >>> msh.add_vertices([[0, 0], [0, 1], [1, 1], [1, 0]]) >>> msh.insert_boundary_vertices(0, [0, 1, 2, 3]) >>> print(msh.num_material_regions) 0 >>> # create a material region, this will add it to its parent mesh >>> import vcfempy.materials >>> rock_material = vcfempy.materials.Material('rock material') >>> rock_region = vcfempy.meshgen.MaterialRegion2D(msh, [0, 1, 2, 3], ... rock_material, ... 'rock region') >>> print(msh.num_material_regions) 1 >>> print(rock_region in msh.material_regions) True >>> print(rock_region.name) rock region >>> print(rock_region.material.name) rock material >>> print(rock_region.vertices) [0, 1, 2, 3] >>> # generate a mesh, then change material region material >>> # this clears the mesh >>> msh.mesh_scale = 0.4 >>> msh.add_seed_points([0.5, 0.5]) >>> msh.generate_mesh() >>> print(msh.mesh_valid) True >>> rock_region.material = None >>> print(rock_region.material) None >>> print(msh.mesh_valid) False >>> # regenerate the mesh, then change the material region vertices >>> # this also clears the mesh >>> # note that the material region need not be fully inside the >>> # mesh boundaries >>> msh.generate_mesh() >>> print(msh.mesh_valid) True >>> msh.add_vertices([0.5, 1.5]) >>> print(msh.mesh_valid) True >>> rock_region.insert_vertices(2, 4) >>> print(rock_region.vertices) [0, 1, 4, 2, 3] >>> print(msh.mesh_valid) False """ _num_created = 0 def __init__(self, mesh, vertices=None, material=None, name=None, add_to_mesh=True): if not isinstance(mesh, PolyMesh2D): raise TypeError('type(mesh) must be vcfempy.meshgen.PolyMesh2D') self._mesh = mesh if add_to_mesh: self.mesh.add_material_region(self) if name is None: name = ('Unnamed Material Region ' + f'{MaterialRegion2D._num_created}') self.name = name MaterialRegion2D._num_created += 1 self._vertices = [] self.insert_vertices(0, vertices) self.material = material @property def name(self): """A descriptive name for the :c:`MaterialRegion2D`. Parameters ---------- name : str The name of the :c:`MaterialRegion2D`. Will be cast to `str` regardless of type. Returns ------- `str` The :a:`name` of the :c:`MaterialRegion2D`. Examples -------- >>> # create a blank material region without a name (reset counter) >>> import vcfempy.meshgen >>> vcfempy.meshgen.MaterialRegion2D._num_created = 0 >>> msh = vcfempy.meshgen.PolyMesh2D() >>> mr = vcfempy.meshgen.MaterialRegion2D(msh) >>> print(mr.name) Unnamed Material Region 0 >>> # setting the name >>> mr.name = 'Rock region' >>> print(mr.name) Rock region >>> # changing the name property to non-str >>> # will be cast to str >>> mr.name = 1 >>> print(mr.name) 1 >>> print(type(mr.name).__name__) str >>> # initialize a material region with a name >>> mr = vcfempy.meshgen.MaterialRegion2D(mesh=msh, name='new region') >>> print(mr.name) new region >>> # initialize another material region without a name >>> # notice that the "Unnamed" counter increases for every region >>> # created (including those that were assigned an initial name) >>> mr = vcfempy.meshgen.MaterialRegion2D(msh) >>> print(mr.name) Unnamed Material Region 2 """ return self._name @name.setter def name(self, name): self._name = str(name) @property def mesh(self): """The parent :c:`PolyMesh2D` of the :c:`MaterialRegion2D`. Returns ------- :c:`PolyMesh2D` The parent mesh object Note ---- This property is immutable to ensure connection between a :c:`PolyMesh2D` and a :c:`MaterialRegion2D`. Examples -------- >>> # create a mesh and a material region >>> # note that creating the material region requires a parent mesh >>> # and the material region will add itself to the list of parent >>> # mesh material regions by default >>> import vcfempy.meshgen >>> msh = vcfempy.meshgen.PolyMesh2D('test mesh') >>> mr = vcfempy.meshgen.MaterialRegion2D(msh) >>> print(mr.mesh.name) test mesh >>> print(mr in msh.material_regions) True >>> # try to set parent mesh (immutable) >>> new_mesh = vcfempy.meshgen.PolyMesh2D() >>> mr.mesh = new_mesh Traceback (most recent call last): ... AttributeError: can't set attribute """ return self._mesh @property def num_vertices(self): """Number of vertices defining the :c:`MaterialRegion2D` geometry. Returns ------- `int` The number of :a:`vertices` in the :c:`MaterialRegion2D`. Examples -------- >>> # creating a material region, no initial vertices provided >>> import vcfempy.meshgen >>> msh = vcfempy.meshgen.PolyMesh2D() >>> mr = vcfempy.meshgen.MaterialRegion2D(msh) >>> print(mr.num_vertices) 0 >>> # creating a material region, providing initial vertices >>> # these are indices referencing vertices in the parent mesh >>> new_verts = [[0, 0], [0, 1], [1, 1], [1, 0]] >>> msh.add_vertices(new_verts) >>> mr.insert_vertices(0, [k for k, _ in enumerate(new_verts)]) >>> print(mr.num_vertices) 4 >>> # add a vertex and check num_vertices >>> msh.add_vertices([1.5, 0.5]) >>> mr.insert_vertices(3, 4) >>> print(mr.num_vertices) 5 """ return len(self.vertices) @property def vertices(self): """List of vertex indices defining the boundary of the :c:`MaterialRegion2D`. Returns ------- `list[int]` The list of vertex indices referencing :a:`PolyMesh2D.vertices` of :a:`mesh`. Examples -------- >>> # creating a material region, no initial vertices provided >>> import vcfempy.meshgen >>> msh = vcfempy.meshgen.PolyMesh2D() >>> mr = vcfempy.meshgen.MaterialRegion2D(msh) >>> print(mr.num_vertices) 0 >>> # creating a material region, providing initial vertices >>> # these are indices referencing vertices in the parent mesh >>> new_verts = [[0, 0], [0, 1], [1, 1], [1, 0]] >>> msh.add_vertices(new_verts) >>> mr.insert_vertices(0, [k for k, _ in enumerate(new_verts)]) >>> print(mr.vertices) [0, 1, 2, 3] >>> print(msh.vertices[mr.vertices, :]) [[0. 0.] [0. 1.] [1. 1.] [1. 0.]] >>> # add a vertex and check vertices >>> msh.add_vertices([1.5, 0.5]) >>> mr.insert_vertices(3, 4) >>> print(mr.vertices) [0, 1, 2, 4, 3] >>> print(msh.vertices[mr.vertices, :]) [[0. 0. ] [0. 1. ] [1. 1. ] [1.5 0.5] [1. 0. ]] """ return self._vertices @property def material(self): """The :c:`vcfempy.materials.Material` assigned to the :c:`MaterialRegion2D`. Parameters ---------- material : None | :c:`vcfempy.materials.Material` The material type to assign to the :c:`MaterialRegion2D`. Returns ------- ``None`` | :c:`vcfempy.materials.Material` The material type assigned to the :c:`MaterialRegion2D`. Raises ------ TypeError If **material** is not ``None`` or a :c:`vcfempy.materials.Material`. Examples -------- >>> # create a material region, no material type assigned >>> import vcfempy.materials >>> import vcfempy.meshgen >>> msh = vcfempy.meshgen.PolyMesh2D() >>> msh.add_vertices([[0, 0], [0, 1], [1, 1], [1, 0]]) >>> msh.insert_boundary_vertices(0, [0, 1, 2, 3]) >>> mr = vcfempy.meshgen.MaterialRegion2D(msh, msh.boundary_vertices, ... name='rock region') >>> print(mr in msh.material_regions) True >>> print(mr.material) None >>> # assign a material type to the material region >>> rock = vcfempy.materials.Material('rock') >>> mr.material = rock >>> print(mr.material.name) rock >>> # changing material type of a material region resets the mesh >>> msh.mesh_scale = 0.4 >>> msh.add_seed_points([0.5, 0.5]) >>> msh.generate_mesh() >>> print(msh.mesh_valid) True >>> mr.material = None >>> print(mr.material) None >>> print(msh.mesh_valid) False >>> # try to assign invalid materials to a material region >>> mr.material = 1 Traceback (most recent call
#!/usr/local/bin/python3 # -*- coding: utf-8 -*- """ * Copyright (C) 2021 <NAME> * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided 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 "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. */ """ import requests, json, sys import xml.dom.minidom import datetime from urllib.request import Request, urlopen from urllib.error import HTTPError, URLError def getconfigelement(path): try: tree = config for node in path.split('/'): tree = tree.getElementsByTagName(node) if len(tree) == 0: return False tree = tree[0] return tree.firstChild.nodeValue except: return False def vpnapi(): key = getconfigelement('OPNsense/ipcheck/vpnapikey') apikey= "?key="+key if key else "" if ipv4: try: url = Request("https://vpnapi.io/api/"+ipv4+apikey) url.add_header('User-Agent', 'Mozilla/5.0') out['ipv4']['vpnapi'] = json.load(urlopen(url, timeout=4)) if debug: out['ipv4']['vpnapi']['apikey'] = key m = out['ipv4']['vpnapi'].get('message') out['ipv4']['vpnapi']['status'] = m if m else "ok" except: pass if ipv6: try: url = Request("https://vpnapi.io/api/"+ipv6+apikey) url.add_header('User-Agent', 'Mozilla/5.0') out['ipv6']['vpnapi'] = json.load(urlopen(url, timeout=4)) if debug: out['ipv6']['vpnapi']['apikey'] = key m = out['ipv6']['vpnapi'].get('message') out['ipv6']['vpnapi']['status'] = m if m else "ok" except: pass return def proxycheck(): key = getconfigelement('OPNsense/ipcheck/proxycheckkey') apikey= 'key='+key+'&' if key else "" if ipv4: try: url = Request("http://proxycheck.io/v2/"+ipv4+"?"+apikey+"vpn=1&asn=1&risk=1&port=1&seen=1") url.add_header('User-Agent', 'Mozilla/5.0') ret = json.load(urlopen(url, timeout=4)) out['ipv4']['proxycheck']={} out['ipv4']['proxycheck']['status'] = ret['status'] out['ipv4']['proxycheck'] = ret[ipv4] if debug: out['ipv4']['proxycheck']['apikey'] = key except: pass if ipv6: try: url = Request("http://proxycheck.io/v2/"+ipv6+"?"+apikey+"vpn=1&asn=1&risk=1&port=1&seen=1") url.add_header('User-Agent', 'Mozilla/5.0') ret = json.load(urlopen(url, timeout=4)) out['ipv6']['proxycheck']={} out['ipv6']['proxycheck']['status'] = ret['status'] out['ipv6']['proxycheck'] = ret[ipv6] if debug: out['ipv6']['proxycheck']['apikey'] = key except: pass return def ip2loc(): key = getconfigelement('OPNsense/ipcheck/ip2lockey') apikey= key if key else "demo" if ipv4: try: url = Request("https://api.ip2location.com/v2/?ip="+ipv4+"&key="+apikey+"&format=json&package=WS8") out['ipv4']['ip2location'] = json.load(urlopen(url, timeout=4)) out['ipv4']['ip2location']['apikey'] = key except: pass if ipv6: try: pass url = Request("https://api.ip2location.com/v2/?ip="+ipv6+"&key="+apikey+"&format=json&package=WS8") out['ipv6']['ip2location'] = json.load(urlopen(url, timeout=4)) out['ipv6']['ip2location']['apikey'] = key except: pass return def ip2proxy(): key = getconfigelement('OPNsense/ipcheck/ip2proxykey') apikey= key if key else "demo" if ipv4: try: url = Request("https://api.ip2proxy.com/?ip="+ipv4+"&key="+apikey+"&package=PX10") out['ipv4']['ip2proxy'] = json.load(urlopen(url, timeout=4)) out['ipv4']['ip2proxy']['apikey'] = key except: pass if ipv6: try: url = Request("https://api.ip2proxy.com/?ip="+ipv6+"&key="+apikey+"&package=PX10") out['ipv6']['ip2proxy'] = json.load(urlopen(url, timeout=4)) out['ipv6']['ip2proxy']['apikey'] = key except: pass return def onionoo(): if ipv4: try: out['ipv4']['onionoo']={} url = Request("https://onionoo.torproject.org/details?limit=4&search="+ipv4) ret = json.load(urlopen(url, timeout=4)) if len(ret['relays']): out['ipv4']['onionoo']['relay'] = (ret['relays'][0]) if len(ret['bridges']): out['ipv4']['onionoo']['bridge'] = (ret['relays'][0]) except: pass if ipv6: try: out['ipv6']['onionoo']={} url = Request("https://onionoo.torproject.org/details?limit=4&search="+ipv6) ret = json.load(urlopen(url, timeout=4)) if len(ret['relays']): out['ipv6']['onionoo']['relay'] = (ret['relays'][0]) if len(ret['bridges']): out['ipv6']['onionoo']['bridge'] = (ret['relays'][0]) except: pass return def ipqs(): key = getconfigelement('OPNsense/ipcheck/ipqskey') apikey= key if key else "false" if ipv4: try: url = Request("https://ipqualityscore.com/api/json/ip/"+apikey+"/"+ipv4+"?strictness=0") url.add_header('User-Agent', 'Mozilla/5.0') out['ipv4']['ipqs'] = json.load(urlopen(url, timeout=4)) if debug: out['ipv4']['ipqs']['apikey'] = key except: pass if ipv6: try: url = Request("https://ipqualityscore.com/api/json/ip/"+apikey+"/"+ipv6+"?strictness=0") url.add_header('User-Agent', 'Mozilla/5.0') out['ipv6']['ipqs'] = json.load(urlopen(url, timeout=4)) if debug: out['ipv6']['ipqs']['apikey'] = key except: pass return def transform(out): o={} if ipv4: o['ipv4']={} o['ipv4']['ip'] = ipv4 net = out['ipv4'].get('vpnapi', {}).get('network', {}).get('network') o['ipv4']['network'] = net if net else False ntype =[out['ipv4'].get('proxycheck', {}).get('type'), out['ipv4'].get('ip2proxy', {}).get('usageType'), False] if debug: o['ipv4']['network_type_list']=ntype o['ipv4']['network_type']=next(i for i in ntype if i not in [None, ""]) isp=[out['ipv4'].get('ip2location', {}).get('isp'), out['ipv4'].get('ip2proxy', {}).get('isp'), out['ipv4'].get('ipqs', {}).get('ISP'), out['ipv4'].get('proxycheck', {}).get('provider'), out['ipv4'].get('vpnapi', {}).get('network', {}).get('autonomous_system_organization'), False] if debug: o['ipv4']['isp_list']=isp o['ipv4']['isp']=next(i for i in isp if i not in [None, ""]) asn=[out['ipv4'].get('vpnapi', {}).get('network', {}).get('autonomous_system_number'), out['ipv4'].get('proxycheck', {}).get('asn'), out['ipv4'].get('ipqs', {}).get('ASN'), out['ipv4'].get('ip2proxy', {}).get('asn'), False] if debug: o['ipv4']['asn_list']=asn o['ipv4']['asn']=str(next(i for i in asn if i not in [None, "","0"])) city=[out['ipv4'].get('ipqs', {}).get('city'), out['ipv4'].get('proxycheck', {}).get('city'), out['ipv4'].get('vpnapi', {}).get('location', {}).get('city'), out['ipv4'].get('ip2location', {}).get('city_name'), out['ipv4'].get('ip2proxy', {}).get('cityName'), False] if debug: o['ipv4']['city_list']=city o['ipv4']['city']=next(i for i in city if i not in [None, ""]) region=[out['ipv4'].get('ipqs', {}).get('region'), out['ipv4'].get('proxycheck', {}).get('region'), out['ipv4'].get('ip2proxy', {}).get('regionName'), out['ipv4'].get('ip2proxy', {}).get('regionName'), out['ipv4'].get('vpnapi', {}).get('location', {}).get('region_code'), False] if debug: o['ipv4']['region_list']=region o['ipv4']['region']=next(i for i in region if i not in [None, ""]) country=[out['ipv4'].get('ip2location', {}).get('country_name'), out['ipv4'].get('ip2proxy', {}).get('countryName'), out['ipv4'].get('vpnapi', {}).get('country'), out['ipv4'].get('proxycheck', {}).get('country'), out['ipv4'].get('vpnapi', {}).get('location', {}).get('country_code'), out['ipv4'].get('ipqs', {}).get('country_code'), False] if debug: o['ipv4']['country_list']=country o['ipv4']['country']=next(i for i in country if i not in [None, ""]) tor=['vpnapi' if out['ipv4'].get('vpnapi', {}).get('security', {}).get('tor') else False, 'ipqualityscore' if out['ipv4'].get('ipqs', {}).get('tor') else False, 'ip2proxy' if out['ipv4'].get('ip2proxy', {}).get('proxyType')=="TOR" else False, 'proxycheck' if out['ipv4'].get('proxycheck', {}).get('type')=="TOR" else False, 'onionoo' if not len(out['ipv4'].get('onionoo', {}))==0 else False, False] if debug: o['ipv4']['tor_list']=tor o['ipv4']['tor']=any(tor) tor = [i for i in tor if i != False] o['ipv4']['tor_detected_by']=tor vpn=['vpnapi' if out['ipv4'].get('vpnapi', {}).get('security', {}).get('vpn') else False, 'ipqs' if out['ipv4'].get('ipqs', {}).get('vpn') else False, 'ip2proxy' if out['ipv4'].get('ip2proxy', {}).get('proxyType')=="VPN" else False, 'proxycheck' if out['ipv4'].get('proxycheck', {}).get('type')=="VPN" else False, 'proxycheck' if out['ipv4'].get('proxycheck', {}).get('type')=="OPENVPN" else False, 'proxycheck' if out['ipv4'].get('proxycheck', {}).get('type')=="SOCKS" else False, False] if debug: o['ipv4']['vpn_list']=vpn o['ipv4']['vpn']=any(vpn) vpn = [i for i in vpn if i != False] o['ipv4']['vpn_detected_by']=vpn proxy=['vpnapi' if out['ipv4'].get('vpnapi', {}).get('security', {}).get('proxy') else False, 'ipqualityscore' if out['ipv4'].get('ipqs', {}).get('proxy') else False, 'ip2proxy' if out['ipv4'].get('ip2proxy', {}).get('proxyType')=="PUB" else False, 'ip2proxy' if out['ipv4'].get('ip2proxy', {}).get('proxyType')=="WEB" else False, 'ip2proxy' if out['ipv4'].get('ip2proxy', {}).get('proxyType')=="RES" else False, False] if debug: o['ipv4']['proxy_list']=proxy o['ipv4']['proxy']=any(proxy) proxy = [i for i in proxy if i != False] o['ipv4']['proxy_detected_by']=proxy o['ipv4']['ipqs_fraud_score'] = out['ipv4'].get('ipqs', {}).get('fraud_score') o['ipv4']['proxycheck_risk'] = out['ipv4'].get('proxycheck', {}).get('risk') # IPv6 section if ipv6: o['ipv6']={} o['ipv6']['ip'] = ipv6 net = out['ipv6'].get('vpnapi', {}).get('network', {}).get('network') o['ipv6']['network'] = net if net else False ntype =[out['ipv6'].get('proxycheck', {}).get('type'), out['ipv6'].get('ip2proxy', {}).get('usageType'), False] if debug: o['ipv6']['network_type_list']=ntype o['ipv6']['network_type']=next(i for i in ntype if i not in [None, ""]) isp=[out['ipv6'].get('ip2location', {}).get('isp'), out['ipv6'].get('ip2proxy', {}).get('isp'), out['ipv6'].get('ipqs', {}).get('ISP'), out['ipv6'].get('proxycheck', {}).get('provider'), out['ipv6'].get('vpnapi', {}).get('network', {}).get('autonomous_system_organization'), False] if debug: o['ipv6']['isp_list']=isp o['ipv6']['isp']=next(i for i in isp if i not in [None, ""]) asn=[out['ipv6'].get('vpnapi', {}).get('network', {}).get('autonomous_system_number'), out['ipv6'].get('ip2proxy', {}).get('asn'), out['ipv6'].get('ipqs', {}).get('ASN'), out['ipv6'].get('proxycheck', {}).get('asn'), False] if debug: o['ipv6']['asn_list']=asn o['ipv6']['asn']= str(next(i for i in asn if i not in [None, ""])) city=[out['ipv6'].get('ipqs', {}).get('city'), out['ipv6'].get('proxycheck', {}).get('city'), out['ipv6'].get('vpnapi', {}).get('location', {}).get('city'), out['ipv6'].get('ip2location', {}).get('city_name'), out['ipv6'].get('ip2proxy', {}).get('cityName'), False] if debug: o['ipv6']['city_list']=city o['ipv6']['city']=next(i for i in city if i not in [None, ""]) region=[out['ipv6'].get('ipqs', {}).get('region'), out['ipv6'].get('proxycheck', {}).get('region'), out['ipv6'].get('ip2proxy', {}).get('regionName'), out['ipv6'].get('ip2location', {}).get('region_name'), out['ipv6'].get('vpnapi', {}).get('location', {}).get('region_code'), False] if debug: o['ipv6']['region_list']=region o['ipv6']['region']=next(i for i in region if i not in [None, ""]) country=[out['ipv6'].get('ip2location', {}).get('country_name'), out['ipv6'].get('ip2proxy', {}).get('countryName'), out['ipv6'].get('vpnapi', {}).get('location', {}).get('country'), out['ipv6'].get('proxycheck', {}).get('country'), out['ipv6'].get('vpnapi', {}).get('location', {}).get('country_code'), out['ipv6'].get('ipqs', {}).get('country_code'), False] if debug: o['ipv6']['country_list']=country o['ipv6']['country']=next(i for i in country if i not in [None, ""]) tor=['vpnapi' if out['ipv6'].get('vpnapi', {}).get('security', {}).get('tor') else False, 'ipqualityscore' if out['ipv6'].get('ipqs', {}).get('tor') else False, 'ip2proxy' if out['ipv6'].get('ip2proxy', {}).get('proxyType')=="TOR" else False, 'proxycheck' if out['ipv6'].get('proxycheck', {}).get('type')=="TOR" else False, 'onionoo' if not len(out['ipv6'].get('onionoo', {}))==0 else False, False] if debug: o['ipv6']['tor_list']=tor o['ipv6']['tor']=next(i for i in tor if i not in [None, ""]) tor = [i for i in tor if i != False] o['ipv6']['tor_detected_by']=tor vpn=['vpnapi' if out['ipv6'].get('vpnapi', {}).get('security', {}).get('vpn') else False, 'ipqualityscore' if out['ipv6'].get('ipqs', {}).get('vpn') else False, 'ip2proxy' if out['ipv6'].get('ip2proxy', {}).get('proxyType')=="VPN" else False, 'proxycheck' if out['ipv6'].get('proxycheck', {}).get('type')=="VPN" else False, 'proxycheck' if out['ipv6'].get('proxycheck', {}).get('type')=="OPENVPN" else False, False] if debug: o['ipv6']['vpn_list']=vpn o['ipv6']['vpn']=any(vpn) vpn = [i for i in vpn if i != False] o['ipv6']['vpn_detected_by']=vpn proxy=['vpnapi' if out['ipv6'].get('vpnapi', {}).get('security', {}).get('proxy') else False, 'ipqualityscore' if out['ipv6'].get('ipqs', {}).get('proxy') else False, 'ip2proxy' if out['ipv6'].get('ip2proxy', {}).get('proxyType')=="PUB" else False, 'ip2proxy' if out['ipv6'].get('ip2proxy', {}).get('proxyType')=="WEB" else False, 'ip2proxy' if out['ipv6'].get('ip2proxy', {}).get('proxyType')=="RES" else False, 'proxycheck' if out['ipv6'].get('proxycheck', {}).get('type')=="SOCKS" else False, False] if debug: o['ipv6']['proxy_list']=proxy o['ipv6']['proxy']=any(proxy) proxy = [i for i in proxy if i != False] o['ipv6']['proxy_detected_by']=proxy o['ipv6']['ipqs_fraud_score'] = out['ipv6'].get('ipqs', {}).get('fraud_score') o['ipv6']['proxycheck_risk'] = out['ipv6'].get('proxycheck', {}).get('risk') return o ############# # Main loop # ############# debug = False config = xml.dom.minidom.parse('/conf/config.xml') savestate = "/usr/local/opnsense/scripts/OPNsense/ipcheck/savestate.json" out={} arg='' if len(sys.argv)>1: arg=str(sys.argv[1]) if arg == '': try: with open(savestate, "r") as f: out = json.loads(f.read()) out['source']='Cached record' print(json.dumps(out, indent=3)) except: arg = 'all' if arg ==
<reponame>dkamotsky/addons # Copyright 2017 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """Tests for tfa.seq2seq.seq2seq.beam_search_decoder.""" import numpy as np import pytest import tensorflow as tf from tensorflow_addons.seq2seq import attention_wrapper from tensorflow_addons.seq2seq import beam_search_decoder, gather_tree def test_gather_tree(): # (max_time = 3, batch_size = 2, beam_width = 3) # create (batch_size, max_time, beam_width) matrix and transpose it predicted_ids = np.array( [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[2, 3, 4], [5, 6, 7], [8, 9, 10]]], dtype=np.int32, ).transpose([1, 0, 2]) parent_ids = np.array( [[[0, 0, 0], [0, 1, 1], [2, 1, 2]], [[0, 0, 0], [1, 2, 0], [2, 1, 1]]], dtype=np.int32, ).transpose([1, 0, 2]) # sequence_lengths is shaped (batch_size = 3) max_sequence_lengths = [3, 3] expected_result = np.array( [[[2, 2, 2], [6, 5, 6], [7, 8, 9]], [[2, 4, 4], [7, 6, 6], [8, 9, 10]]] ).transpose([1, 0, 2]) res = gather_tree( predicted_ids, parent_ids, max_sequence_lengths=max_sequence_lengths, end_token=11, ) np.testing.assert_equal(expected_result, res) def _test_gather_tree_from_array(depth_ndims=0, merged_batch_beam=False): array = np.array( [ [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]], [[2, 3, 4], [5, 6, 7], [8, 9, 10], [11, 12, 0]], ] ).transpose([1, 0, 2]) parent_ids = np.array( [ [[0, 0, 0], [0, 1, 1], [2, 1, 2], [-1, -1, -1]], [[0, 0, 0], [1, 1, 0], [2, 0, 1], [0, 1, 0]], ] ).transpose([1, 0, 2]) expected_array = np.array( [ [[2, 2, 2], [6, 5, 6], [7, 8, 9], [0, 0, 0]], [[2, 3, 2], [7, 5, 7], [8, 9, 8], [11, 12, 0]], ] ).transpose([1, 0, 2]) sequence_length = [[3, 3, 3], [4, 4, 3]] array = tf.convert_to_tensor(array, dtype=tf.float32) parent_ids = tf.convert_to_tensor(parent_ids, dtype=tf.int32) expected_array = tf.convert_to_tensor(expected_array, dtype=tf.float32) max_time = tf.shape(array)[0] batch_size = tf.shape(array)[1] beam_width = tf.shape(array)[2] def _tile_in_depth(tensor): # Generate higher rank tensors by concatenating tensor and # tensor + 1. for _ in range(depth_ndims): tensor = tf.stack([tensor, tensor + 1], -1) return tensor if merged_batch_beam: array = tf.reshape(array, [max_time, batch_size * beam_width]) expected_array = tf.reshape(expected_array, [max_time, batch_size * beam_width]) if depth_ndims > 0: array = _tile_in_depth(array) expected_array = _tile_in_depth(expected_array) sorted_array = beam_search_decoder.gather_tree_from_array( array, parent_ids, sequence_length ) np.testing.assert_equal(expected_array.numpy(), sorted_array.numpy()) def test_gather_tree_from_array_scalar(): _test_gather_tree_from_array() def test_gather_tree_from_array_1d(): _test_gather_tree_from_array(depth_ndims=1) def test_gather_tree_from_array_1d_with_merged_batch_beam(): _test_gather_tree_from_array(depth_ndims=1, merged_batch_beam=True) def test_gather_tree_from_array_2d(): _test_gather_tree_from_array(depth_ndims=2) def test_gather_tree_from_array_complex_trajectory(): # Max. time = 7, batch = 1, beam = 5. array = np.expand_dims( np.array( [ [[25, 12, 114, 89, 97]], [[9, 91, 64, 11, 162]], [[34, 34, 34, 34, 34]], [[2, 4, 2, 2, 4]], [[2, 3, 6, 2, 2]], [[2, 2, 2, 3, 2]], [[2, 2, 2, 2, 2]], ] ), -1, ) parent_ids = np.array( [ [[0, 0, 0, 0, 0]], [[0, 0, 0, 0, 0]], [[0, 1, 2, 3, 4]], [[0, 0, 1, 2, 1]], [[0, 1, 1, 2, 3]], [[0, 1, 3, 1, 2]], [[0, 1, 2, 3, 4]], ] ) expected_array = np.expand_dims( np.array( [ [[25, 25, 25, 25, 25]], [[9, 9, 91, 9, 9]], [[34, 34, 34, 34, 34]], [[2, 4, 2, 4, 4]], [[2, 3, 6, 3, 6]], [[2, 2, 2, 3, 2]], [[2, 2, 2, 2, 2]], ] ), -1, ) sequence_length = [[4, 6, 4, 7, 6]] array = tf.convert_to_tensor(array, dtype=tf.float32) parent_ids = tf.convert_to_tensor(parent_ids, dtype=tf.int32) expected_array = tf.convert_to_tensor(expected_array, dtype=tf.float32) sorted_array = beam_search_decoder.gather_tree_from_array( array, parent_ids, sequence_length ) np.testing.assert_equal(expected_array.numpy(), sorted_array.numpy()) def basic_test_array_shape_dynamic_checks( static_shape, dynamic_shape, batch_size, beam_width, is_valid=True ): t = tf.compat.v1.placeholder_with_default( np.random.randn(*static_shape).astype(np.float32), shape=dynamic_shape ) batch_size = tf.constant(batch_size) def _test_body(): beam_search_decoder._check_batch_beam(t, batch_size, beam_width) if is_valid: _test_body() else: with pytest.raises(tf.errors.InvalidArgumentError): _test_body() @pytest.mark.usefixtures("maybe_run_functions_eagerly") def test_array_shape_dynamic_checks(): basic_test_array_shape_dynamic_checks( (8, 4, 5, 10), (None, None, 5, 10), 4, 5, is_valid=True ) basic_test_array_shape_dynamic_checks( (8, 20, 10), (None, None, 10), 4, 5, is_valid=True ) basic_test_array_shape_dynamic_checks( (8, 21, 10), (None, None, 10), 4, 5, is_valid=False ) basic_test_array_shape_dynamic_checks( (8, 4, 6, 10), (None, None, None, 10), 4, 5, is_valid=False ) basic_test_array_shape_dynamic_checks((8, 4), (None, None), 4, 5, is_valid=False) def test_array_shape_static_checks(): assert ( beam_search_decoder._check_static_batch_beam_maybe( tf.TensorShape([None, None, None]), 3, 5 ) is True ) assert ( beam_search_decoder._check_static_batch_beam_maybe( tf.TensorShape([15, None, None]), 3, 5 ) is True ) assert ( beam_search_decoder._check_static_batch_beam_maybe( tf.TensorShape([16, None, None]), 3, 5 ) is False ) assert ( beam_search_decoder._check_static_batch_beam_maybe( tf.TensorShape([3, 5, None]), 3, 5 ) is True ) assert ( beam_search_decoder._check_static_batch_beam_maybe( tf.TensorShape([3, 6, None]), 3, 5 ) is False ) assert ( beam_search_decoder._check_static_batch_beam_maybe( tf.TensorShape([5, 3, None]), 3, 5 ) is False ) def test_eos_masking(): probs = tf.constant( [ [ [-0.2, -0.2, -0.2, -0.2, -0.2], [-0.3, -0.3, -0.3, 3, 0], [5, 6, 0, 0, 0], ], [[-0.2, -0.2, -0.2, -0.2, 0], [-0.3, -0.3, -0.1, 3, 0], [5, 6, 3, 0, 0],], ] ) eos_token = 0 previously_finished = np.array([[0, 1, 0], [0, 1, 1]], dtype=bool) masked = beam_search_decoder._mask_probs(probs, eos_token, previously_finished) masked = masked.numpy() np.testing.assert_equal(probs[0][0], masked[0][0]) np.testing.assert_equal(probs[0][2], masked[0][2]) np.testing.assert_equal(probs[1][0], masked[1][0]) np.testing.assert_equal(masked[0][1][0], 0) np.testing.assert_equal(masked[1][1][0], 0) np.testing.assert_equal(masked[1][2][0], 0) for i in range(1, 5): np.testing.assert_allclose(masked[0][1][i], np.finfo("float32").min) np.testing.assert_allclose(masked[1][1][i], np.finfo("float32").min) np.testing.assert_allclose(masked[1][2][i], np.finfo("float32").min) def test_beam_step(): batch_size = 2 beam_width = 3 vocab_size = 5 end_token = 0 length_penalty_weight = 0.6 coverage_penalty_weight = 0.0 dummy_cell_state = tf.zeros([batch_size, beam_width]) beam_state = beam_search_decoder.BeamSearchDecoderState( cell_state=dummy_cell_state, log_probs=tf.nn.log_softmax(tf.ones([batch_size, beam_width])), lengths=tf.constant(2, shape=[batch_size, beam_width], dtype=tf.int64), finished=tf.zeros([batch_size, beam_width], dtype=tf.bool), accumulated_attention_probs=(), ) logits_ = np.full([batch_size, beam_width, vocab_size], 0.0001) logits_[0, 0, 2] = 1.9 logits_[0, 0, 3] = 2.1 logits_[0, 1, 3] = 3.1 logits_[0, 1, 4] = 0.9 logits_[1, 0, 1] = 0.5 logits_[1, 1, 2] = 2.7 logits_[1, 2, 2] = 10.0 logits_[1, 2, 3] = 0.2 logits = tf.convert_to_tensor(logits_, dtype=tf.float32) log_probs = tf.nn.log_softmax(logits) outputs, next_beam_state = beam_search_decoder._beam_search_step( time=2, logits=logits, next_cell_state=dummy_cell_state, beam_state=beam_state, batch_size=tf.convert_to_tensor(batch_size), beam_width=beam_width, end_token=end_token, length_penalty_weight=length_penalty_weight, coverage_penalty_weight=coverage_penalty_weight, ) outputs_, next_state_, state_, log_probs_ = [ outputs, next_beam_state, beam_state, log_probs, ] np.testing.assert_equal( outputs_.predicted_ids.numpy(), np.asanyarray([[3, 3, 2], [2, 2, 1]]) ) np.testing.assert_equal( outputs_.parent_ids.numpy(), np.asanyarray([[1, 0, 0], [2, 1, 0]]) ) np.testing.assert_equal( next_state_.lengths.numpy(), np.asanyarray([[3, 3, 3], [3, 3, 3]]) ) np.testing.assert_equal( next_state_.finished.numpy(), np.asanyarray([[False, False, False], [False, False, False]]), ) expected_log_probs = [] expected_log_probs.append(state_.log_probs[0].numpy()) expected_log_probs.append(state_.log_probs[1].numpy()) expected_log_probs[0][0] += log_probs_[0, 1, 3] expected_log_probs[0][1] += log_probs_[0, 0, 3] expected_log_probs[0][2] += log_probs_[0, 0, 2] expected_log_probs[1][0] += log_probs_[1, 2, 2] expected_log_probs[1][1] += log_probs_[1, 1, 2] expected_log_probs[1][2] += log_probs_[1, 0, 1] np.testing.assert_equal( next_state_.log_probs.numpy(), np.asanyarray(expected_log_probs) ) def test_step_with_eos(): batch_size = 2 beam_width = 3 vocab_size = 5 end_token = 0 length_penalty_weight = 0.6 coverage_penalty_weight = 0.0 dummy_cell_state = tf.zeros([batch_size, beam_width]) beam_state = beam_search_decoder.BeamSearchDecoderState( cell_state=dummy_cell_state, log_probs=tf.nn.log_softmax(tf.ones([batch_size, beam_width])), lengths=tf.convert_to_tensor([[2, 1, 2], [2, 2, 1]], dtype=tf.int64), finished=tf.convert_to_tensor( [[False, True, False], [False, False, True]], dtype=tf.bool ), accumulated_attention_probs=(), ) logits_ = np.full([batch_size, beam_width, vocab_size], 0.0001) logits_[0, 0, 2] = 1.9 logits_[0, 0, 3] = 2.1 logits_[0, 1, 3] = 3.1 logits_[0, 1, 4] = 0.9 logits_[1, 0, 1] = 0.5 logits_[1, 1, 2] = 5.7 # why does this not work when it's 2.7? logits_[1, 2, 2] = 1.0 logits_[1, 2, 3] = 0.2 logits = tf.convert_to_tensor(logits_, dtype=tf.float32) log_probs = tf.nn.log_softmax(logits) outputs, next_beam_state = beam_search_decoder._beam_search_step( time=2, logits=logits, next_cell_state=dummy_cell_state, beam_state=beam_state, batch_size=tf.convert_to_tensor(batch_size), beam_width=beam_width, end_token=end_token, length_penalty_weight=length_penalty_weight, coverage_penalty_weight=coverage_penalty_weight, ) outputs_, next_state_, state_, log_probs_ = [ outputs, next_beam_state, beam_state, log_probs, ] np.testing.assert_equal( outputs_.parent_ids.numpy(), np.asanyarray([[1, 0, 0], [1, 2, 0]]) ) np.testing.assert_equal( outputs_.predicted_ids.numpy(), np.asanyarray([[0, 3, 2], [2, 0, 1]]) ) np.testing.assert_equal( next_state_.lengths.numpy(), np.asanyarray([[1, 3, 3], [3, 1, 3]]) ) np.testing.assert_equal( next_state_.finished.numpy(), np.asanyarray([[True, False, False], [False, True, False]]), ) expected_log_probs = [] expected_log_probs.append(state_.log_probs[0].numpy()) expected_log_probs.append(state_.log_probs[1].numpy()) expected_log_probs[0][1] += log_probs_[0, 0, 3] expected_log_probs[0][2] += log_probs_[0, 0, 2] expected_log_probs[1][0] += log_probs_[1, 1, 2] expected_log_probs[1][2] += log_probs_[1, 0, 1] np.testing.assert_equal( next_state_.log_probs.numpy(), np.asanyarray(expected_log_probs) ) def test_large_beam_step(): batch_size = 2 beam_width = 8 vocab_size = 5 end_token = 0 length_penalty_weight = 0.6 coverage_penalty_weight = 0.0 def get_probs(): """this simulates the initialize method in BeamSearchDecoder.""" log_prob_mask = tf.one_hot( tf.zeros([batch_size], dtype=tf.int32), depth=beam_width, on_value=True, off_value=False, dtype=tf.bool, ) log_prob_zeros = tf.zeros([batch_size, beam_width], dtype=tf.float32) log_prob_neg_inf = tf.ones([batch_size, beam_width], dtype=tf.float32) * -np.Inf log_probs = tf.where(log_prob_mask, log_prob_zeros, log_prob_neg_inf) return log_probs log_probs = get_probs() dummy_cell_state = tf.zeros([batch_size, beam_width]) _finished
go.layout.Annotation( text = f'regressor: {self.label}', x = 0, y = 2.1, font = go.layout.annotation.Font( color = '#5E5E5E', size = 15, ), showarrow = False, xref = 'paper', yref = 'paper' ) annotations.append(annotation)""" # draw vertical line at output value shape = go.layout.Shape(type='line', x0=self.sample_prediction_prob, x1=self.sample_prediction_prob, y0= 0, y1= 1.1, yref = "paper", line=dict( color="#A6A6A6", width=4, ) ) shapes.append(shape) #draw bosplots if selected if boxplots: self.box_plot_shapes = [] self.box_plot_colors = [("#FF9300", "rgba(255,147,0, 0.3)"),("#70AD47", "rgba(112,173,71, 0.3)")] for elem, c in zip(self.box_plots, self.box_plot_colors): q1 = elem.quantile(0.25) q2 = elem.quantile(0.75) median = elem.quantile(0.5) minimum = elem.min() maximum = elem.max() box_plot_values = [minimum, median, maximum] for e in box_plot_values: shape = go.layout.Shape(type='line', x0= float(e), x1= float(e), y0= 1.6, y1= 1.8, yref = 'paper', line=dict( color=c[0], width=3, ) ) shapes.append(shape) shape = go.layout.Shape(type='line', x0 = float(minimum), x1= float(q1), y0= 1.7, y1= 1.7, yref = 'paper', line=dict( color=c[0], width=3, ) ) shapes.append(shape) shape = go.layout.Shape(type='line', x0 = float(q2), x1= float(maximum), y0= 1.7, y1= 1.7, yref = 'paper', line=dict( color=c[0], width=3, ) ) shapes.append(shape) shape = go.layout.Shape(type='rect', x0 = float(q1), x1= float(q2), y0= 1.6, y1= 1.8, yref = 'paper', fillcolor = c[1], line=dict( color=c[0], width=3, ) ) shapes.append(shape) #get visualization ordering of features while visualizing them (actual ordering of absolute SHAP values -> (feature name, visualization ordering)) self.visualization_ordering = dict() count = 0 #visualize polygons for features with positive SHAP values first_pos_feature = True color_count = 0 for elem in self.pos_x_coordinates: coords = elem[2] self.visualization_ordering[elem[3]] = (elem[0], count) count +=1 if elem[0] in self.sample_impacting_features_names: if first_pos_feature: x =[coords[1]-0.001, coords[1]-0.001, coords[3]-0.005, coords[2], coords[3]-0.005, coords[1]-0.001] y =[0.7, 0.4, 0.4, 0.55, 0.7, 0.7] else: x=[coords[1]-0.006, coords[0]-0.001, coords[1]-0.006, coords[3]-0.005, coords[2], coords[3]-0.005, coords[1]-0.006] y=[0.7, 0.55, 0.4, 0.4, 0.55, 0.7, 0.7] else: if first_pos_feature: x =[coords[1]-0.001, coords[1]-0.001, coords[3], coords[2], coords[3], coords[1]-0.001] y =[0.65, 0.45, 0.45, 0.55, 0.65, 0.65] else: x=[coords[1]-0.001, coords[0]-0.001, coords[1]-0.001, coords[3], coords[2], coords[3], coords[1]-0.001] y=[0.65, 0.55, 0.45, 0.45, 0.55, 0.65, 0.65] if color_count < len(self.red_colors): color = self.red_colors[color_count] else: color = self.red_colors[-1] text_plus = "" if elem[0] in self.feature_value_range.keys(): text_plus = "<br>Max: " + str(self.feature_value_range[elem[0]][2]) + "<br>Average: " + str(self.feature_value_range[elem[0]][1]) + "<br>Min:" + str(self.feature_value_range[elem[0]][0]) trace = go.Scatter(x = x, y = y, fill = 'toself', fillcolor = 'hsv'+ str(color), hoveron = 'fills', line_color = '#FFFFFF' if highlighted_feature != elem[0] else "#000000", name = elem[0] + " = " + str(self.sample_feature_values[elem[0]]), text= "<b>" + str(elem[0]) + " = " + str(self.sample_feature_values[elem[0]]) + "<br>SHAP value: " + "{:.3f}".format(elem[1]) + "</b><br>" + text_plus, hoverinfo = 'text' , mode = 'lines', line = dict(width = 1) ) traces.append(trace) first_pos_feature = False color_count+=1 # visualize polygons for features with negative SHAP values first_neg_feature = True color_count = 0 for elem in self.neg_x_coordinates: coords = elem[2] self.visualization_ordering[elem[3]] = (elem[0], count) count +=1 if elem[0] in self.sample_impacting_features_names: if first_neg_feature: x =[coords[1]+0.001, coords[1]+0.001, coords[3]+0.005, coords[2], coords[3]+0.005, coords[1]+0.001] y =[0.7, 0.4, 0.4, 0.55, 0.7, 0.7] else: x=[coords[1]+0.006, coords[0]+0.001, coords[1]+0.006, coords[3]+0.005, coords[2], coords[3]+0.005, coords[1]+0.006] y=[0.7, 0.55, 0.4, 0.4, 0.55, 0.7, 0.7] else: if first_neg_feature: x=[coords[1]+0.001, coords[1]+0.001, coords[3], coords[2], coords[3], coords[1]+0.001] y =[0.65, 0.45, 0.45, 0.55, 0.65, 0.65] else: x=[coords[1]+0.001, coords[0]+0.001, coords[1]+0.001, coords[3], coords[2], coords[3], coords[1]+0.001] y=[0.65, 0.55, 0.45, 0.45, 0.55, 0.65, 0.65] if color_count < len(self.blue_colors): color = self.blue_colors[color_count] else: color = self.blue_colors[-1] text_plus = "" if elem[0] in self.feature_value_range.keys(): text_plus = "<br>Max: " + str(self.feature_value_range[elem[0]][2]) + "<br>Average: " + str(self.feature_value_range[elem[0]][1]) + "<br>Min: " + str(self.feature_value_range[elem[0]][0]) trace = go.Scatter(x=x, y=y, fill='toself', fillcolor= "hsv" + str(color), hoveron = 'fills', line_color= '#FFFFFF' if highlighted_feature != elem[0] else '#000000', name = elem[0] + " = " + str(self.sample_feature_values[elem[0]]), text = "<b>" + str(elem[0]) + " = " + str(self.sample_feature_values[elem[0]]) + "<br>SHAP value: " + "{:.3f}".format(elem[1]) + "</b><br>" + text_plus, hoverinfo = 'text', mode = 'lines', line = dict(width = 1) ) traces.append(trace) first_neg_feature = False color_count+=1 # draw max pos shap value over all samples trace = go.Scatter(x=[self.sample_prediction_prob, self.sample_prediction_prob - self.max_pos_shap_value[1]], y=[0.85, 0.85], hoveron = 'points', line_color='#FF0D57', text= "SHAP value: " + str(self.max_pos_shap_value[1]) + "<br>feature: " + str(self.max_pos_shap_value[0]) + "<br>sample id: " + str(self.max_pos_shap_value[2]), hoverinfo = 'text', mode = 'lines', line = dict( width = 4, ), showlegend = False, ) traces.append(trace) # draw max neg shap value over all samples trace = go.Scatter(x=[self.sample_prediction_prob, self.sample_prediction_prob - self.max_neg_shap_value[1]], y=[0.85, 0.85], hoveron = 'points', line_color='#1E88E5', text= "SHAP value: " + str(self.max_neg_shap_value[1]) + "<br>feature: " + str(self.max_neg_shap_value[0]) + "<br>sample id: " + str(self.max_neg_shap_value[2]), hoverinfo = 'text', mode = 'lines', line = dict( width = 4, ), showlegend = False, ) traces.append(trace) #draw shap value ranges if highlighted_feature != "": avg_pos, avg_neg, pos_count, neg_count, intervall = self.calculate_feature_value_range(highlighted_feature) if intervall is None: hovertext_pos = "average positive SHAP value for "+highlighted_feature+" = " + str(self.sample_feature_values[highlighted_feature]) + "<br>number of samples: " + str(pos_count), hovertext_neg = "average negative SHAP value for "+highlighted_feature+" = " + str(self.sample_feature_values[highlighted_feature]) + "<br>number of samples: "+str(neg_count), else: hovertext_pos = "average positive SHAP value for "+highlighted_feature+" in " + str(intervall) + "<br>number of samples: " + str(pos_count), hovertext_neg = "average negative SHAP value for "+highlighted_feature+ " in " + str(intervall) + "<br>number of samples: "+str(neg_count), annotation = go.layout.Annotation( x = self.sample_prediction_prob - avg_pos - 0.01, y = 0.1, xanchor = "right", text = "|avg|↑ for " + highlighted_feature + " = " + str(self.sample_feature_values[highlighted_feature]) if intervall is None else "|avg|↑ for " + highlighted_feature + " in " + str(intervall), showarrow = False, font=go.layout.annotation.Font( color = '#FF0D57', size = 11 ), ) annotations.append(annotation) annotation = go.layout.Annotation( x = self.sample_prediction_prob - avg_neg + 0.01, y = 0.1, xanchor = "left", text = "|avg|↓ for " + highlighted_feature + " = " + str(self.sample_feature_values[highlighted_feature]) if intervall is None else "|avg|↓ for " + highlighted_feature + " in " + str(intervall), showarrow = False, font=go.layout.annotation.Font( color = '#1E88E5', size = 11 ), ) annotations.append(annotation) trace = go.Scatter( x=[self.sample_prediction_prob, self.sample_prediction_prob - avg_pos], y=[0.1, 0.1], hoveron = 'points', line_color= "#FF0D57" , text=hovertext_pos, hoverinfo = 'text', mode = 'lines', line = dict( width = 4, ), showlegend = False, ) traces.append(trace) trace = go.Scatter( x=[self.sample_prediction_prob, self.sample_prediction_prob - avg_neg], y=[0.1, 0.1], hoveron = 'points', line_color= "#1E88E5", text=hovertext_neg, hoverinfo = 'text', mode = 'lines', line = dict( width = 4, ), showlegend = False, ) traces.append(trace) #design layout of forceplot layout = go.Layout( hovermode='closest', plot_bgcolor = '#FFFFFF', autosize=False, width=1500, height = 400, legend = dict( x = 1.05, font= dict( color = '#5E5E5E', size = 10, ), ), margin= dict(t = 250, b = 0, l = 0, r = 0 ), xaxis = go.layout.XAxis( position = 1, side = 'top', fixedrange = True, range = [self.min_x_coordinate - 0.05, self.max_x_coordinate + 0.05], showgrid = False, ticks = 'inside', zeroline = False, tickcolor = '#A6A6A6', tickfont = go.layout.xaxis.Tickfont( color = '#A6A6A6', ), tick0 = self.base_value, dtick = 0.1, nticks = 15, tickformat = '.3f', showline = True, linecolor = '#A6A6A6' ), yaxis = go.layout.YAxis( showgrid = False, showticklabels = False, fixedrange = True, range = [0, 1], zeroline = False, showline = False, linecolor = '#A6A6A6', ), annotations = annotations, shapes = shapes ) #create figure fig = go.Figure(data = traces, layout = layout) #create and add slider steps = [] for i in range(len(self.visualization_ordering)): step = dict( method="update", args=[{"visible": [elem.visible for elem in fig.data]}], label = str(i+1) ) for e in range (len(self.visualization_ordering)): step["args"][0]["visible"][self.visualization_ordering[e][1]] = False for e in range (i+1): step["args"][0]["visible"][self.visualization_ordering[e][1]] = True steps.append(step) fig.update_layout( sliders = [dict( active=len(self.sample_shap_values)-1, currentvalue={"prefix": "number of features shown: ", "font": { "size":15, "color": '#5E5E5E', }}, tickcolor= '#5E5E5E', font={"color": '#5E5E5E', "size": 10 }, ticklen= 5, len= 0.2, x= 0.8, y= 2.5, pad={"t": 0}, bordercolor = '#5E5E5E', steps=steps, )] ) fig.show() def draw_table(self): shapes = [] traces = [] annotations =
<filename>Yolo/yolo2_model_base.py # coding = utf-8 import tensorflow as tf import tensorflow.contrib.layers as layers from colorama import Fore import numpy as np import random import Putil.np.util as npu import Putil.tf.util as tfu import base.logger as plog root_logger = plog.PutilLogConfig('yolo2ModelBase').logger() root_logger.setLevel(plog.DEBUG) Yolo2BuildLogger = root_logger.getChild('Yolo2Build') Yolo2BuildLogger.setLevel(plog.DEBUG) Yolo2GenerateFeedLogger = root_logger.getChild('Yolo2GenerateFeed') Yolo2GenerateFeedLogger.setLevel(plog.DEBUG) StandardYolo2GenerateLogger = root_logger.getChild('StandardYolo2Generate') StandardYolo2GenerateLogger.setLevel(plog.DEBUG) Yolo2GenerateLogger = root_logger.getChild('Yolo2Generate') Yolo2GenerateLogger.setLevel(plog.DEBUG) Yolo2GenerateILogger = root_logger.getChild('Yolo2GenerateI') Yolo2GenerateILogger.setLevel(plog.DEBUG) assert tf.__version__ == '1.6.0', Fore.RED + 'version of tensorflow should be 1.6.0' class Yolo2Build: def __init__(self, net_output, class_num, prior_h, prior_w, scalar, _dtype): self._net_output = net_output self._class_amount = class_num self.__check_prior(prior_h, prior_w) self._prior_height = prior_h self._prior_width = prior_w self._cluster_object_count = len(prior_h) self._scalar = scalar self._dtype = _dtype self._pro__ = self.GeneratePro() self._output_tensor = self._pro__['pro'] self._anchor_pro__ = self._pro__['anchor'] self._precision_pro__ = self._pro__['precision'] self._class_pro__ = self._pro__['class'] self._y_pro__ = self._pro__['y'] self._x_pro__ = self._pro__['x'] self._h_pro__ = self._pro__['h'] self._w_pro__ = self._pro__['w'] self._output_loss__, self._place_gt_result__, self._iou_result__ = self.AppendLoss() self._gt_one_hot_class__ = self._place_gt_result__['class'] self._gt_feed_class__ = self._place_gt_result__['feed_class'] self._gt_y_offset__ = self._place_gt_result__['y_offset'] self._gt_y__ = self._place_gt_result__['y'] self._gt_y_feed__ = self._place_gt_result__['y_feed'] self._gt_x_offset__ = self._place_gt_result__['x_offset'] self._gt_x__ = self._place_gt_result__['x'] self._gt_x_feed__ = self._place_gt_result__['x_feed'] self._gt_h__ = self._place_gt_result__['h'] self._gt_h_feed__ = self._place_gt_result__['h_feed'] self._gt_w__ = self._place_gt_result__['w'] self.__gt_w_feed__ = self._place_gt_result__['w_feed'] self._anchor_mask__ = self._place_gt_result__['anchor_mask'] self._negative_anchor_mask__ = self._place_gt_result__['negative_anchor_mask'] self._total_loss__ = self._output_loss__['total_loss'] self._anchor_loss__ = self._output_loss__['anchor_loss'] self._precision_loss__ = self._output_loss__['precision_loss'] self._class_loss__ = self._output_loss__['class_loss'] self._indicator_mean_iou = self._output_loss__['mean_iou'] self._indicator_classify_top_one_acc = self._output_loss__['classify_top_one_acc'] self._gt_iou__ = self._iou_result__ pass @property def IndicatorClassifyTopOneAcc(self): return self._indicator_classify_top_one_acc @property def IndicatorIoU(self): return self._indicator_mean_iou @property def NewOutput(self): return self._net_output @property def ClassAmount(self): return self._class_amount @property def PriorHeight(self): return self._prior_height @property def PriorWidth(self): return self._prior_width @property def ClusterObjectAmount(self): return self._cluster_object_count @property def Scalar(self): return self._scalar @property def Dtype(self): return self._dtype @property def Pro(self): return self._output_tensor @property def AnchorPro(self): return self._anchor_pro__ @property def PrecisionPro(self): return self._precision_pro__ @property def ClassPro(self): return self._class_pro__ @property def YPro(self): return self._y_pro__ @property def XPro(self): return self._x_pro__ @property def HPro(self): return self._h_pro__ @property def WPro(self): return self._w_pro__ @property def GtOneHotClass(self): return self._gt_one_hot_class__ @property def GtClassFeed(self): return self._gt_feed_class__ @property def GtYOffset(self): return self._gt_y_offset__ @property def GtY(self): return self._gt_y__ @property def GtYFeed(self): return self._gt_y_feed__ @property def GtXOffset(self): return self._gt_x_offset__ @property def GtX(self): return self._gt_x__ @property def GtxFeed(self): return self._gt_x_feed__ @property def GtH(self): return self._gt_h__ @property def GtHFeed(self): return self._gt_h_feed__ @property def GtW(self): return self._gt_w__ @property def GtWFeed(self): return self.__gt_w_feed__ @property def AnchorMask(self): return self._anchor_mask__ @property def NegativateAnchorMask(self): return self._negative_anchor_mask__ @property def TotalLoss(self): return self._total_loss__ @property def AnchorLoss(self): return self._anchor_loss__ @property def PrecisionLoss(self): return self._precision_loss__ @property def ClassLoss(self): return self._class_loss__ @property def GtIou(self): return self._gt_iou__ def __check_prior(self, prior_h, prior_w): # check failed throw exception return True pass def GeneratePro(self): return gen_pro(self._net_output, self._class_amount, self._cluster_object_count, self._dtype) pass def AppendLoss(self): return append_yolo2_loss(self._pro__, self._class_amount, self._prior_height, self._prior_width, self._scalar, self._dtype) pass pass def append_yolo2_loss( yolo2_net_feature, class_num, prior_h, prior_w, scalar, _dtype=0.32 ): """ :param yolo2_net_feature: feature from base net output :param class_num: the count of the class with background :param prior_h: prior height list or 1-D ndarray :param prior_w: prior width list or 1-D ndarray :param scalar: down sample scalar :param _dtype: model parameter dtype, default 0.32 :return: """ assert len(prior_w) == len(prior_h), Fore.RED + 'prior height should be same length with prior width' print(Fore.YELLOW + '-------generate yolo2 loss---------') print(Fore.GREEN + 'class_num : ', class_num) print(Fore.GREEN + 'prior_h : ', prior_h) print(Fore.GREEN + 'prior_w : ', prior_w) print(Fore.GREEN + 'scalar : ', scalar) cluster_object_count = len(prior_w) place_gt_result = __PlaceGT(cluster_object_count=cluster_object_count, _dtype=_dtype).Place place_process_result = __place_process( place_gt_result, class_num, prior_h, prior_w, scalar=scalar, _dtype=_dtype ) pro_result_read_result = __pro_result_reader( split_pro_result=yolo2_net_feature) calc_iou_result = __calc_iou( pro_result_read_result=pro_result_read_result, place_process_result=place_process_result, scalar=scalar, prior_h=prior_h, prior_w=prior_w, _dtype=_dtype ) loss = __calc_loss( split_pro_result=yolo2_net_feature, gt_process_result=place_process_result, calc_iou_result=calc_iou_result) print(Fore.YELLOW + '-------generate yolo2 loss done---------') return loss, place_process_result, calc_iou_result # generator placeholder for total feed, designed to easy used and generate # gt is the standard data # 'class' : int include background and all kind of object # 'p_mask' : set 1.0 in the cell location which has an object and set 0.0 for other # 'n_mask' : set 1.0 in the cell location which does not contain any object and set 0.0 for other # 'y': object center location y shift from the top left point int the cell, set 0.0 which cell does not contain object # 'x': object center location x shift from the top left point int the cell, set 0.0 which cell does not contain object # relationship between real (center_y, center_x, height, width) and (y_shift, x_shift, h_shift, w_shift): class __PlaceGT: def __init__(self, cluster_object_count, _dtype): gt_place = dict() dtype = tfu.tf_type(_dtype).Type with tf.name_scope('GT'): gt_place['class'] = tf.placeholder(dtype=tf.int32, shape=[None, None, None, cluster_object_count], name='class') # set 0.0 in the cell which does not contain any object except background gt_place['y'] = tf.placeholder(dtype=dtype, shape=[None, None, None, cluster_object_count], name='y') gt_place['x'] = tf.placeholder(dtype=dtype, shape=[None, None, None, cluster_object_count], name='x') # !!!!important: because of the follow process in (__place_process), hw should not contain negative and zero # !!!!suggest fill prior value in the cell location which does not contain any object gt_place['h'] = tf.placeholder(dtype=dtype, shape=[None, None, None, cluster_object_count], name='h') gt_place['w'] = tf.placeholder(dtype=dtype, shape=[None, None, None, cluster_object_count], name='w') # the mask frequently used in calc loss gt_place['p_mask'] = tf.placeholder(dtype=dtype, shape=[None, None, None, 1], name='p_mask') gt_place['n_mask'] = tf.placeholder(dtype=dtype, shape=[None, None, None, 1], name='n_mask') # avoid learning illegal anchor gt_place['anchor_mask'] = tf.placeholder( dtype=dtype, shape=[None, None, None, cluster_object_count], name='anchor_mask') pass self._gt_place = gt_place pass @property def Place(self): return self._gt_place def __generate(self): return self._gt_place pass @property def Class(self): return self._gt_place['class'] @property def Y(self): return self._gt_place['y'] @property def X(self): return self._gt_place['x'] @property def H(self): return self._gt_place['h'] @property def W(self): return self._gt_place['w'] @property def PMask(self): return self._gt_place['p_mask'] @property def NMask(self): return self._gt_place['n_mask'] @property def LegalAnchor(self): return self._gt_place['anchor_mask'] pass # : the pro tensor is not easy to used in calc loss, make same process in this function, this function should make # : sure gradient can propagate directly def __split_pro_ac(pro, class_num, cluster_object_count): """ to split the pro of yolo2 into several part :param pro: the pro of gen_pro :param class_num: class amount :param cluster_object_count: prior anchor amount :return: {'pro': pro, 'anchor': anchor_pro, 'precision': precision_pro, 'class': class_pro, 'y': y_pro, 'x': x_pro, 'h': h_pro, 'w': w_pro} pro: the input pro [y, x, h, w, precision, class_part, .., ..., ] anchor: take all anchor and concat then[batch, cell_height, cell_width, cluster_object_count, 4(include [y, x, h, w])] precision:[batch, cell_height, cell_width, cluster_object_count] class:[batch * cell_height * cell_width * cluster_object_count, class_amount] y: [batch, cell_height, cell_width, cluster_object_count] x: [batch, cell_height, cell_width, cluster_object_count] h: [batch, cell_height, cell_width, cluster_object_count] w: [batch, cell_height, cell_width, cluster_object_count] """ with tf.name_scope('split_and_pro'): # generate all part y x: sigmoid; h w: None; precision: sigmoid; class: part softmax with tf.name_scope('total_split'): with tf.name_scope('y_part'): y_part = pro[:, :, :, 0: ((cluster_object_count - 1) * (4 + 1 + class_num) + 1): 4 + 1 + class_num] y_pro = y_part pass with tf.name_scope('x_part'): x_part = pro[:, :, :, 1: ((cluster_object_count - 1) * (4 + 1 + class_num) + 2): 4 + 1 + class_num] x_pro = x_part pass with tf.name_scope('h_part'): h_part = pro[:, :, :, 2: ((cluster_object_count - 1) * (4 + 1 + class_num) + 3): 4 + 1 + class_num] h_pro = h_part pass with tf.name_scope('w_part'): w_part = pro[:, :, :, 3: ((cluster_object_count - 1) * (4 + 1 + class_num) + 4): 4 + 1 + class_num] w_pro = w_part pass with tf.name_scope('precision_part'): precision_part = pro[:, :, :, 4: ((cluster_object_count - 1) * (4 + 1 + class_num) + 5): 4 + 1 + class_num] precision_pro = precision_part pass with tf.name_scope('class_part'): class_part = tf.reshape(pro, [-1, 4 + 1 + class_num]) class_part = class_part[:, 5::] class_pro = class_part pass pass with tf.name_scope('anchor_pro'): anchor_pro = tf.concat( [tf.expand_dims(y_pro, axis=-1), tf.expand_dims(x_pro, -1), tf.expand_dims(h_pro, -1), tf.expand_dims(w_pro, -1)], axis=-1) return {'pro': pro, 'anchor': anchor_pro, 'precision': precision_pro, 'class': class_pro, 'y': y_pro, 'x': x_pro, 'h': h_pro, 'w': w_pro} pass # : this function is used to generate the standard pro in yolo-version2 network, which split into # {'pro': pro, 'anchor': anchor_pro, 'precision': precision_pro, 'class': class_pro, # 'y': y_pro, 'x': x_pro, 'h': h_pro, 'w': w_pro} def gen_pro(other_new_feature, class_num, cluster_object_count, _dtype=0.32): """ pro = {'pro': pro, 'anchor': anchor_pro, 'precision': precision_pro, 'class': class_pro, 'y': y_pro, 'x': x_pro, 'h': h_pro, 'w': w_pro} :param other_new_feature: base net feature :param class_num: :param cluster_object_count: :return: """ print(Fore.YELLOW + '-----------generate yolo2 base pro---------') print(Fore.GREEN + 'class_num : ', class_num) print(Fore.GREEN + 'cluster_object_count : ', cluster_object_count) feature_chanel = other_new_feature.shape.as_list()[-1] dtype = tfu.tf_type(_dtype).Type with tf.name_scope('yolo_pro'):
<reponame>maxbeegee/yt """ openPMD data structures """ # ----------------------------------------------------------------------------- # Copyright (c) 2013, yt Development Team. # Copyright (c) 2015, <NAME> (HZDR) # Copyright (c) 2016, <NAME> (HZDR) # # Distributed under the terms of the Modified BSD License. # # The full license is in the file COPYING.txt, distributed with this software. # ----------------------------------------------------------------------------- from distutils.version import StrictVersion from functools import reduce from operator import mul from os import \ path, \ listdir from re import match import numpy as np from yt.data_objects.grid_patch import AMRGridPatch from yt.data_objects.static_output import Dataset from yt.data_objects.time_series import DatasetSeries from yt.frontends.open_pmd.fields import OpenPMDFieldInfo from yt.frontends.open_pmd.misc import \ is_const_component, \ get_component from yt.funcs import setdefaultattr from yt.geometry.grid_geometry_handler import GridIndex from yt.utilities.file_handler import HDF5FileHandler, \ warn_h5py from yt.utilities.logger import ytLogger as mylog from yt.utilities.on_demand_imports import _h5py as h5 ompd_known_versions = [StrictVersion("1.0.0"), StrictVersion("1.0.1"), StrictVersion("1.1.0")] opmd_required_attributes = ["openPMD", "basePath"] class OpenPMDGrid(AMRGridPatch): """Represents chunk of data on-disk. This defines the index and offset for every mesh and particle type. It also defines parents and children grids. Since openPMD does not have multiple levels of refinement, there are no parents or children for any grid. """ _id_offset = 0 __slots__ = ["_level_id"] # Every particle species and mesh might have different hdf5-indices and offsets ftypes = [] ptypes = [] findex = 0 foffset = 0 pindex = 0 poffset = 0 def __init__(self, gid, index, level=-1, fi=0, fo=0, pi=0, po=0, ft=[], pt=[]): AMRGridPatch.__init__(self, gid, filename=index.index_filename, index=index) self.findex = fi self.foffset = fo self.pindex = pi self.poffset = po self.ftypes = ft self.ptypes = pt self.Parent = None self.Children = [] self.Level = level def __repr__(self): return "OpenPMDGrid_%04i (%s)" % (self.id, self.ActiveDimensions) class OpenPMDHierarchy(GridIndex): """Defines which fields and particles are created and read from disk. Furthermore it defines the characteristics of the grids. """ grid = OpenPMDGrid def __init__(self, ds, dataset_type="openPMD"): self.dataset_type = dataset_type self.dataset = ds self.index_filename = ds.parameter_filename self.directory = path.dirname(self.index_filename) GridIndex.__init__(self, ds, dataset_type) def _get_particle_type_counts(self): """Reads the active number of particles for every species. Returns ------- dict keys are ptypes values are integer counts of the ptype """ result = {} f = self.dataset._handle bp = self.dataset.base_path pp = self.dataset.particles_path try: for ptype in self.ds.particle_types_raw: if str(ptype) == "io": spec = list(f[bp + pp].keys())[0] else: spec = ptype axis = list(f[bp + pp + "/" + spec + "/position"].keys())[0] pos = f[bp + pp + "/" + spec + "/position/" + axis] if is_const_component(pos): result[ptype] = pos.attrs["shape"] else: result[ptype] = pos.len() except(KeyError): result["io"] = 0 return result def _detect_output_fields(self): """Populates ``self.field_list`` with native fields (mesh and particle) on disk. Each entry is a tuple of two strings. The first element is the on-disk fluid type or particle type. The second element is the name of the field in yt. This string is later used for accessing the data. Convention suggests that the on-disk fluid type should be "openPMD", the on-disk particle type (for a single species of particles) is "io" or (for multiple species of particles) the particle name on-disk. """ f = self.dataset._handle bp = self.dataset.base_path mp = self.dataset.meshes_path pp = self.dataset.particles_path mesh_fields = [] try: meshes = f[bp + mp] for mname in meshes.keys(): try: mesh = meshes[mname] for axis in mesh.keys(): mesh_fields.append(mname.replace("_", "-") + "_" + axis) except AttributeError: # This is a h5.Dataset (i.e. no axes) mesh_fields.append(mname.replace("_", "-")) except(KeyError, TypeError, AttributeError): pass self.field_list = [("openPMD", str(field)) for field in mesh_fields] particle_fields = [] try: particles = f[bp + pp] for pname in particles.keys(): species = particles[pname] for recname in species.keys(): record = species[recname] if is_const_component(record): # Record itself (e.g. particle_mass) is constant particle_fields.append(pname.replace("_", "-") + "_" + recname.replace("_", "-")) elif "particlePatches" not in recname: try: # Create a field for every axis (x,y,z) of every property (position) # of every species (electrons) axes = list(record.keys()) if str(recname) == "position": recname = "positionCoarse" for axis in axes: particle_fields.append(pname.replace("_", "-") + "_" + recname.replace("_", "-") + "_" + axis) except AttributeError: # Record is a dataset, does not have axes (e.g. weighting) particle_fields.append(pname.replace("_", "-") + "_" + recname.replace("_", "-")) pass else: pass if len(list(particles.keys())) > 1: # There is more than one particle species, use the specific names as field types self.field_list.extend( [(str(field).split("_")[0], ("particle_" + "_".join(str(field).split("_")[1:]))) for field in particle_fields]) else: # Only one particle species, fall back to "io" self.field_list.extend( [("io", ("particle_" + "_".join(str(field).split("_")[1:]))) for field in particle_fields]) except(KeyError, TypeError, AttributeError): pass def _count_grids(self): """Sets ``self.num_grids`` to be the total number of grids in the simulation. The number of grids is determined by their respective memory footprint. """ f = self.dataset._handle bp = self.dataset.base_path mp = self.dataset.meshes_path pp = self.dataset.particles_path self.meshshapes = {} self.numparts = {} self.num_grids = 0 try: meshes = f[bp + mp] for mname in meshes.keys(): mesh = meshes[mname] if type(mesh) is h5.Group: shape = mesh[list(mesh.keys())[0]].shape else: shape = mesh.shape spacing = tuple(mesh.attrs["gridSpacing"]) offset = tuple(mesh.attrs["gridGlobalOffset"]) unit_si = mesh.attrs["gridUnitSI"] self.meshshapes[mname] = (shape, spacing, offset, unit_si) except(KeyError, TypeError, AttributeError): pass try: particles = f[bp + pp] for pname in particles.keys(): species = particles[pname] if "particlePatches" in species.keys(): for (patch, size) in enumerate(species["/particlePatches/numParticles"]): self.numparts[pname + "#" + str(patch)] = size else: axis = list(species["/position"].keys())[0] if is_const_component(species["/position/" + axis]): self.numparts[pname] = species["/position/" + axis].attrs["shape"] else: self.numparts[pname] = species["/position/" + axis].len() except(KeyError, TypeError, AttributeError): pass # Limit values per grid by resulting memory footprint self.vpg = int(self.dataset.gridsize / 4) # 4Byte per value (f32) # Meshes of the same size do not need separate chunks for (shape, spacing, offset, unit_si) in set(self.meshshapes.values()): self.num_grids += min(shape[0], int(np.ceil(reduce(mul, shape) * self.vpg**-1))) # Same goes for particle chunks if they are not inside particlePatches patches = {} no_patches = {} for (k, v) in self.numparts.items(): if "#" in k: patches[k] = v else: no_patches[k] = v for size in set(no_patches.values()): self.num_grids += int(np.ceil(size * self.vpg**-1)) for size in patches.values(): self.num_grids += int(np.ceil(size * self.vpg**-1)) def _parse_index(self): """Fills each grid with appropriate properties (extent, dimensions, ...) This calculates the properties of every OpenPMDGrid based on the total number of grids in the simulation. The domain is divided into ``self.num_grids`` (roughly) equally sized chunks along the x-axis. ``grid_levels`` is always equal to 0 since we only have one level of refinement in openPMD. Notes ----- ``self.grid_dimensions`` is rounded to the nearest integer. Grid edges are calculated from this dimension. Grids with dimensions [0, 0, 0] are particle only. The others do not have any particles affiliated with them. """ f = self.dataset._handle bp = self.dataset.base_path pp = self.dataset.particles_path self.grid_levels.flat[:] = 0 self.grids = np.empty(self.num_grids, dtype="object") grid_index_total = 0 # Mesh grids for mesh in set(self.meshshapes.values()): (shape, spacing, offset, unit_si) = mesh shape = np.asarray(shape) spacing = np.asarray(spacing) offset = np.asarray(offset) # Total dimension of this grid domain_dimension = np.asarray(shape, dtype=np.int32) domain_dimension = np.append(domain_dimension, np.ones(3 - len(domain_dimension))) # Number of grids of this shape num_grids = min(shape[0], int(np.ceil(reduce(mul, shape) * self.vpg**-1))) gle = offset * unit_si # self.dataset.domain_left_edge gre = domain_dimension[:spacing.size] * unit_si * spacing + gle # self.dataset.domain_right_edge gle = np.append(gle, np.zeros(3 - len(gle))) gre = np.append(gre, np.ones(3 - len(gre))) grid_dim_offset = np.linspace(0, domain_dimension[0], num_grids + 1, dtype=np.int32) grid_edge_offset = grid_dim_offset * np.float(domain_dimension[0])**-1 * (gre[0] - gle[0]) + gle[0] mesh_names = [] for (mname, mdata) in self.meshshapes.items(): if mesh == mdata: mesh_names.append(str(mname)) prev = 0 for grid in np.arange(num_grids): self.grid_dimensions[grid_index_total] = domain_dimension self.grid_dimensions[grid_index_total][0] = grid_dim_offset[grid + 1] - grid_dim_offset[grid] self.grid_left_edge[grid_index_total] = gle self.grid_left_edge[grid_index_total][0] = grid_edge_offset[grid] self.grid_right_edge[grid_index_total] = gre self.grid_right_edge[grid_index_total][0] = grid_edge_offset[grid + 1] self.grid_particle_count[grid_index_total] = 0 self.grids[grid_index_total] = self.grid(grid_index_total, self, 0, fi=prev, fo=self.grid_dimensions[grid_index_total][0], ft=mesh_names) prev += self.grid_dimensions[grid_index_total][0] grid_index_total += 1 handled_ptypes = [] # Particle grids for (species, count) in self.numparts.items(): if "#" in species: # This is a particlePatch spec = species.split("#") patch = f[bp + pp + "/" + spec[0] + "/particlePatches"] domain_dimension = np.ones(3, dtype=np.int32) for (ind, axis) in enumerate(list(patch["extent"].keys())): domain_dimension[ind] = patch["extent/" + axis][()][int(spec[1])] num_grids = int(np.ceil(count * self.vpg**-1)) gle = [] for axis in patch["offset"].keys(): gle.append(get_component(patch, "offset/" + axis, int(spec[1]), 1)[0]) gle = np.asarray(gle) gle = np.append(gle, np.zeros(3 - len(gle))) gre = [] for axis in patch["extent"].keys(): gre.append(get_component(patch, "extent/"
<reponame>YoheiN/donkeycar ''' utils.py Functions that don't fit anywhere else. ''' from io import BytesIO import os import glob import socket import zipfile import sys import itertools import subprocess import math import random import time from PIL import Image import numpy as np ''' IMAGES ''' def scale(im, size=128): ''' accepts: PIL image, size of square sides returns: PIL image scaled so sides lenght = size ''' size = (size,size) im.thumbnail(size, Image.ANTIALIAS) return im def img_to_binary(img, format='jpeg'): ''' accepts: PIL image returns: binary stream (used to save to database) ''' f = BytesIO() try: img.save(f, format=format) except Exception as e: raise e return f.getvalue() def arr_to_binary(arr): ''' accepts: numpy array with shape (Hight, Width, Channels) returns: binary stream (used to save to database) ''' img = arr_to_img(arr) return img_to_binary(img) def arr_to_img(arr): ''' accepts: numpy array with shape (Hight, Width, Channels) returns: binary stream (used to save to database) ''' arr = np.uint8(arr) img = Image.fromarray(arr) return img def img_to_arr(img): ''' accepts: numpy array with shape (Hight, Width, Channels) returns: binary stream (used to save to database) ''' return np.array(img) def binary_to_img(binary): ''' accepts: binary file object from BytesIO returns: PIL image ''' if binary is None or len(binary) == 0: return None img = BytesIO(binary) try: img = Image.open(img) return img except: return None def norm_img(img): return (img - img.mean() / np.std(img))/255.0 def create_video(img_dir_path, output_video_path): import envoy # Setup path to the images with telemetry. full_path = os.path.join(img_dir_path, 'frame_*.png') # Run ffmpeg. command = ("""ffmpeg -framerate 30/1 -pattern_type glob -i '%s' -c:v libx264 -r 15 -pix_fmt yuv420p -y %s""" % (full_path, output_video_path)) response = envoy.run(command) def rgb2gray(rgb): ''' take a numpy rgb image return a new single channel image converted to greyscale ''' return np.dot(rgb[...,:3], [0.299, 0.587, 0.114]) def img_crop(img_arr, top, bottom): if bottom is 0: end = img_arr.shape[0] else: end = -bottom return img_arr[top:end,: ,:] def normalize_and_crop(img_arr, cfg): img_arr = img_arr.astype(np.float32) / 255.0 if cfg.ROI_CROP_TOP or cfg.ROI_CROP_BOTTOM: img_arr = img_crop(img_arr, cfg.ROI_CROP_TOP, cfg.ROI_CROP_BOTTOM) return img_arr def load_scaled_image_arr(filename, cfg): ''' load an image from the filename, and use the cfg to resize if needed also apply cropping and normalize ''' import donkeycar as dk try: img = Image.open(filename) if img.height != cfg.IMAGE_H or img.width != cfg.IMAGE_W: img = img.resize((cfg.IMAGE_W, cfg.IMAGE_H)) img_arr = np.array(img) img_arr = normalize_and_crop(img_arr, cfg) if img_arr.shape[2] == 3 and cfg.IMAGE_DEPTH == 1: img_arr = dk.utils.rgb2gray(img_arr).reshape(cfg.IMAGE_H, cfg.IMAGE_W, 1) except Exception as e: print(e) print('failed to load image:', filename) img_arr = None return img_arr ''' FILES ''' def most_recent_file(dir_path, ext=''): ''' return the most recent file given a directory path and extension ''' query = dir_path + '/*' + ext newest = min(glob.iglob(query), key=os.path.getctime) return newest def make_dir(path): real_path = os.path.expanduser(path) if not os.path.exists(real_path): os.makedirs(real_path) return real_path def zip_dir(dir_path, zip_path): """ Create and save a zipfile of a one level directory """ file_paths = glob.glob(dir_path + "/*") #create path to search for files. zf = zipfile.ZipFile(zip_path, 'w') dir_name = os.path.basename(dir_path) for p in file_paths: file_name = os.path.basename(p) zf.write(p, arcname=os.path.join(dir_name, file_name)) zf.close() return zip_path ''' BINNING functions to help converte between floating point numbers and categories. ''' def clamp(n, min, max): if n < min: return min if n > max: return max return n def linear_bin(a, N=15, offset=1, R=2.0): ''' create a bin of length N map val A to range R offset one hot bin by offset, commonly R/2 ''' a = a + offset b = round(a / (R/(N-offset))) arr = np.zeros(N) b = clamp(b, 0, N - 1) arr[int(b)] = 1 return arr def linear_unbin(arr, N=15, offset=-1, R=2.0): ''' preform inverse linear_bin, taking one hot encoded arr, and get max value rescale given R range and offset ''' b = np.argmax(arr) a = b *(R/(N + offset)) + offset return a def map_range(x, X_min, X_max, Y_min, Y_max): ''' Linear mapping between two ranges of values ''' X_range = X_max - X_min Y_range = Y_max - Y_min XY_ratio = X_range/Y_range y = ((x-X_min) / XY_ratio + Y_min) // 1 return int(y) ''' ANGLES ''' def norm_deg(theta): while theta > 360: theta -= 360 while theta < 0: theta += 360 return theta DEG_TO_RAD = math.pi / 180.0 def deg2rad(theta): return theta * DEG_TO_RAD ''' VECTORS ''' def dist(x1, y1, x2, y2): return math.sqrt(math.pow(x2 - x1, 2) + math.pow(y2 - y1, 2)) ''' NETWORKING ''' def my_ip(): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(('172.16.31.10', 1027)) return s.getsockname()[0] ''' OTHER ''' def merge_two_dicts(x, y): """Given two dicts, merge them into a new dict as a shallow copy.""" z = x.copy() z.update(y) return z def param_gen(params): ''' Accepts a dictionary of parameter options and returns a list of dictionary with the permutations of the parameters. ''' for p in itertools.product(*params.values()): yield dict(zip(params.keys(), p )) def run_shell_command(cmd, cwd=None, timeout=15): proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd) out = [] err = [] try: proc.wait(timeout=timeout) except subprocess.TimeoutExpired: kill(proc.pid) for line in proc.stdout.readlines(): out.append(line.decode()) for line in proc.stderr.readlines(): err.append(line) return out, err, proc.pid ''' def kill(proc_pid): process = psutil.Process(proc_pid) for proc in process.children(recursive=True): proc.kill() process.kill() ''' import signal def kill(proc_id): os.kill(proc_id, signal.SIGINT) def eprint(*args, **kwargs): print(*args, file=sys.stderr, **kwargs) """ Tub management """ def expand_path_masks(paths): ''' take a list of paths and expand any wildcards returns a new list of paths fully expanded ''' import glob expanded_paths = [] for path in paths: if '*' in path or '?' in path: mask_paths = glob.glob(path) expanded_paths += mask_paths else: expanded_paths.append(path) return expanded_paths def gather_tub_paths(cfg, tub_names=None): ''' takes as input the configuration, and the comma seperated list of tub paths returns a list of Tub paths ''' if tub_names: if type(tub_names) == list: tub_paths = [os.path.expanduser(n) for n in tub_names] else: tub_paths = [os.path.expanduser(n) for n in tub_names.split(',')] return expand_path_masks(tub_paths) else: paths = [os.path.join(cfg.DATA_PATH, n) for n in os.listdir(cfg.DATA_PATH)] dir_paths = [] for p in paths: if os.path.isdir(p): dir_paths.append(p) return dir_paths def gather_tubs(cfg, tub_names): ''' takes as input the configuration, and the comma seperated list of tub paths returns a list of Tub objects initialized to each path ''' from donkeycar.parts.datastore import Tub tub_paths = gather_tub_paths(cfg, tub_names) tubs = [Tub(p) for p in tub_paths] return tubs """ Training helpers """ def get_image_index(fnm): sl = os.path.basename(fnm).split('_') return int(sl[0]) def get_record_index(fnm): sl = os.path.basename(fnm).split('_') return int(sl[1].split('.')[0]) def gather_records(cfg, tub_names, opts=None, verbose=False): tubs = gather_tubs(cfg, tub_names) records = [] for tub in tubs: if verbose: print(tub.path) record_paths = tub.gather_records() records += record_paths return records def get_model_by_type(model_type, cfg): ''' given the string model_type and the configuration settings in cfg create a Keras model and return it. ''' from donkeycar.parts.keras import KerasRNN_LSTM, KerasBehavioral, KerasCategorical, KerasIMU, KerasLinear, Keras3D_CNN, KerasLocalizer, KerasLatent from donkeycar.parts.tflite import TFLitePilot if model_type is None: model_type = cfg.DEFAULT_MODEL_TYPE print("\"get_model_by_type\" model Type is: {}".format(model_type)) input_shape = (cfg.IMAGE_H, cfg.IMAGE_W, cfg.IMAGE_DEPTH) roi_crop = (cfg.ROI_CROP_TOP, cfg.ROI_CROP_BOTTOM) if model_type == "tflite_linear": kl = TFLitePilot() elif model_type == "localizer" or cfg.TRAIN_LOCALIZER: kl = KerasLocalizer(num_outputs=2, num_behavior_inputs=len(cfg.BEHAVIOR_LIST), num_locations=cfg.NUM_LOCATIONS, input_shape=input_shape) elif model_type == "behavior" or cfg.TRAIN_BEHAVIORS: kl = KerasBehavioral(num_outputs=2, num_behavior_inputs=len(cfg.BEHAVIOR_LIST), input_shape=input_shape) elif model_type == "imu": kl = KerasIMU(num_outputs=2, num_imu_inputs=6, input_shape=input_shape) elif model_type == "linear": kl = KerasLinear(input_shape=input_shape, roi_crop=roi_crop) elif model_type == "tensorrt_linear": # Aggressively lazy load this. This module imports pycuda.autoinit which causes a lot of unexpected things # to happen when using TF-GPU for training. from donkeycar.parts.tensorrt import TensorRTLinear kl = TensorRTLinear(cfg=cfg) elif model_type == "3d": kl = Keras3D_CNN(image_w=cfg.IMAGE_W, image_h=cfg.IMAGE_H, image_d=cfg.IMAGE_DEPTH, seq_length=cfg.SEQUENCE_LENGTH) elif model_type == "rnn": kl = KerasRNN_LSTM(image_w=cfg.IMAGE_W, image_h=cfg.IMAGE_H, image_d=cfg.IMAGE_DEPTH, seq_length=cfg.SEQUENCE_LENGTH) elif model_type == "categorical": kl = KerasCategorical(input_shape=input_shape, throttle_range=cfg.MODEL_CATEGORICAL_MAX_THROTTLE_RANGE, roi_crop=roi_crop) elif model_type == "latent": kl = KerasLatent(input_shape=input_shape) else: raise Exception("unknown model type: %s" % model_type) return kl def get_test_img(model): ''' query the input to see what it likes make an image capable of using with that test model ''' assert(len(model.inputs) > 0) try: count, h, w, ch = model.inputs[0].get_shape() seq_len = 0 except Exception as e: count, seq_len, h, w, ch = model.inputs[0].get_shape() #generate random array in the right shape img = np.random.rand(int(h), int(w), int(ch)) return img def train_test_split(data_list, shuffle=True, test_size=0.2): ''' take a list, split it into two sets while selecting a random element in order to shuffle the results. use the test_size to choose the split percent. shuffle is always True, left there to be backwards compatible ''' assert(shuffle==True) train_data = [] target_train_size = len(data_list) * (1. - test_size) i_sample = 0 while i_sample < target_train_size and len(data_list) > 1: i_choice
m.b148*m.b435 + m.b148*m.b443 + m.b148*m.b445 + m.b148*m.b446 + m.b148*m.b464 + m.b148*m.b479 + m.b148*m.b489 + m.b148*m.b494 + m.b148*m.b551 + m.b148*m.b564 + m.b148*m.b568 + m.b148*m.b573 + m.b148*m.b593 + m.b148*m.b598 + m.b148*m.b601 + m.b148*m.b613 + m.b148*m.b620 + m.b148*m.b622 + m.b148*m.b625 + m.b148*m.b643 + m.b148*m.b647 + 0.5*m.b149*m.b151 + 0.5*m.b149*m.b162 + m.b149* m.b169 + m.b149*m.b174 + 0.5*m.b149*m.b176 + 0.5*m.b149*m.b178 + 0.5*m.b149*m.b183 + 0.5*m.b149* m.b184 + 0.5*m.b149*m.b186 + 0.5*m.b150*m.b152 + 0.5*m.b150*m.b154 + 0.5*m.b150*m.b155 + 0.5* m.b150*m.b158 + 0.5*m.b150*m.b161 + 0.5*m.b150*m.b163 + 0.5*m.b150*m.b164 + 0.5*m.b150*m.b165 + m.b150*m.b166 + 0.5*m.b150*m.b180 + 0.5*m.b150*m.b181 + 0.5*m.b150*m.b252 + 0.5*m.b150*m.b253 + 0.5*m.b150*m.b265 + 0.5*m.b150*m.b298 + 0.5*m.b150*m.b300 + 0.5*m.b150*m.b318 + 0.5*m.b150*m.b334 + 0.5*m.b150*m.b337 + 0.5*m.b150*m.b357 + 0.5*m.b150*m.b374 + 0.5*m.b150*m.b383 + 0.5*m.b150* m.b397 + 0.5*m.b150*m.b402 + 0.5*m.b150*m.b410 + 0.5*m.b150*m.b411 + 0.5*m.b150*m.b505 + 0.5* m.b150*m.b509 + 0.5*m.b150*m.b510 + 0.5*m.b150*m.b530 + 0.5*m.b150*m.b536 + 0.5*m.b150*m.b544 + 0.5*m.b150*m.b547 + 0.5*m.b150*m.b553 + 0.5*m.b150*m.b562 + 0.5*m.b150*m.b569 + 0.5*m.b150*m.b574 + 0.5*m.b150*m.b576 + 0.5*m.b150*m.b583 + 0.5*m.b150*m.b586 + 0.5*m.b150*m.b591 + 0.5*m.b150* m.b602 + 0.5*m.b150*m.b605 + 0.5*m.b150*m.b641 + 0.5*m.b150*m.b645 + 0.5*m.b150*m.b648 + 0.5* m.b150*m.b650 + 0.5*m.b150*m.b656 + 0.5*m.b150*m.b658 + 0.5*m.b150*m.b662 + 0.5*m.b150*m.b666 + m.b150*m.x842 + m.b151*m.b162 + 0.5*m.b151*m.b169 + 0.5*m.b151*m.b174 + m.b151*m.b184 + 0.5* m.b151*m.b251 + 0.5*m.b151*m.b263 + 0.5*m.b151*m.b271 + 0.5*m.b151*m.b284 + m.b152*m.b154 + 0.5* m.b152*m.b155 + 0.5*m.b152*m.b158 + 0.5*m.b152*m.b161 + 0.5*m.b152*m.b163 + 0.5*m.b152*m.b164 + m.b152*m.b165 + 0.5*m.b152*m.b166 + 0.5*m.b152*m.b180 + 0.5*m.b152*m.b181 + 0.5*m.b152*m.b252 + 0.5*m.b152*m.b253 + 0.5*m.b152*m.b265 + 0.5*m.b152*m.b298 + 0.5*m.b152*m.b300 + 0.5*m.b152*m.b318 + 0.5*m.b152*m.b334 + 0.5*m.b152*m.b337 + 0.5*m.b152*m.b357 + 0.5*m.b152*m.b374 + 0.5*m.b152* m.b383 + 0.5*m.b152*m.b397 + 0.5*m.b152*m.b402 + 0.5*m.b152*m.b410 + 0.5*m.b152*m.b411 + 0.5* m.b152*m.b431 + 0.5*m.b152*m.b505 + 0.5*m.b152*m.b507 + 0.5*m.b152*m.b509 + 0.5*m.b152*m.b510 + 0.5*m.b152*m.b519 + 0.5*m.b152*m.b530 + 0.5*m.b152*m.b533 + 0.5*m.b152*m.b536 + 0.5*m.b152*m.b544 + 0.5*m.b152*m.b547 + 0.5*m.b152*m.b553 + 0.5*m.b152*m.b562 + 0.5*m.b152*m.b569 + 0.5*m.b152* m.b574 + 0.5*m.b152*m.b576 + 0.5*m.b152*m.b583 + 0.5*m.b152*m.b586 + 0.5*m.b152*m.b591 + 0.5* m.b152*m.b602 + 0.5*m.b152*m.b605 + 0.5*m.b152*m.b616 + 0.5*m.b152*m.b641 + 0.5*m.b152*m.b642 + 0.5*m.b152*m.b645 + 0.5*m.b152*m.b648 + 0.5*m.b152*m.b650 + 0.5*m.b152*m.b652 + 0.5*m.b152*m.b656 + 0.5*m.b152*m.b658 + 0.5*m.b152*m.b662 + 0.5*m.b152*m.b666 + 0.5*m.b153*m.b156 + 0.5*m.b153* m.b157 + 0.5*m.b153*m.b159 + 0.5*m.b153*m.b160 + m.b153*m.b167 + 0.5*m.b153*m.b168 + 0.5*m.b153* m.b170 + m.b153*m.b171 + 0.5*m.b153*m.b172 + 0.5*m.b153*m.b173 + 0.5*m.b153*m.b175 + 0.5*m.b153* m.b176 + 0.5*m.b153*m.b177 + 0.5*m.b153*m.b178 + 0.5*m.b153*m.b179 + 0.5*m.b153*m.b183 + 0.5* m.b153*m.b186 + 0.5*m.b153*m.b251 + 0.5*m.b153*m.b263 + 0.5*m.b153*m.b271 + 0.5*m.b153*m.b284 + 0.5*m.b154*m.b155 + 0.5*m.b154*m.b158 + 0.5*m.b154*m.b161 + 0.5*m.b154*m.b163 + 0.5*m.b154*m.b164 + m.b154*m.b165 + 0.5*m.b154*m.b166 + 0.5*m.b154*m.b180 + 0.5*m.b154*m.b181 + 0.5*m.b154*m.b252 + 0.5*m.b154*m.b253 + 0.5*m.b154*m.b265 + 0.5*m.b154*m.b298 + 0.5*m.b154*m.b300 + 0.5*m.b154* m.b318 + 0.5*m.b154*m.b334 + 0.5*m.b154*m.b337 + 0.5*m.b154*m.b357 + 0.5*m.b154*m.b374 + 0.5* m.b154*m.b383 + 0.5*m.b154*m.b397 + 0.5*m.b154*m.b402 + 0.5*m.b154*m.b410 + 0.5*m.b154*m.b411 + 0.5*m.b154*m.b431 + 0.5*m.b154*m.b505 + 0.5*m.b154*m.b507 + 0.5*m.b154*m.b509 + 0.5*m.b154*m.b510 + 0.5*m.b154*m.b519 + 0.5*m.b154*m.b530 + 0.5*m.b154*m.b533 + 0.5*m.b154*m.b536 + 0.5*m.b154* m.b544 + 0.5*m.b154*m.b547 + 0.5*m.b154*m.b553 + 0.5*m.b154*m.b562 + 0.5*m.b154*m.b569 + 0.5* m.b154*m.b574 + 0.5*m.b154*m.b576 + 0.5*m.b154*m.b583 + 0.5*m.b154*m.b586 + 0.5*m.b154*m.b591 + 0.5*m.b154*m.b602 + 0.5*m.b154*m.b605 + 0.5*m.b154*m.b616 + 0.5*m.b154*m.b641 + 0.5*m.b154*m.b642 + 0.5*m.b154*m.b645 + 0.5*m.b154*m.b648 + 0.5*m.b154*m.b650 + 0.5*m.b154*m.b652 + 0.5*m.b154* m.b656 + 0.5*m.b154*m.b658 + 0.5*m.b154*m.b662 + 0.5*m.b154*m.b666 + 0.5*m.b155*m.b158 + 0.5* m.b155*m.b161 + 0.5*m.b155*m.b163 + m.b155*m.b164 + 0.5*m.b155*m.b165 + 0.5*m.b155*m.b166 + m.b155*m.b180 + 0.5*m.b155*m.b181 + 0.5*m.b155*m.b252 + 0.5*m.b155*m.b253 + 0.5*m.b155*m.b265 + 0.5*m.b155*m.b298 + 0.5*m.b155*m.b300 + 0.5*m.b155*m.b318 + 0.5*m.b155*m.b334 + 0.5*m.b155*m.b337 + 0.5*m.b155*m.b357 + 0.5*m.b155*m.b374 + 0.5*m.b155*m.b383 + 0.5*m.b155*m.b397 + 0.5*m.b155* m.b402 + 0.5*m.b155*m.b410 + 0.5*m.b155*m.b411 + 0.5*m.b155*m.b505 + 0.5*m.b155*m.b509 + 0.5* m.b155*m.b510 + 0.5*m.b155*m.b530 + 0.5*m.b155*m.b536 + 0.5*m.b155*m.b544 + 0.5*m.b155*m.b547 + 0.5*m.b155*m.b553 + 0.5*m.b155*m.b562 + 0.5*m.b155*m.b569 + 0.5*m.b155*m.b574 + 0.5*m.b155*m.b576 + 0.5*m.b155*m.b583 + 0.5*m.b155*m.b586 + 0.5*m.b155*m.b591 + 0.5*m.b155*m.b602 + 0.5*m.b155* m.b605 + 0.5*m.b155*m.b641 + 0.5*m.b155*m.b645 + 0.5*m.b155*m.b648 + 0.5*m.b155*m.b650 + 0.5* m.b155*m.b656 + 0.5*m.b155*m.b658 + 0.5*m.b155*m.b662 + 0.5*m.b155*m.b666 + m.b155*m.x843 + m.b156*m.b157 + 0.5*m.b156*m.b167 + m.b156*m.b168 + 0.5*m.b156*m.b171 + 0.5*m.b156*m.b172 + m.b156*m.b175 + 0.5*m.b156*m.b176 + 0.5*m.b156*m.b178 + 0.5*m.b156*m.b183 + 0.5*m.b156*m.b186 + 0.5*m.b156*m.b251 + 0.5*m.b156*m.b263 + 0.5*m.b156*m.b271 + 0.5*m.b156*m.b284 + m.b156*m.x846 + 0.5*m.b157*m.b167 + m.b157*m.b168 + 0.5*m.b157*m.b171 + 0.5*m.b157*m.b172 + m.b157*m.b175 + 0.5* m.b157*m.b176 + 0.5*m.b157*m.b178 + 0.5*m.b157*m.b183 + 0.5*m.b157*m.b186 + 0.5*m.b157*m.b251 + 0.5*m.b157*m.b263 + 0.5*m.b157*m.b271 + 0.5*m.b157*m.b284 + m.b157*m.x846 + 0.5*m.b158*m.b161 + 0.5*m.b158*m.b163 + 0.5*m.b158*m.b164 + 0.5*m.b158*m.b165 + 0.5*m.b158*m.b166 + 0.5*m.b158*m.b180 + 0.5*m.b158*m.b181 + 0.5*m.b158*m.b252 + 0.5*m.b158*m.b253 + 0.5*m.b158*m.b265 + 0.5*m.b158* m.b298 + 0.5*m.b158*m.b300 + 0.5*m.b158*m.b318 + 0.5*m.b158*m.b334 + 0.5*m.b158*m.b337 + 0.5* m.b158*m.b357 + 0.5*m.b158*m.b374 + 0.5*m.b158*m.b383 + 0.5*m.b158*m.b397 + 0.5*m.b158*m.b402 + 0.5*m.b158*m.b410 + 0.5*m.b158*m.b411 + 0.5*m.b158*m.b505 + 0.5*m.b158*m.b509 + 0.5*m.b158*m.b510 + 0.5*m.b158*m.b530 + 0.5*m.b158*m.b536 + 0.5*m.b158*m.b544 + 0.5*m.b158*m.b547 + 0.5*m.b158* m.b553 + 0.5*m.b158*m.b562 + 0.5*m.b158*m.b569 + 0.5*m.b158*m.b574 + 0.5*m.b158*m.b576 + 0.5* m.b158*m.b583 + 0.5*m.b158*m.b586 + 0.5*m.b158*m.b591 + 0.5*m.b158*m.b602 + 0.5*m.b158*m.b605 + 0.5*m.b158*m.b641 + 0.5*m.b158*m.b645 + 0.5*m.b158*m.b648 + 0.5*m.b158*m.b650 + 0.5*m.b158*m.b656 + 0.5*m.b158*m.b658 + 0.5*m.b158*m.b662 + 0.5*m.b158*m.b666 + m.b158*m.x847 + 0.5*m.b159*m.b160 + 0.5*m.b159*m.b167 + 0.5*m.b159*m.b170 + 0.5*m.b159*m.b171 + 0.5*m.b159*m.b173 + 0.5*m.b159* m.b177 + 0.5*m.b159*m.b179 + 0.5*m.b159*m.b336 + 0.5*m.b159*m.b358 + 0.5*m.b159*m.b370 + 0.5* m.b159*m.b382 + 0.5*m.b159*m.b387 + 0.5*m.b159*m.b389 + 0.5*m.b159*m.b403 + 0.5*m.b159*m.b416 + 0.5*m.b159*m.b422 + 0.5*m.b159*m.b425 + 0.5*m.b159*m.b426 + 0.5*m.b159*m.b437 + 0.5*m.b159*m.b468 + 0.5*m.b159*m.b469 + 0.5*m.b159*m.b476 + 0.5*m.b159*m.b478 + 0.5*m.b159*m.b498 + 0.5*m.b159* m.b501 + 0.5*m.b159*m.b502 + 0.5*m.b159*m.b512 + 0.5*m.b159*m.b522 + 0.5*m.b159*m.b525 + 0.5* m.b159*m.b529 + 0.5*m.b159*m.b538 + 0.5*m.b159*m.b571 + 0.5*m.b159*m.b604 + 0.5*m.b159*m.b610 + 0.5*m.b159*m.b629 + 0.5*m.b159*m.b637 + 0.5*m.b159*m.b653 + 0.5*m.b160*m.b167 + m.b160*m.b170 + 0.5*m.b160*m.b171 + 0.5*m.b160*m.b173 + 0.5*m.b160*m.b177 + 0.5*m.b160*m.b179 + m.b161*m.b163 + 0.5*m.b161*m.b164 + 0.5*m.b161*m.b165 + 0.5*m.b161*m.b166 + 0.5*m.b161*m.b180 + m.b161*m.b181 + 0.5*m.b161*m.b252 + 0.5*m.b161*m.b253 + 0.5*m.b161*m.b265 + 0.5*m.b161*m.b298 + 0.5*m.b161*m.b300 + 0.5*m.b161*m.b318 + 0.5*m.b161*m.b334 + 0.5*m.b161*m.b337 + 0.5*m.b161*m.b357 + 0.5*m.b161* m.b374 + 0.5*m.b161*m.b383 + 0.5*m.b161*m.b397 + 0.5*m.b161*m.b402 + 0.5*m.b161*m.b410 + 0.5* m.b161*m.b411 + 0.5*m.b161*m.b505 + 0.5*m.b161*m.b509 + 0.5*m.b161*m.b510 + 0.5*m.b161*m.b530 + 0.5*m.b161*m.b536 + 0.5*m.b161*m.b544 + 0.5*m.b161*m.b547 + 0.5*m.b161*m.b553 + 0.5*m.b161*m.b562 + 0.5*m.b161*m.b569 + 0.5*m.b161*m.b574 + 0.5*m.b161*m.b576 + 0.5*m.b161*m.b583 + 0.5*m.b161* m.b586 + 0.5*m.b161*m.b591 + 0.5*m.b161*m.b602 + 0.5*m.b161*m.b605 + 0.5*m.b161*m.b641 + 0.5* m.b161*m.b645 + 0.5*m.b161*m.b648 + 0.5*m.b161*m.b650 + 0.5*m.b161*m.b656 + 0.5*m.b161*m.b658 + 0.5*m.b161*m.b662 + 0.5*m.b161*m.b666 + 0.5*m.b162*m.b169 + 0.5*m.b162*m.b174 + m.b162*m.b184 + 0.5*m.b162*m.b251 + 0.5*m.b162*m.b263 + 0.5*m.b162*m.b271 + 0.5*m.b162*m.b284 + 0.5*m.b163*m.b164 + 0.5*m.b163*m.b165 + 0.5*m.b163*m.b166 + 0.5*m.b163*m.b180 + m.b163*m.b181 + 0.5*m.b163*m.b252 + 0.5*m.b163*m.b253 + 0.5*m.b163*m.b265 + 0.5*m.b163*m.b298 + 0.5*m.b163*m.b300 + 0.5*m.b163* m.b318 + 0.5*m.b163*m.b334 + 0.5*m.b163*m.b337 + 0.5*m.b163*m.b357 + 0.5*m.b163*m.b374 + 0.5* m.b163*m.b383 + 0.5*m.b163*m.b397 + 0.5*m.b163*m.b402 + 0.5*m.b163*m.b410 + 0.5*m.b163*m.b411 + 0.5*m.b163*m.b505 + 0.5*m.b163*m.b509 + 0.5*m.b163*m.b510 + 0.5*m.b163*m.b530 + 0.5*m.b163*m.b536 + 0.5*m.b163*m.b544 + 0.5*m.b163*m.b547 + 0.5*m.b163*m.b553 + 0.5*m.b163*m.b562 + 0.5*m.b163* m.b569 + 0.5*m.b163*m.b574 + 0.5*m.b163*m.b576 + 0.5*m.b163*m.b583 + 0.5*m.b163*m.b586 + 0.5* m.b163*m.b591 + 0.5*m.b163*m.b602 + 0.5*m.b163*m.b605 + 0.5*m.b163*m.b641 + 0.5*m.b163*m.b645 + 0.5*m.b163*m.b648 + 0.5*m.b163*m.b650 + 0.5*m.b163*m.b656 + 0.5*m.b163*m.b658 + 0.5*m.b163*m.b662 + 0.5*m.b163*m.b666 + 0.5*m.b164*m.b165 + 0.5*m.b164*m.b166 + m.b164*m.b180 + 0.5*m.b164*m.b181 + 0.5*m.b164*m.b252 + 0.5*m.b164*m.b253 + 0.5*m.b164*m.b265 + 0.5*m.b164*m.b298 + 0.5*m.b164* m.b300 + 0.5*m.b164*m.b318 + 0.5*m.b164*m.b334 + 0.5*m.b164*m.b337 + 0.5*m.b164*m.b357 + 0.5* m.b164*m.b374 + 0.5*m.b164*m.b383 + 0.5*m.b164*m.b397 + 0.5*m.b164*m.b402 + 0.5*m.b164*m.b410 + 0.5*m.b164*m.b411 + 0.5*m.b164*m.b505 + 0.5*m.b164*m.b509 + 0.5*m.b164*m.b510 + 0.5*m.b164*m.b530 + 0.5*m.b164*m.b536 + 0.5*m.b164*m.b544 + 0.5*m.b164*m.b547 + 0.5*m.b164*m.b553 + 0.5*m.b164* m.b562 + 0.5*m.b164*m.b569 + 0.5*m.b164*m.b574 + 0.5*m.b164*m.b576 + 0.5*m.b164*m.b583 + 0.5* m.b164*m.b586 + 0.5*m.b164*m.b591 + 0.5*m.b164*m.b602 + 0.5*m.b164*m.b605 + 0.5*m.b164*m.b641 + 0.5*m.b164*m.b645 + 0.5*m.b164*m.b648 + 0.5*m.b164*m.b650 + 0.5*m.b164*m.b656 + 0.5*m.b164*m.b658 + 0.5*m.b164*m.b662 + 0.5*m.b164*m.b666 + m.b164*m.x843 + 0.5*m.b165*m.b166 + 0.5*m.b165*m.b180 + 0.5*m.b165*m.b181 + 0.5*m.b165*m.b252 + 0.5*m.b165*m.b253 + 0.5*m.b165*m.b265 + 0.5*m.b165* m.b298 + 0.5*m.b165*m.b300 + 0.5*m.b165*m.b318 + 0.5*m.b165*m.b334 + 0.5*m.b165*m.b337 + 0.5* m.b165*m.b357 + 0.5*m.b165*m.b374 + 0.5*m.b165*m.b383 + 0.5*m.b165*m.b397 + 0.5*m.b165*m.b402 + 0.5*m.b165*m.b410 + 0.5*m.b165*m.b411 + 0.5*m.b165*m.b431 + 0.5*m.b165*m.b505 + 0.5*m.b165*m.b507 + 0.5*m.b165*m.b509 + 0.5*m.b165*m.b510 + 0.5*m.b165*m.b519 + 0.5*m.b165*m.b530 + 0.5*m.b165* m.b533 + 0.5*m.b165*m.b536 + 0.5*m.b165*m.b544 + 0.5*m.b165*m.b547 + 0.5*m.b165*m.b553 + 0.5* m.b165*m.b562 + 0.5*m.b165*m.b569 + 0.5*m.b165*m.b574 + 0.5*m.b165*m.b576 + 0.5*m.b165*m.b583 + 0.5*m.b165*m.b586 + 0.5*m.b165*m.b591 + 0.5*m.b165*m.b602 + 0.5*m.b165*m.b605 + 0.5*m.b165*m.b616 + 0.5*m.b165*m.b641 + 0.5*m.b165*m.b642 + 0.5*m.b165*m.b645 + 0.5*m.b165*m.b648 + 0.5*m.b165* m.b650 + 0.5*m.b165*m.b652 + 0.5*m.b165*m.b656 + 0.5*m.b165*m.b658 + 0.5*m.b165*m.b662 + 0.5* m.b165*m.b666 + 0.5*m.b166*m.b180 + 0.5*m.b166*m.b181 + 0.5*m.b166*m.b252 + 0.5*m.b166*m.b253 + 0.5*m.b166*m.b265 + 0.5*m.b166*m.b298 + 0.5*m.b166*m.b300 +
#!/usr/bin/env python ######################################################################################## ######################################################################################## # THIS FILE IS DEPRECATED, USE arm_moveit2.py INSTEAD ######################################################################################## ######################################################################################## import sys import os import rospy import moveit_commander import moveit_msgs.msg import moveit_msgs.srv import geometry_msgs.msg import std_msgs.msg import wpi_jaco_msgs.msg import wpi_jaco_msgs.srv from math import pi, floor, ceil, fabs print("*"*80) print("THIS FILE IS DEPRECATED, USE arm_moveit2.py INSTEAD") print("*"*80) class ArmMoveIt: def __init__(self, planning_frame='base_link', default_planner="RRTConnectkConfigDefault", orientation_tolerance=None): # Make sure the moveit service is up and running rospy.logwarn("Waiting for MoveIt! to load") try: rospy.wait_for_service('compute_ik') except rospy.ROSException, e: rospy.logerr("No moveit service detected. Exiting") exit() else: rospy.loginfo("MoveIt detected: arm planner loading") # Check if we're using the 7dof if os.environ.get("ROBOT_NAME") == 'poli2': is_7dof = True else: is_7dof = os.environ['VECTOR_HAS_KINOVA_7DOF_ARM'] # self.pose = geometry_msgs.msg.PoseStamped() ## Instantiate a RobotCommander object. This object is an interface to ## the robot as a whole. self.robot = moveit_commander.RobotCommander() ## Instantiate a PlanningSceneInterface object. This object is an interface ## to the world surrounding the robot. self.scene = moveit_commander.PlanningSceneInterface() ## Instantiate a MoveGroupCommander object. This object is an interface ## to one group of joints. In this case the group is the joints in the left ## arm. This interface can be used to plan and execute motions on the left ## arm. self.group = [moveit_commander.MoveGroupCommander("arm")] # Set orientation tolerance if provided if orientation_tolerance is not None: rospy.loginfo("Setting orientation tolerance to {}".format(orientation_tolerance)) self.group[0].set_goal_orientation_tolerance(orientation_tolerance) # Set the planner self.planner = default_planner # Set the planning pose reference frame self.group[0].set_pose_reference_frame(planning_frame) # Set continuous joint names if is_7dof: self.continuous_joints = ['joint_1','joint_3','joint_5','joint_7'] # NOTE: order that moveit currently is configured # ['joint_1, joint_2, joint_3, joint_4, joint_5, joint_6, joint_7'] self.continuous_joints_list = [0,2,4,6] # joints that are continous else: self.continuous_joints = ['shoulder_pan_joint','wrist_1_joint','wrist_2_joint','wrist_3_joint'] # NOTE: order that moveit currently is configured # ['right_shoulder_pan_joint', 'right_shoulder_lift_joint', 'right_elbow_joint', 'right_wrist_1_joint', 'right_wrist_2_joint', 'right_wrist_3_joint'] self.continuous_joints_list = [0,3,4,5] # joints that are continous def get_IK(self, newPose, root = None): ## from a defined newPose (geometry_msgs.msg.Pose()), retunr its correspondent joint angle(list) rospy.wait_for_service('compute_ik') compute_ik = rospy.ServiceProxy('compute_ik', moveit_msgs.srv.GetPositionIK) wkPose = geometry_msgs.msg.PoseStamped() if root is None: wkPose.header.frame_id = self.group[0].get_planning_frame() # name:odom else: wkPose.header.frame_id = root wkPose.header.stamp=rospy.Time.now() wkPose.pose=newPose msgs_request = moveit_msgs.msg.PositionIKRequest() msgs_request.group_name = self.group[0].get_name() # name: arm # msgs_request.robot_state = robot.get_current_state() msgs_request.pose_stamped = wkPose msgs_request.timeout.secs = 2 msgs_request.avoid_collisions = False try: jointAngle=compute_ik(msgs_request) ans=list(jointAngle.solution.joint_state.position[2:9]) if jointAngle.error_code.val == -31: print 'No IK solution' return None return ans except rospy.ServiceException, e: print "Service call failed: %s"%e def get_FK(self, root = 'base_link'): rospy.wait_for_service('compute_fk') compute_fk = rospy.ServiceProxy('compute_fk', moveit_msgs.srv.GetPositionFK) header = std_msgs.msg.Header() header.frame_id = root header.stamp = rospy.Time.now() fk_link_names = ['j2s7s300_ee_link'] robot_state = self.robot.get_current_state() try: reply=compute_fk(header,fk_link_names,robot_state) return reply.pose_stamped except rospy.ServiceException, e: print "Service call failed: %s"%e def get_FK_wpi(self, joints = None): rospy.wait_for_service('/jaco_arm/kinematics/fk') compute_fk = rospy.ServiceProxy('/jaco_arm/kinematics/fk', wpi_jaco_msgs.srv.JacoFK) if joints is None: joints = [pi,pi,pi,pi,pi,pi,pi] try: pose=compute_fk(joints) return pose except rospy.ServiceException, e: print "Service call failed: %s"%e def plan_targetInput(self, target, joint_flag): '''Generic target planner that what type is specified''' try: if (joint_flag): self.group[0].set_joint_value_target(self._simplify_joints(target)) else: self.group[0].set_pose_target(target) self.group[0].set_planner_id(self.planner) planAns=self.group[0].plan() return planAns except: print 'No plan found, see the moveit terminal for the error' print("Unexpected error:", sys.exc_info()[0]) return None def plan_targetInputWaypoint(self, targets, joint_flag, merged=False, current_joints=None): '''Generic target planner that what type is specified''' ## input: list of pose (geometry_msgs.msg.Pose()) ## output: plan from current pose all of the target poses ## If merge true - then a single large plan is returned ## If merge is false - then several plans in an array are returned # Plan each pose individually and stitch together try: full_plan = [] points = [] current_state = self.robot.get_current_state() if current_joints is not None: current_state = self.set_robot_state_joint_dict(current_joints) for target in targets: self.group[0].set_start_state(current_state) plan = self.plan_targetInput(target, joint_flag) if plan is not None: full_plan.append(plan) if merged: points = self.merge_points(points, plan.joint_trajectory.points) traj = plan.joint_trajectory current_state = self.set_robot_state_pose(traj) else: print 'No full plan found, see the moveit terminal for the error' return None if merged: plan = full_plan[0] plan.joint_trajectory.points = points return plan else: return full_plan except: print 'No plan found, see the moveit terminal for the error' print("Unexpected error:", sys.exc_info()[0]) return None def set_robot_state_pose(self, traj): '''Gets the current robot state pose and sets it to the joint pose''' cur_robot_state = self.robot.get_current_state() last_point = traj.points[-1].positions # convert the joints to array joints = [x for x in cur_robot_state.joint_state.position] for i in xrange(len(traj.joint_names)): # Find index of joint joint_name = traj.joint_names[i] idx = cur_robot_state.joint_state.name.index(joint_name) joints[idx] = last_point[i] # Set full joint tuple now cur_robot_state.joint_state.position = joints return cur_robot_state def set_robot_state_joint_dict(self, joint_dict): cur_robot_state = self.robot.get_current_state() joints = [x for x in cur_robot_state.joint_state.position] for joint_name in joint_dict: idx = cur_robot_state.joint_state.name.index(joint_name) joints[idx] = joint_dict[joint_name] cur_robot_state.joint_state.position = joints return cur_robot_state def merge_points(self, points, new_points): '''Merge two sets of points and taking into account time''' # Check if this is the first set if len(points) < 1: return new_points all_points = points # Pull out the last time from current points last_point_time = points[-1].time_from_start+rospy.Duration(0.1) for point in new_points: point.time_from_start = point.time_from_start+last_point_time all_points = all_points + [point] return all_points def _simplify_angle(self, angle): # Very simple function that makes sure the angles are between -pi and pi if angle > pi: while angle > pi: angle -= 2*pi elif angle < -pi: while angle < -pi: angle += 2*pi return angle def _simplify_joints(self, joint_dict): # Helper function to convert a dictionary of joint values if isinstance(joint_dict, dict): simplified_joints = dict() for joint in joint_dict: # Pull out the name of the joint joint_name = '_'.join(joint.split('_')[1::]) if joint_name in self.continuous_joints: simplified_joints[joint] = self._simplify_angle(joint_dict[joint]) else: simplified_joints[joint] = joint_dict[joint] elif isinstance(joint_dict, list): simplified_joints = [] for i in xrange(len(joint_dict)): a = joint_dict[i] if i in self.continuous_joints_list: simplified_joints.append(self._simplify_angle(a)) else: simplified_joints.append(a) return simplified_joints '''Older functions - left for backwards compatibility''' def plan_jointTargetInput(self,target_joint): ## input: target joint angles (list) of the robot ## output: plan from current joint angles to the target one try: self.group[0].set_joint_value_target(self._simplify_joints(target_joint)) self.group[0].set_planner_id(self.planner) planAns=self.group[0].plan() return planAns except: print 'No plan found, see the moveit terminal for the error' print("Unexpected error:", sys.exc_info()[0]) return None def plan_poseTargetInput(self,target_pose): ## input: tart pose (geometry_msgs.msg.Pose()) ## output: plan from current pose to the target one try: self.group[0].set_pose_target(target_pose) self.group[0].set_planner_id(self.planner) planAns=self.group[0].plan() return planAns except: print 'No plan found, see the moveit terminal for the error' print("Unexpected error:", sys.exc_info()[0]) return None def box_table_scene(self) : #Scene : add box # after loading this object/scene, need to do "add" ==> "planning scene" # in the rviz interface if one want to see the box rospy.sleep(2) self.scene.remove_world_object("table_box") p = geometry_msgs.msg.PoseStamped() p.header.frame_id = self.robot.get_planning_frame() p.pose.position.x = 1.64 p.pose.position.y = 0.0 p.pose.position.z = 0.25 p.pose.orientation.w = 0.0 self.scene.add_box("table_box",p,(0.75, 1, 0.5)) rospy.sleep(5) def wayPointIK(self, wps, numSteps = None, ik_root = None): if numSteps is None: numSteps = 3 jointWps = [] for i in range(0, len(wps)): jointP = self.get_IK(wps[i], ik_root) if jointP is None: jointWps = None break jointWps.append(jointP) return jointWps def ask_scene_integration(arm): # Ask the user if want to integrate a box scene answer= input("""\n Integrate a box as a table from code ? (1 or 0) (if 1: box can't be displaced nor resized by user, if 0: no scene (can always do add from rviz interface) ) \n""") if answer == 1: arm.box_table_scene() print "\n Box inserted; to see it ==> rviz interface ==> add button==> planning scene " return else: print "\n No scene added" return def ask_position(arm,tarPose): #Ask the user the values of the target position while True: try: inputPosition=input(""" \n Target position coord. (format: x,y,z or write -1 to take the robot current position ): """) if inputPosition == -1: inputPosition=tarPose.position return inputPosition except (ValueError,IOError,NameError): print("\n Please, enter the coordinate in the following format: x,y,z ") continue else: if len(list(inputPosition)) == 3: poseTmp= geometry_msgs.msg.Pose() poseTmp.position.x=inputPosition[0] poseTmp.position.y=inputPosition[1] poseTmp.position.z=inputPosition[2] return poseTmp.position else: print("\n Please, enter the coordinate in the following format: x,y,z ") continue def ask_orientation(arm,tarPose): # Ask the user the values of the target quaternion while True: try: inputQuat=input(""" \n Target quaternion coordi. (format: qx,qy,qz,qw or write -1 to take the robot current quaternion ):""") if inputQuat == -1: inputQuat=arm.group[0].get_current_pose().pose.orientation return
:math:`\mathit{h}^2` constrained to ``i / 100``. The values for ``1 <= i <= 99`` are normalized to sum to 1, and ``a[0]`` and ``a[100]`` are set to ``nan``. Returns ------- :class:`ndarray` of :obj:`float64` Normalized likelihood values for :math:`\mathit{h}^2`. """ log_lkhd = np.zeros(101, dtype=np.float64) log_lkhd[0], log_lkhd[100] = np.nan, np.nan for h2 in range(1, 100): gamma = h2 / (100.0 - h2) log_lkhd[h2] = -self.compute_neg_log_reml(np.log(gamma)) log_lkhd -= np.max(log_lkhd[1:-1]) lkhd = np.exp(log_lkhd) lkhd /= np.sum(lkhd[1:-1]) return lkhd @typecheck_method(pa_t_path=str, a_t_path=nullable(str), partition_size=nullable(int)) def fit_alternatives(self, pa_t_path, a_t_path=None, partition_size=None): r"""Fit and test alternative model for each augmented design matrix in parallel. Notes ----- The alternative model is fit using REML constrained to the value of :math:`\gamma` set by :meth:`fit`. The likelihood ratio test of fixed effect parameter :math:`\beta_\star` uses (non-restricted) maximum likelihood: .. math:: \chi^2 = 2 \log\left(\frac{ \max_{\beta_\star, \beta, \sigma^2}\mathrm{N} (y \, | \, x_\star \beta_\star + X \beta; \sigma^2(K + \gamma^{-1}I)} {\max_{\beta, \sigma^2} \mathrm{N} (y \, | \, x_\star \cdot 0 + X \beta; \sigma^2(K + \gamma^{-1}I)} \right) The p-value is given by the tail probability under a chi-squared distribution with one degree of freedom. The resulting table has the following fields: .. list-table:: :header-rows: 1 * - Field - Type - Value * - `idx` - int64 - Index of augmented design matrix. * - `beta` - float64 - :math:`\beta_\star` * - `sigma_sq` - float64 - :math:`\sigma^2` * - `chi_sq` - float64 - :math:`\chi^2` * - `p_value` - float64 - p-value :math:`(P_r A)^T` and :math:`A^T` (if given) must have the same number of rows (augmentations). These rows are grouped into partitions for parallel processing. The number of partitions equals the ceiling of ``n_rows / partition_size``, and should be at least the number or cores to make use of all cores. By default, there is one partition per row of blocks in :math:`(P_r A)^T`. Setting the partition size to an exact (rather than approximate) divisor or multiple of the block size reduces superfluous shuffling of data. The number of columns in each block matrix must be less than :math:`2^{31}`. Warning ------- The block matrices must be stored in row-major format, as results from :meth:`.BlockMatrix.write` with ``force_row_major=True`` and from :meth:`.BlockMatrix.write_from_entry_expr`. Otherwise, this method will produce an error message. Parameters ---------- pa_t_path: :obj:`str` Path to block matrix :math:`(P_r A)^T` with shape :math:`(m, r)`. Each row is a projected augmentation :math:`P_r x_\star` of :math:`P_r X`. a_t_path: :obj:`str`, optional Path to block matrix :math:`A^T` with shape :math:`(m, n)`. Each row is an augmentation :math:`x_\star` of :math:`X`. Include for low-rank inference. partition_size: :obj:`int`, optional Number of rows to process per partition. Default given by block size of :math:`(P_r A)^T`. Returns ------- :class:`.Table` Table of results for each augmented design matrix. """ from hail.table import Table self._check_dof(self.f + 1) if self.low_rank and a_t_path is None: raise ValueError('model is low-rank so a_t is required.') elif not (self.low_rank or a_t_path is None): raise ValueError('model is full-rank so a_t must not be set.') if self._scala_model is None: self._set_scala_model() backend = Env.spark_backend('LinearMixedModel.fit_alternatives') jfs = backend.fs._jfs if partition_size is None: block_size = Env.hail().linalg.BlockMatrix.readMetadata(jfs, pa_t_path).blockSize() partition_size = block_size elif partition_size <= 0: raise ValueError(f'partition_size must be positive, found {partition_size}') jpa_t = Env.hail().linalg.RowMatrix.readBlockMatrix(jfs, pa_t_path, partition_size) if a_t_path is None: maybe_ja_t = None else: maybe_ja_t = Env.hail().linalg.RowMatrix.readBlockMatrix(jfs, a_t_path, partition_size) return Table._from_java(backend._jbackend.pyFitLinearMixedModel( self._scala_model, jpa_t, maybe_ja_t)) @typecheck_method(pa=np.ndarray, a=nullable(np.ndarray), return_pandas=bool) def fit_alternatives_numpy(self, pa, a=None, return_pandas=False): r"""Fit and test alternative model for each augmented design matrix. Notes ----- This Python-only implementation runs serially on leader (master). See the scalable implementation :meth:`fit_alternatives` for documentation of the returned table. Parameters ---------- pa: :class:`ndarray` Projected matrix :math:`P_r A` of alternatives with shape :math:`(r, m)`. Each column is a projected augmentation :math:`P_r x_\star` of :math:`P_r X`. a: :class:`ndarray`, optional Matrix :math:`A` of alternatives with shape :math:`(n, m)`. Each column is an augmentation :math:`x_\star` of :math:`X`. Required for low-rank inference. return_pandas: :obj:`bool` If true, return pandas dataframe. If false, return Hail table. Returns ------- :class:`.Table` or :class:`.pandas.DataFrame` Table of results for each augmented design matrix. """ self._check_dof(self.f + 1) if not self._fitted: raise Exception("null model is not fit. Run 'fit' first.") n_cols = pa.shape[1] assert pa.shape[0] == self.r if self.low_rank: assert a.shape[0] == self.n and a.shape[1] == n_cols data = [(i,) + self._fit_alternative_numpy(pa[:, i], a[:, i]) for i in range(n_cols)] else: data = [(i,) + self._fit_alternative_numpy(pa[:, i], None) for i in range(n_cols)] df = pd.DataFrame.from_records(data, columns=['idx', 'beta', 'sigma_sq', 'chi_sq', 'p_value']) if return_pandas: return df else: return Table.from_pandas(df, key='idx') def _fit_alternative_numpy(self, pa, a): from scipy.linalg import solve, LinAlgError from scipy.stats.distributions import chi2 gamma = self.gamma dpa = self._d_alt * pa # single thread => no need to copy ydy = self._ydy_alt xdy = self._xdy_alt xdx = self._xdx_alt if self.low_rank: xdy[0] = self.py @ dpa + gamma * (self.y @ a) xdx[0, 0] = pa @ dpa + gamma * (a @ a) xdx[0, 1:] = self.px.T @ dpa + gamma * (self.x.T @ a) else: xdy[0] = self.py @ dpa xdx[0, 0] = pa @ dpa xdx[0, 1:] = self.px.T @ dpa try: beta = solve(xdx, xdy, assume_a='pos') # only uses upper triangle residual_sq = ydy - xdy.T @ beta sigma_sq = residual_sq / self._dof_alt chi_sq = self.n * np.log(self._residual_sq / residual_sq) # division => precision p_value = chi2.sf(chi_sq, 1) return beta[0], sigma_sq, chi_sq, p_value except LinAlgError: return tuple(4 * [float('nan')]) def _set_scala_model(self): from hail.utils.java import Env from hail.linalg import _jarray_from_ndarray, _breeze_from_ndarray if not self._fitted: raise Exception("null model is not fit. Run 'fit' first.") self._scala_model = Env.hail().stats.LinearMixedModel.pyApply( self.gamma, self._residual_sq, _jarray_from_ndarray(self.py), _breeze_from_ndarray(self.px), _jarray_from_ndarray(self._d_alt), self._ydy_alt, _jarray_from_ndarray(self._xdy_alt), _breeze_from_ndarray(self._xdx_alt), _jarray_from_ndarray(self.y) if self.low_rank else None, _breeze_from_ndarray(self.x) if self.low_rank else None ) def _check_dof(self, f=None): if f is None: f = self.f dof = self.n - f if dof <= 0: raise ValueError(f"{self.n} {plural('observation', self.n)} with {f} fixed {plural('effect', f)} " f"implies {dof} {plural('degree', dof)} of freedom. Must be positive.") @classmethod @typecheck_method(y=np.ndarray, x=np.ndarray, k=np.ndarray, p_path=nullable(str), overwrite=bool) def from_kinship(cls, y, x, k, p_path=None, overwrite=False): r"""Initializes a model from :math:`y`, :math:`X`, and :math:`K`. Examples -------- >>> from hail.stats import LinearMixedModel >>> y = np.array([0.0, 1.0, 8.0, 9.0]) >>> x = np.array([[1.0, 0.0], ... [1.0, 2.0], ... [1.0, 1.0], ... [1.0, 4.0]]) >>> k = np.array([[ 1. , -0.8727875 , 0.96397335, 0.94512946], ... [-0.8727875 , 1. , -0.93036112, -0.97320323], ... [ 0.96397335, -0.93036112, 1. , 0.98294169], ... [ 0.94512946, -0.97320323, 0.98294169, 1. ]]) >>> model, p = LinearMixedModel.from_kinship(y, x, k) >>> model.fit() >>> model.h_sq # doctest: +SKIP_OUTPUT_CHECK 0.2525148830695317 >>> model.s # doctest: +SKIP_OUTPUT_CHECK array([3.83501295, 0.13540343, 0.02454114, 0.00504248]) Truncate to a rank :math:`r=2` model: >>> r = 2 >>> s_r = model.s[:r] >>> p_r = p[:r, :] >>> model_r = LinearMixedModel(p_r @ y, p_r @ x, s_r, y, x) >>> model.fit() >>> model.h_sq # doctest: +SKIP_OUTPUT_CHECK 0.25193197591429695 Notes ----- This method eigendecomposes :math:`K = P^T S P` on the leader (master) and returns ``LinearMixedModel(p @ y, p @ x, s)`` and ``p``. The performance of eigendecomposition depends critically on the number of leader (master) cores and the NumPy / SciPy configuration, viewable with ``np.show_config()``. For Intel machines, we recommend installing the `MKL <https://anaconda.org/anaconda/mkl>`__ package for Anaconda. `k` must be positive semi-definite; symmetry is not checked as only the lower triangle is used. Parameters ---------- y: :class:`ndarray` :math:`n` vector of observations. x: :class:`ndarray` :math:`n \times p` matrix of fixed effects. k: :class:`ndarray` :math:`n \times n` positive semi-definite kernel :math:`K`. p_path: :obj:`str`, optional Path at which to write :math:`P` as a block matrix. overwrite: :obj:`bool` If ``True``, overwrite an existing file at `p_path`. Returns ------- model: :class:`LinearMixedModel` Model constructed from :math:`y`, :math:`X`, and :math:`K`. p: :class:`ndarray` Matrix :math:`P` whose rows are the eigenvectors of :math:`K`. """ _check_dims(y, "y", 1) _check_dims(x, "x", 2) _check_dims(k, "k", 2) n = k.shape[0] if k.shape[1] != n: raise ValueError("from_kinship: 'k' must be a square matrix") if y.shape[0] != n: raise ValueError("from_kinship: 'y' and 'k' must have the same " "number of rows") if x.shape[0] != n:
}) for item in items: setResponseTimeLimit() itemModel.remove(item, progress=progress, **kwargs) if progress: progress.update(increment=1, message='Deleted item %s' % item['name']) # subsequent operations take a long time, so free the cursor's resources items.close() # Delete all child folders folders = self.find({ 'parentId': folder['_id'], 'parentCollection': 'folder' }) for subfolder in folders: self.remove(subfolder, progress=progress, **kwargs) folders.close() def remove(self, folder, progress=None, **kwargs): """ Delete a folder recursively. :param folder: The folder document to delete. :type folder: dict :param progress: A progress context to record progress on. :type progress: girder.utility.progress.ProgressContext or None. """ # Remove the contents underneath this folder recursively. from .upload import Upload self.clean(folder, progress, **kwargs) # Delete pending uploads into this folder uploadModel = Upload() uploads = uploadModel.find({ 'parentId': folder['_id'], 'parentType': 'folder' }) for upload in uploads: uploadModel.remove(upload, progress=progress, **kwargs) uploads.close() # Delete this folder AccessControlledModel.remove(self, folder, progress=progress, **kwargs) if progress: progress.update(increment=1, message='Deleted folder %s' % folder['name']) def childItems(self, folder, limit=0, offset=0, sort=None, filters=None, **kwargs): """ Generator function that yields child items in a folder. Passes any kwargs to the find function. :param folder: The parent folder. :param limit: Result limit. :param offset: Result offset. :param sort: The sort structure to pass to pymongo. :param filters: Additional query operators. """ from .item import Item q = { 'folderId': folder['_id'] } q.update(filters or {}) return Item().find(q, limit=limit, offset=offset, sort=sort, **kwargs) def childFolders(self, parent, parentType, user=None, limit=0, offset=0, sort=None, filters=None, **kwargs): """ This generator will yield child folders of a user, collection, or folder, with access policy filtering. Passes any kwargs to the find function. :param parent: The parent object. :type parentType: Type of the parent object. :param parentType: The parent type. :type parentType: 'user', 'folder', or 'collection' :param user: The user running the query. Only returns folders that this user can see. :param limit: Result limit. :param offset: Result offset. :param sort: The sort structure to pass to pymongo. :param filters: Additional query operators. """ if not filters: filters = {} parentType = parentType.lower() if parentType not in ('folder', 'user', 'collection'): raise ValidationException('The parentType must be folder, collection, or user.') q = { 'parentId': parent['_id'], 'parentCollection': parentType } q.update(filters) cursor = self.findWithPermissions( q, sort=sort, user=user, level=AccessType.READ, limit=limit, offset=offset, **kwargs) return iter(cursor) def createFolder(self, parent, name, description='', parentType='folder', public=None, creator=None, allowRename=False, reuseExisting=False): """ Create a new folder under the given parent. :param parent: The parent document. Should be a folder, user, or collection. :type parent: dict :param name: The name of the folder. :type name: str :param description: Description for the folder. :type description: str :param parentType: What type the parent is: ('folder' | 'user' | 'collection') :type parentType: str :param public: Public read access flag. :type public: bool or None to inherit from parent :param creator: User document representing the creator of this folder. :type creator: dict :param allowRename: if True and a folder or item of this name exists, automatically rename the folder. :type allowRename: bool :param reuseExisting: If a folder with the given name already exists under the given parent, return that folder rather than creating a new one. :type reuseExisting: bool :returns: The folder document that was created. """ if reuseExisting: existing = self.findOne({ 'parentId': parent['_id'], 'name': name, 'parentCollection': parentType }) if existing: return existing parentType = parentType.lower() if parentType not in ('folder', 'user', 'collection'): raise ValidationException('The parentType must be folder, collection, or user.') if parentType == 'folder': if 'baseParentId' not in parent: pathFromRoot = self.parentsToRoot( parent, user=creator, force=True) parent['baseParentId'] = pathFromRoot[0]['object']['_id'] parent['baseParentType'] = pathFromRoot[0]['type'] else: parent['baseParentId'] = parent['_id'] parent['baseParentType'] = parentType now = datetime.datetime.utcnow() if creator is None: creatorId = None else: creatorId = creator.get('_id', None) folder = { 'name': name, 'description': description, 'parentCollection': parentType, 'baseParentId': parent['baseParentId'], 'baseParentType': parent['baseParentType'], 'parentId': ObjectId(parent['_id']), 'creatorId': creatorId, 'created': now, 'updated': now, 'size': 0, 'meta': {} } if parentType in ('folder', 'collection'): self.copyAccessPolicies(src=parent, dest=folder, save=False) if creator is not None: self.setUserAccess(folder, user=creator, level=AccessType.ADMIN, save=False) # Allow explicit public flag override if it's set. if public is not None and isinstance(public, bool): self.setPublic(folder, public, save=False) if allowRename: self.validate(folder, allowRename=True) # Now validate and save the folder. return self.save(folder) def updateFolder(self, folder): """ Updates a folder. :param folder: The folder document to update :type folder: dict :returns: The folder document that was edited. """ folder['updated'] = datetime.datetime.utcnow() # Validate and save the folder return self.save(folder) def filter(self, doc, user=None, additionalKeys=None): """ Overrides the parent ``filter`` method to add an empty meta field (if it doesn't exist) to the returned folder. """ filteredDoc = super(Folder, self).filter(doc, user, additionalKeys=additionalKeys) if 'meta' not in filteredDoc: filteredDoc['meta'] = {} return filteredDoc def parentsToRoot(self, folder, curPath=None, user=None, force=False, level=AccessType.READ): """ Get the path to traverse to a root of the hierarchy. :param folder: The folder whose root to find :type folder: dict :returns: an ordered list of dictionaries from root to the current folder """ curPath = curPath or [] curParentId = folder['parentId'] curParentType = folder['parentCollection'] if curParentType in ('user', 'collection'): curParentObject = ModelImporter.model(curParentType).load( curParentId, user=user, level=level, force=force) if force: parentFiltered = curParentObject else: parentFiltered = ModelImporter.model(curParentType).filter(curParentObject, user) return [{ 'type': curParentType, 'object': parentFiltered }] + curPath else: curParentObject = self.load(curParentId, user=user, level=level, force=force) curPath = [{ 'type': curParentType, 'object': curParentObject if force else self.filter(curParentObject, user) }] + curPath return self.parentsToRoot(curParentObject, curPath, user=user, force=force) def countItems(self, folder): """ Returns the number of items within the given folder. """ return self.childItems(folder, fields=()).count() def countFolders(self, folder, user=None, level=None): """ Returns the number of subfolders within the given folder. Access checking is optional; to circumvent access checks, pass ``level=None``. :param folder: The parent folder. :type folder: dict :param user: If performing access checks, the user to check against. :type user: dict or None :param level: The required access level, or None to return the raw subfolder count. """ fields = () if level is None else ('access', 'public') folders = self.findWithPermissions({ 'parentId': folder['_id'], 'parentCollection': 'folder' }, fields=fields, user=user, level=level) return folders.count() def subtreeCount(self, folder, includeItems=True, user=None, level=None): """ Return the size of the subtree rooted at the given folder. Includes the root folder in the count. :param folder: The root of the subtree. :type folder: dict :param includeItems: Whether to include items in the subtree count, or just folders. :type includeItems: bool :param user: If filtering by permission, the user to filter against. :param level: If filtering by permission, the required permission level. :type level: AccessLevel """ count = 1 if includeItems: count += self.countItems(folder) folders = self.findWithPermissions({ 'parentId': folder['_id'], 'parentCollection': 'folder' }, fields='access', user=user, level=level) count += sum(self.subtreeCount(subfolder, includeItems=includeItems, user=user, level=level) for subfolder in folders) return count def fileList(self, doc, user=None, path='', includeMetadata=False, subpath=True, mimeFilter=None, data=True): """ This function generates a list of 2-tuples whose first element is the relative path to the file from the folder's root and whose second element depends on the value of the `data` flag. If `data=True`, the second element will be a generator that will generate the bytes of the file data as stored in the assetstore. If `data=False`, the second element is the file document itself. :param doc: The folder to list. :param user: The user used for access. :param path: A path prefix to add to the results. :type path: str :param includeMetadata: if True and there is any metadata, include a result which is the JSON string of the metadata. This is given a name of metadata[-(number).json that is distinct from any file within the folder. :type includeMetadata: bool :param subpath: if True, add the folder's name to the path. :type subpath: bool :param mimeFilter: Optional list of MIME types to filter by. Set to None to include all files. :type mimeFilter: `list or tuple` :param data: If True return raw content of each file as stored in the assetstore, otherwise return file document. :type data: bool :returns: Iterable over files in this folder, where each element is a tuple of (path name of the file,
import mahjongpy class MahjongPlayer: """ プレイヤーを表すクラス。各プレイヤーの情報などを保持する Attributes ---------- hands : list プレイヤーの手牌。MahjongTileのリスト discards : list プレイヤーの河。MahjongTileのリスト melds : list プレイヤーが鳴いた牌のリストのリスト。 ポン、カン、チーをしたときに3枚または4枚のMahjongTileのリストが追加される。 oya : bool プレイヤーが親かどうか points : int プレイヤーの持ち点 wind : str プレイヤーの自風。東:'ton' 南:'nan' 西:'sha' 北:'pei' latest_tile : MahjongTile 一番最後に引いた牌(一番最新の牌) table : MahjongTable プレイヤーがゲームを行っている卓 turn : int 局が始まってから経過したターン数 riichi_turn : int リーチした時のターン数 is_tumo : bool ツモしたかどうか id_ron : bool ロンしたかどうか ankans : list 暗槓のリスト。MahjongTile4枚のリスト(暗槓)のリスト minkans :list 明槓のリスト。MahjongTile4枚のリスト(明槓)のリスト minkos :list 明刻のリスト。MahjongTile3枚のリスト(明刻)のリスト is_riichi : bool リーチしているかどうか is_doubleriichi : bool 和了った時にダブルリーチ(役)がつく状態かどうか is_rinsyankaihou : bool 和了った時に嶺上開花(役)がつく状態かどうか score_cache : int プレイヤーの点数のキャッシュ score_without_tsumibo_cache : int プレイヤーの点数(積み棒分を除く)のキャッシュ yakus_cache : list プレイヤーの手牌でできる役のリストのキャッシュ tilse_cache : list 手牌のキャッシュ """ TILE_TYPES = ['pinzu', 'manzu', 'souzu', 'ton', 'nan', 'sha', 'pei', 'haku', 'hatu', 'tyun'] KYOMU_TILE = mahjongpy.MahjongTile(None) def __init__(self, hands=[], discards=[], melds=[], oya=False, points=25000, wind='ton', latest_tile=KYOMU_TILE, table=None, turn=0, is_tumo=False, ankans=[], minkans=[], minkos=[]): if len(hands)+len(sum(melds,[])) not in [13, 14]: raise ValueError('amout of hands is not 13 or 14.') self.hands = hands[:] self.discards = discards[:] self.melds = melds[:] self.oya = oya self.points = points self.wind = wind self.latest_tile = latest_tile self.is_riichi = False self.turn = turn self.riichi_turn = 100 self.is_tumo = is_tumo self.is_ron = False self.ankans = ankans[:] self.minkans = minkans[:] self.minkos = minkos[:] self.is_doubleriichi = False self.is_rinsyankaihou = False self.table = table self.score_cache = 0 self.score_without_tsumibo_cache = 0 self.yakus_cache = [] self.tiles_cache = [] self.sort() def sort(self): """ プレイヤーの手牌を種類、番号順にソートする Notes ----- self.hands を 破壊的に ソートするので注意 """ self.hands = sorted(self.hands) def hands_display(self): """ プレイヤーの手牌すべてを実際の牌のような感じで表示 """ for i in self.hands: print(i.display) def hands_name_jp(self): """ プレイヤーの手牌すべての名前を表示 """ for i in self.hands: print(i.name_jp) def discards_display(self): """ プレイヤーの河すべてを実際の牌のような感じで表示 """ for i in self.discards: print(i.display) def discards_name_jp(self): """ プレイヤーの河すべての名前を表示 """ for i in self.discards: print(i.name_jp) def shanten(self): """ プレイヤーのシャンテン数を計算。一向聴で1、二向聴で2…… を返す Returns ------- count : int プレイヤーのシャンテン数 """ counts = [100] tiles = self.hands[:] mentus = [] self.make_shuntus(tiles, mentus) self.make_kotus(tiles, mentus) self.make_zyantou(tiles, mentus) tmp = tiles[:] count = 0 for i in self.TILE_TYPES[:3]: for j in range(1,8): if mahjongpy.MahjongTile(i,j) in tmp: if mahjongpy.MahjongTile(i,j+1) in tmp: tmp.pop(tmp.index(mahjongpy.MahjongTile(i,j))) tmp.pop(tmp.index(mahjongpy.MahjongTile(i,j+1))) count += 1 if mahjongpy.MahjongTile(i,j+2) in tmp: tmp.pop(tmp.index(mahjongpy.MahjongTile(i,j))) tmp.pop(tmp.index(mahjongpy.MahjongTile(i,j+2))) count += 1 for i in self.TILE_TYPES: for j in range(1,8): if tmp.count(mahjongpy.MahjongTile(i,j)) == 2: tmp.pop(tmp.index(mahjongpy.MahjongTile(i,j))) tmp.pop(tmp.index(mahjongpy.MahjongTile(i,j))) count += 1 if len(tmp)-count == 2: tmp.pop(0) count += 1 if len(tmp) == count: counts.append(count) tiles = self.hands[:] mentus = [] self.make_zyantou(tiles, mentus) self.make_shuntus(tiles, mentus) self.make_kotus(tiles, mentus) tmp = tiles[:] count = 0 for i in self.TILE_TYPES[:3]: for j in range(1,8): if mahjongpy.MahjongTile(i,j) in tmp: if mahjongpy.MahjongTile(i,j+1) in tmp: tmp.pop(tmp.index(mahjongpy.MahjongTile(i,j))) tmp.pop(tmp.index(mahjongpy.MahjongTile(i,j+1))) count += 1 if mahjongpy.MahjongTile(i,j+2) in tmp: tmp.pop(tmp.index(mahjongpy.MahjongTile(i,j))) tmp.pop(tmp.index(mahjongpy.MahjongTile(i,j+2))) count += 1 for i in self.TILE_TYPES: for j in range(1,8): if tmp.count(mahjongpy.MahjongTile(i,j)) == 2: tmp.pop(tmp.index(mahjongpy.MahjongTile(i,j))) tmp.pop(tmp.index(mahjongpy.MahjongTile(i,j))) count += 1 if len(tmp)-count == 2: tmp.pop(0) count += 1 if len(tmp) == count: counts.append(count) tmp = tiles[:] count = 0 for i in self.TILE_TYPES: for j in range(1,10): if tmp.count(mahjongpy.MahjongTile(i,j)) == 2: count += 1 counts.append(7-count) # 七対子用 tiles = self.hands[:] tmp = [] tmp.append(tiles.count(mahjongpy.MahjongTile('pinzu',1))) tmp.append(tiles.count(mahjongpy.MahjongTile('pinzu',9))) tmp.append(tiles.count(mahjongpy.MahjongTile('manzu',1))) tmp.append(tiles.count(mahjongpy.MahjongTile('manzu',9))) tmp.append(tiles.count(mahjongpy.MahjongTile('souzu',1))) tmp.append(tiles.count(mahjongpy.MahjongTile('souzu',9))) tmp.append(tiles.count(mahjongpy.MahjongTile('ton'))) tmp.append(tiles.count(mahjongpy.MahjongTile('nan'))) tmp.append(tiles.count(mahjongpy.MahjongTile('sha'))) tmp.append(tiles.count(mahjongpy.MahjongTile('pei'))) tmp.append(tiles.count(mahjongpy.MahjongTile('haku'))) tmp.append(tiles.count(mahjongpy.MahjongTile('hatu'))) tmp.append(tiles.count(mahjongpy.MahjongTile('tyun'))) if tmp.count(1) == 13: counts.append(1) elif tmp.count(2) > 1: counts.append(13-tmp.count(1)) else: counts.append(13-tmp.count(1)+1) return(min(counts)-1) def is_tenpai(self): """ Returns ------- is_tenpai : bool プレイヤーがテンパイかどうか """ return(self.shanten() == 0) def is_furiten(self): """ Returns ------- is_furiten : bool プレイヤーがフリテン状態かどうか """ is_furiten = False return(is_furiten) def is_kyusyukyuhai(self): """ Returns ------- is_kyusyukyuhai : bool 手牌が九種九牌かどうか """ count = 0 for i in self.hands: if i.number in [1, 9, None]: count += 1 return(count > 8) def is_hora(self): """ Returns ------- is_hora : bool プレイヤーの手牌が和了形かどうか """ is_hora = False tiles = self.hands[:] mentus = [] self.make_shuntus(tiles, mentus) self.make_kotus(tiles, mentus) is_hora = self.is_zyantou(tiles, mentus) tiles = self.hands[:] mentus = [] self.make_zyantou(tiles, mentus) self.make_shuntus(tiles, mentus) self.make_kotus(tiles, mentus) is_hora = is_hora or (len(tiles) == 0) return(is_hora or self.is_chitoitu() or self.is_kokushimusou()) def zyantou(self): """ プレイヤーの手牌の内、雀頭を返す Returns ------- tiles : list 雀頭(2枚のMahjongTileのリスト)。雀頭がない場合ダミータイル(self.KYOMU_TILE)1枚のみのリストが返る """ is_hora = False tiles = self.hands[:] mentus = [] self.make_shuntus(tiles, mentus) self.make_kotus(tiles, mentus) is_hora = self.is_zyantou(tiles, mentus) if is_hora: return(mentus[-1]) tiles = self.hands[:] mentus = [] self.make_zyantou(tiles, mentus) self.make_shuntus(tiles, mentus) self.make_kotus(tiles, mentus) is_hora = is_hora or (len(tiles) == 0) if is_hora: return(mentus[0]) return([self.KYOMU_TILE]) def make_shuntus(self, tiles, mentus): """ 順子を作る Parameters ---------- tiles : list 未処理のMahjongTileのリスト(手牌) mentus: list 処理済みのMahjongTileのリスト。このリストに順子が、MahjongTile3枚のリストとして追加される Notes ----- 引数のtiles、およびmentusを 破壊的に 変更するので注意 """ for _ in range(2): for i in range(1,8): for j in self.TILE_TYPES[:3]: if mahjongpy.MahjongTile(j,i) in tiles and mahjongpy.MahjongTile(j,i+1) in tiles and mahjongpy.MahjongTile(j,i+2) in tiles: tmp = [] tmp.append(tiles.pop(tiles.index(mahjongpy.MahjongTile(j,i)))) tmp.append(tiles.pop(tiles.index(mahjongpy.MahjongTile(j,i+1)))) tmp.append(tiles.pop(tiles.index(mahjongpy.MahjongTile(j,i+2)))) mentus.append(tmp) def make_kotus(self, tiles, mentus): """ 刻子を作る Parameters ---------- tiles : list 未処理のMahjongTileのリスト(手牌) mentus: list 処理済みのMahjongTileのリスト。このリストに刻子が、MahjongTile3枚のリストとして追加される Notes ----- 引数のtiles、およびmentusを 破壊的に 変更するので注意 """ for i in range(1,10): for j in self.TILE_TYPES: if tiles.count(mahjongpy.MahjongTile(j,i)) == 3: tmp = [] for _ in range(3): tmp.append(tiles.pop(tiles.index(mahjongpy.MahjongTile(j,i)))) mentus.append(tmp) def make_zyantou(self, tiles, mentus): """ 雀頭を作る Parameters ---------- tiles : list 未処理のMahjongTileのリスト(手牌) mentus: list 処理済みのMahjongTileのリスト。このリストに雀頭が、MahjongTile2枚のリストとして追加される Notes ----- 引数のtiles、およびmentusを 破壊的に 変更するので注意 """ for i in range(1,10): for j in self.TILE_TYPES: if tiles.count(mahjongpy.MahjongTile(j,i)) == 2: tmp = [] for _ in range(2): tmp.append(tiles.pop(tiles.index(mahjongpy.MahjongTile(j,i)))) mentus.append(tmp) return(None) def is_zyantou(self, tiles, mentus): """ 残りの牌が雀頭かどうかを判定する Parameters ---------- tiles : list 未処理のMahjongTileのリスト mentus: list 処理済みのMahjongTileのリスト。雀頭判定されたとき、MahjongTile2枚がリストとして追加される Notes ----- 引数のtiles、およびmentusを 破壊的に 変更するので注意 """ if len(tiles) == 2 and tiles[0] == tiles[1]: mentus.append([tiles[0], tiles[1]]) return(True) else: return(False) def is_chitoitu(self): """ Returns ------- is_chitoitu : bool プレイヤーの手牌が七対子かどうか """ if not self.is_menzen(): return(False) mentus = [] tiles = self.hands[:] for i in range(1,10): for j in self.TILE_TYPES: if tiles.count(mahjongpy.MahjongTile(j,i)) == 2: tmp = [] for _ in range(2): tmp.append(tiles.pop(tiles.index(mahjongpy.MahjongTile(j,i)))) mentus.append(tmp) return(len(tiles) == 0) def is_kokushimusou(self): """ Returns ------- is_kokushimusou : bool プレイヤーの手牌が国士無双かどうか """ if not self.is_menzen(): return(False) tmp = [] tiles = self.hands[:] tmp.append(tiles.count(mahjongpy.MahjongTile('pinzu',1))) tmp.append(tiles.count(mahjongpy.MahjongTile('pinzu',9))) tmp.append(tiles.count(mahjongpy.MahjongTile('manzu',1))) tmp.append(tiles.count(mahjongpy.MahjongTile('manzu',9))) tmp.append(tiles.count(mahjongpy.MahjongTile('souzu',1))) tmp.append(tiles.count(mahjongpy.MahjongTile('souzu',9))) tmp.append(tiles.count(mahjongpy.MahjongTile('ton'))) tmp.append(tiles.count(mahjongpy.MahjongTile('nan'))) tmp.append(tiles.count(mahjongpy.MahjongTile('sha'))) tmp.append(tiles.count(mahjongpy.MahjongTile('pei'))) tmp.append(tiles.count(mahjongpy.MahjongTile('haku'))) tmp.append(tiles.count(mahjongpy.MahjongTile('hatu'))) tmp.append(tiles.count(mahjongpy.MahjongTile('tyun'))) return(tmp.count(1) == 12 and tmp.count(2) == 1) def is_chanta(self): """ Returns ------- is_kokushimusou : bool プレイヤーの手牌がチャンタかどうか """ is_hora = False tiles = self.hands[:] + sum(self.melds, []) mentus = [] self.make_shuntus(tiles, mentus) self.make_kotus(tiles, mentus) is_hora = self.is_zyantou(tiles, mentus) count = 0 for i in mentus: for j in i: if j.number in [1, 9, None]: count += 1 break if is_hora and count == 5: return(True) count = 0 tiles = self.hands[:] mentus = [] self.make_zyantou(tiles, mentus) self.make_shuntus(tiles, mentus) self.make_kotus(tiles, mentus) is_hora = is_hora or (len(tiles) == 0) for i in mentus: for j in i: if j.number in [1, 9, None]: count += 1 break if is_hora and count == 5: return(True) return(False) def is_zyuntyan(self): """ Returns ------- is_kokushimusou : bool プレイヤーの手牌がジュンチャンかどうか """ is_hora = False tiles = self.hands[:] + sum(self.melds, []) mentus = [] self.make_shuntus(tiles, mentus) self.make_kotus(tiles, mentus) is_hora = self.is_zyantou(tiles, mentus) count = 0 for i in mentus: for j in i: if j.number in [1, 9]: count += 1 break if is_hora and count == 5: return(True) count = 0 tiles = self.hands[:] mentus = [] self.make_zyantou(tiles, mentus) self.make_shuntus(tiles, mentus) self.make_kotus(tiles, mentus) is_hora = is_hora or (len(tiles) == 0) for i in mentus: for j in i: if j.number in [1, 9]: count += 1 break if is_hora and count == 5: return(True) return(False) def is_ipeikou(self, tiles, mentus): """ Returns ------- is_kokushimusou : bool プレイヤーの手牌が一盃口かどうか """ if not self.is_menzen(): return(False) count = [] for _ in range(2): for i in range(1,8): for j in self.TILE_TYPES[:3]: if mahjongpy.MahjongTile(j,i) in tiles and mahjongpy.MahjongTile(j,i+1) in tiles and mahjongpy.MahjongTile(j,i+2) in tiles: tmp = [] tmp.append(tiles.pop(tiles.index(mahjongpy.MahjongTile(j,i)))) tmp.append(tiles.pop(tiles.index(mahjongpy.MahjongTile(j,i+1)))) tmp.append(tiles.pop(tiles.index(mahjongpy.MahjongTile(j,i+2)))) mentus.append(tmp) count.append(len(tiles)) return(count == [5,2]) def is_ryanpeikou(self, tiles, mentus): """ Returns ------- is_kokushimusou : bool プレイヤーの手牌が二盃口かどうか """ if not self.is_menzen(): return(False) count = [] for _ in range(2): for i in range(1,8): for j in self.TILE_TYPES[:3]: if mahjongpy.MahjongTile(j,i) in tiles and mahjongpy.MahjongTile(j,i+1) in tiles and mahjongpy.MahjongTile(j,i+2) in tiles: tmp = [] tmp.append(tiles.pop(tiles.index(mahjongpy.MahjongTile(j,i)))) tmp.append(tiles.pop(tiles.index(mahjongpy.MahjongTile(j,i+1)))) tmp.append(tiles.pop(tiles.index(mahjongpy.MahjongTile(j,i+2)))) mentus.append(tmp) count.append(len(tiles)) return(count == [8,2]) def displayed_doras(self): """ 手牌の内ドラ表示牌の次の牌の数 Returns ------- count : int 手牌のドラ牌の数 """ count = 0 tiles = self.hands[:] + sum(self.melds, []) doras = None if self.table is None else self.table.dora_tiles for i in tiles: for j in doras: if i == j: count += 1 return(count) def akadoras(self): """ 手牌の赤ドラの数 Returns ------- count : int 手牌の赤ドラの数 """ count = 0 tiles = self.hands[:] + sum(self.melds, []) for i in tiles:
<reponame>mjc87/SHTOOLS """ Functions for reading and writing spherical harmonic coefficients from text files that are formatted as [degree, order, value]. """ import os as _os import io as _io import gzip as _gzip import zipfile as _zipfile import numpy as _np import requests as _requests import shutil as _shutil def read_dov(filename, lmax=None, error=False, header=False, header2=False, skip=0, encoding=None): """ Read spherical harmonic coefficients from a text file formatted as [degree, order, value]. Usage ----- coeffs, [errors], lmaxout, [header], [header2] = read_dov( filename, [error=True, header=True, header2=True, lmax, skip, encoding]) Returns ------- coeffs : ndarray, size(2, lmaxout+1, lmaxout+1) The spherical harmonic coefficients. errors : ndarray, size(2, lmaxout+1, lmaxout+1) The errors associated with the spherical harmonic coefficients. lmaxout : int The maximum spherical harmonic degree read from the file. header : list of type str A list of values in the header line found before the start of the spherical harmonic coefficients. header2 : list of type str A list of values in the second header line found before the start of the spherical harmonic coefficients. Parameters ---------- filename : str File name or URL that contains the text-formatted spherical harmonic coefficients. filename will be treated as a URL if it starts with 'http://', 'https://', or 'ftp://'. If filename ends with '.gz' or '.zip', the file will be uncompressed before parsing. lmax : int, optional, default = None The maximum spherical harmonic degree to read from the file. The default is to read the entire file. error : bool, optional, default = False If True, return the errors associated with the spherical harmonic coefficients as a separate array. header : bool, optional, default = False If True, return a list of values in the header line found before the start of the spherical harmonic coefficients. header2 : bool, optional, default = False If True, return a list of values in the second header line found before the start of the spherical harmonic coefficients. skip : int, optional, default = 0 The number of lines to skip before parsing the file. encoding : str, optional, default = None Encoding of the input file. The default is to use the system default. Notes ----- This function will read spherical harmonic coefficients from a 'dov'- formatted text file. The errors associated with the spherical harmonic coefficients, as well as the values in one or two header lines, can be read optionally by setting the parameters error, header, and header2 to True. The optional parameter skip specifies how many lines should be skipped before attempting to parse the file, and the optional parameter lmax specifies the maximum degree to read from the file. Both real and complex spherical harmonic coefficients are supported. The spherical harmonic coefficients in the file should be formatted as l, m, coeffs[0, l, m] l, -m, coeffs[1, l, m] where l and m are the spherical harmonic degree and order, respectively. If the errors are to be read, the line should be formatted as l, m, coeffs[0, l, m], errors[0, l, m] l, -m, coeffs[0, l, m], errors[1, l, m] For each value of increasing l, all the angular orders are listed in pairs with inceasing abs(order), from 0 to l. If one or two header lines are to be read, they should be located directly after the first lines to be skipped, before the start of the spherical harmonic coefficents. The header values are returned as a list, where each value is formatted as a string. Comment lines will be ignored, where comments start with '#' or the line is all whitespace. If filename starts with 'http://', 'https://', or 'ftp://', the file will be treated as a URL. In this case, the file will be downloaded in its entirety before it is parsed. If the filename ends with '.gz' or '.zip', the file will be automatically uncompressed before parsing. For zip files, archives with only a single file are supported. Note that reading '.gz' and '.zip' files will be extremely slow if lmax is not specified. """ if _isurl(filename): _response = _requests.get(filename) if filename[-4:] == '.zip': zf = _zipfile.ZipFile(_io.BytesIO(_response.content)) if len(zf.namelist()) > 1: raise Exception('read_dov can only process zip archives ' 'that contain a single file. Archive ' 'contents:\n{}'.format(zf.namelist())) elif filename[-4:] == '.zip': zf = _zipfile.ZipFile(filename, 'r') if len(zf.namelist()) > 1: raise Exception('read_dov can only process zip archives that ' 'contain a single file. Archive contents: \n' '{}'.format(zf.namelist())) # If lmax is None, determine lmax by reading last line of the file that # is not a comment. (Note that this is very slow for zipped and gzipped # files. Consider using indexed_gzip when SEEK_END is supported.) if lmax is None: if _isurl(filename): f = _io.BytesIO(_response.content) if filename[-4:] == '.zip': f = zf.open(zf.namelist()[0]) elif filename[-3:] == '.gz': f = _gzip.open(filename, mode='rb') elif filename[-4:] == '.zip': f = zf.open(zf.namelist()[0]) else: f = open(filename, 'rb') # determine lmax by reading the last non-comment line of the file with f: line = '' if f.seek(0, _os.SEEK_END) == 0: raise RuntimeError('File is empty.') else: f.seek(-1, _os.SEEK_CUR) # read backwards to end of preceding line and then read the line while _iscomment(line): while f.read(1) != b'\n': try: f.seek(-2, _os.SEEK_CUR) except: f.seek(-1, _os.SEEK_CUR) # beginning of file break if f.tell() <= 1: line = f.readline().decode() line = line.replace(',', ' ') if _iscomment(line): raise RuntimeError('Encountered beginning of file ' 'while attempting to determine ' 'lmax.') break else: line = f.readline().decode() line = line.replace(',', ' ') try: f.seek(-len(line)-2, _os.SEEK_CUR) except: raise RuntimeError('Encountered beginning of file ' 'while attempting to determine ' 'lmax.') lmaxout = int(line.split()[0]) else: lmaxout = lmax # open file, skip lines, read header, determine lstart, and then read # coefficients one line at a time if _isurl(filename): if encoding is not None: _response.encoding = encoding f = _io.StringIO(_response.text) if filename[-4:] == '.zip': f = _io.TextIOWrapper(zf.open(zf.namelist()[0]), encoding=encoding) elif filename[-3:] == '.gz': f = _gzip.open(filename, mode='rt', encoding=encoding) elif filename[-4:] == '.zip': f = _io.TextIOWrapper(zf.open(zf.namelist()[0]), encoding=encoding) else: f = open(filename, 'r', encoding=encoding) with f: if skip != 0: for i in range(skip): line = f.readline() if line == '': raise RuntimeError('End of file encountered when ' 'skipping lines.') # read headers if header is True: line = f.readline() if line == '': raise RuntimeError('End of file encountered when ' 'reading header line.') while _iscomment(line): line = f.readline() if line == '': raise RuntimeError('End of file encountered when ' 'reading header line.') line = line.replace(',', ' ') header_list = line.split() if header2 is True: line = f.readline() if line == '': raise RuntimeError('End of file encountered when ' 'reading second header line.') while _iscomment(line): line = f.readline() if line == '': raise RuntimeError('End of file encountered when ' 'reading second header line.') line = line.replace(',', ' ') header2_list = line.split() # determine the starting degree start_position = f.tell() line = f.readline() if line == '': raise RuntimeError('End of file encountered when determining ' 'value of lstart.') while _iscomment(line): line = f.readline() if line == '': raise RuntimeError('End of file encountered when determining ' 'value of lstart.') line = line.replace(',', ' ') lstart = int(line.split()[0]) # determine if the coefficients are real or complex try: num = float(line.split()[2]) # noqa F841 coeffs = _np.zeros((2, lmaxout+1, lmaxout+1)) kind = 'real' if error is True: errors = _np.zeros((2, lmaxout+1, lmaxout+1)) except ValueError: try: num = _np.complex128(line.split()[2]) # noqa F841 coeffs = _np.zeros((2, lmaxout+1, lmaxout+1), dtype=_np.complex128) kind = 'complex' if error is True: errors = _np.zeros((2, lmaxout+1, lmaxout+1), dtype=_np.complex128) except ValueError: raise ValueError('Coefficients can not be converted to ' 'either float or complex. Coefficient ' 'is {:s}\n'.format(line.split()[2]) + 'Unformatted string is {:s}'.format(line)) # rewind one line and read coefficients one line at a time f.seek(start_position) for degree in range(lstart, lmaxout+1): for order in range(degree+1): line = f.readline() if line == '': raise RuntimeError('End of file encountered at ' 'degree and order {:d}, {:d}.' .format(degree, order)) while _iscomment(line): line
inventory_currentmachinesnapshot as cms on (msaa.machinesnapshot_id = cms.machine_snapshot_id)" " join inventory_source as s on (cms.source_id = s.id)" f" {wheres_str}" " group by aa.id, aa.display_name, aa.version_name, aa.version_code, s.name, s.id" ") select display_name, name_ms_count ms_count," "jsonb_agg(" " jsonb_build_object(" " 'pk', id," " 'version_name', version_name," " 'version_code', version_code," " 'source_name', source_name," " 'source_pk', source_id," " 'ms_count', version_ms_count" ")) versions," "count(*) over () as full_count " "from aaa " "group by display_name, ms_count " f"order by {order_str}" ) return query, args class DebPackageSearchForm(BaseAppSearchForm): name = forms.CharField(label="Package name", max_length=64, widget=forms.TextInput(attrs={"autofocus": "true", "placeholder": "Package name"}), required=False) order_mapping = {"n": "name", "mc": "ms_count"} default_order = ("name", "ASC") title = "Debian packages" app_headers = ( ("name", "name", True, "Package"), ) version_headers = ( ("version", False, "Version"), ("source_name", True, "Source"), ) def get_ms_query_filters(self, result, version=None): filters = super().get_ms_query_filters(result, version) filter_kwargs = {"name": result["name"]} if version: filter_kwargs["value"] = version["pk"] filters.append((DebPackageFilter, filter_kwargs)) return filters def get_query_and_args(self): args = [] # filtering wheres = [] name = self.cleaned_data.get("name") if name: args.append(name) wheres.append("dp.name ~* %s") source = self.get_source() if source: args.append(source.id) wheres.append("s.id = %s") last_seen = self.get_last_seen() if last_seen: args.append(last_seen) wheres.append("cms.last_seen >= %s") if wheres: wheres_str = "where {}".format(" and ".join(wheres)) else: wheres_str = "" # ordering order_attr, order_dir = self._get_current_order() order_str = f"{order_attr} {order_dir}" if order_attr == "ms_count": order_str = f"{order_str}, name ASC" query = ( "with adp as (" " select dp.id, dp.name, dp.version, s.name source_name, s.id source_id," " sum(count(*)) over (partition by dp.name) name_ms_count," " count(*) version_ms_count" " from inventory_debpackage as dp" " join inventory_machinesnapshot_deb_packages as msdp on (dp.id = msdp.debpackage_id)" " join inventory_currentmachinesnapshot as cms on (msdp.machinesnapshot_id = cms.machine_snapshot_id)" " join inventory_source as s on (cms.source_id = s.id)" f" {wheres_str}" " group by dp.id, dp.name, dp.version, s.name, s.id" ") select name, name_ms_count ms_count," "jsonb_agg(" " jsonb_build_object(" " 'pk', id," " 'version', version," " 'source_name', source_name," " 'source_pk', source_id," " 'ms_count', version_ms_count" ")) versions," "count(*) over () as full_count " "from adp " "group by name, ms_count " f"order by {order_str}" ) return query, args class IOSAppSearchForm(BaseAppSearchForm): name = forms.CharField(label="Name", max_length=64, widget=forms.TextInput(attrs={"autofocus": "true", "placeholder": "Name"}), required=False) order_mapping = {"n": "name", "mc": "ms_count"} default_order = ("name", "ASC") title = "iOS apps" app_headers = ( ("name", "name", True, "Name"), ("identifier", None, False, "Identifier"), ) version_headers = ( ("version", False, "Version"), ("short_version", False, "Short version"), ("source_name", True, "Source"), ) version_sort_keys = ("version", "short_version") def get_ms_query_filters(self, result, version=None): filters = super().get_ms_query_filters(result, version) filter_kwargs = {"name": result["name"]} if version: filter_kwargs["value"] = version["pk"] filters.append((IOSAppFilter, filter_kwargs)) return filters def get_query_and_args(self): args = [] # filtering wheres = [] name = self.cleaned_data.get("name") if name: args.append(name) wheres.append("ia.name ~* %s") source = self.get_source() if source: args.append(source.id) wheres.append("s.id = %s") last_seen = self.get_last_seen() if last_seen: args.append(last_seen) wheres.append("cms.last_seen >= %s") if wheres: wheres_str = "where {}".format(" and ".join(wheres)) else: wheres_str = "" # ordering order_attr, order_dir = self._get_current_order() order_str = f"{order_attr} {order_dir}" if order_attr == "ms_count": order_str = f"{order_str}, name ASC" query = ( "with aia as (" " select ia.id, ia.name, ia.identifier, ia.version, ia.short_version, s.name source_name, s.id source_id," " sum(count(*)) over (partition by ia.name, ia.identifier) name_ms_count," " count(*) version_ms_count" " from inventory_iosapp as ia" " join inventory_machinesnapshot_ios_apps as msia on (ia.id = msia.iosapp_id)" " join inventory_currentmachinesnapshot as cms on (msia.machinesnapshot_id = cms.machine_snapshot_id)" " join inventory_source as s on (cms.source_id = s.id)" f" {wheres_str}" " group by ia.id, ia.name, ia.identifier, ia.version, ia.short_version, s.name, s.id" ") select name, identifier, name_ms_count ms_count," "jsonb_agg(" " jsonb_build_object(" " 'pk', id," " 'version', version," " 'short_version', short_version," " 'source_name', source_name," " 'source_pk', source_id," " 'ms_count', version_ms_count" ")) versions," "count(*) over () as full_count " "from aia " "group by name, identifier, ms_count " f"order by {order_str}" ) return query, args class MacOSAppSearchForm(BaseAppSearchForm): bundle_name = forms.CharField(label='Bundle name', max_length=64, widget=forms.TextInput(attrs={"autofocus": "true", "placeholder": "Bundle name"}), required=False) order_mapping = {"bn": "bundle_name", "mc": "ms_count"} default_order = ("bundle_name", "ASC") title = "macOS apps" app_headers = ( ("bundle_name", "bundle_name", True, "Bundle"), ("bundle_id", None, False, "Bundle ID"), ) version_headers = ( ("bundle_version", False, "Bundle version"), ("bundle_version_str", False, "Bundle version str"), ("source_name", True, "Source"), ) version_sort_keys = ("bundle_version", "bundle_version_str") def get_ms_query_filters(self, result, version=None): filters = super().get_ms_query_filters(result, version) bundle_name = result["bundle_name"] bundle_id = result["bundle_id"] if bundle_name or bundle_id: if bundle_name: filter_kwargs = {"bundle_name": bundle_name} else: filter_kwargs = {"bundle_id": bundle_id} if version: filter_kwargs["value"] = version["pk"] filters.append((BundleFilter, filter_kwargs)) return filters def get_query_and_args(self): args = [] # filtering wheres = [] bundle_name = self.cleaned_data.get("bundle_name") if bundle_name: args.append(bundle_name) wheres.append("a.bundle_name ~* %s") source = self.get_source() if source: args.append(source.id) wheres.append("s.id = %s") last_seen = self.get_last_seen() if last_seen: args.append(last_seen) wheres.append("cms.last_seen >= %s") if wheres: wheres_str = "where {}".format(" and ".join(wheres)) else: wheres_str = "" # ordering order_attr, order_dir = self._get_current_order() order_str = f"{order_attr} {order_dir}" if order_attr == "ms_count": order_str = f"{order_str}, bundle_name ASC" query = ( "with ama as (" " select a.id, a.bundle_id, a.bundle_name, a.bundle_version, a.bundle_version_str," " s.name source_name, s.id source_id," " sum(count(*)) over (partition by a.bundle_id, a.bundle_name) bundle_ms_count," " count(*) version_ms_count" " from inventory_osxapp as a" " join inventory_osxappinstance as ai on (ai.app_id = a.id)" " join inventory_machinesnapshot_osx_app_instances as msoai on(msoai.osxappinstance_id = ai.id)" " join inventory_currentmachinesnapshot as cms on (msoai.machinesnapshot_id = cms.machine_snapshot_id)" " join inventory_source as s on (cms.source_id = s.id)" f" {wheres_str}" " group by a.id, a.bundle_id, a.bundle_name, a.bundle_version, a.bundle_version_str, s.name, s.id" ") select bundle_id, bundle_name, bundle_ms_count ms_count," "jsonb_agg(" "jsonb_build_object(" " 'pk', id," " 'bundle_version', bundle_version," " 'bundle_version_str', bundle_version_str," " 'source_name', source_name," " 'source_pk', source_id," " 'ms_count', version_ms_count" ")) versions," "count(*) over () as full_count " "from ama " "group by bundle_id, bundle_name, ms_count " f"order by {order_str}" ) return query, args class ProgramsSearchForm(BaseAppSearchForm): name = forms.CharField(label='Name', max_length=64, widget=forms.TextInput(attrs={"autofocus": "true", "placeholder": "Name"}), required=False) order_mapping = {"n": "name", "mc": "ms_count"} default_order = ("name", "ASC") title = "Programs" app_headers = ( ("name", "name", True, "Name"), ("identifying_number", None, False, "Identifying number"), ) version_headers = ( ("version", False, "Version"), ("source_name", True, "Source"), ) def get_ms_query_filters(self, result, version=None): filters = super().get_ms_query_filters(result, version) filter_kwargs = {"name": result["name"]} if version: filter_kwargs["value"] = version["pk"] filters.append((ProgramFilter, filter_kwargs)) return filters def get_query_and_args(self): args = [] # filtering wheres = [] name = self.cleaned_data.get("name") if name: args.append(name) wheres.append("p.name ~* %s") source = self.get_source() if source: args.append(source.id) wheres.append("s.id = %s") last_seen = self.get_last_seen() if last_seen: args.append(last_seen) wheres.append("cms.last_seen >= %s") if wheres: wheres_str = "where {}".format(" and ".join(wheres)) else: wheres_str = "" # ordering order_attr, order_dir = self._get_current_order() order_str = f"{order_attr} {order_dir}" if order_attr == "ms_count": order_str = f"{order_str}, name ASC" query = ( "with ap as (" " select p.id, p.name, p.identifying_number, p.version," " s.name source_name, s.id source_id," " sum(count(*)) over (partition by p.name, p.identifying_number) program_ms_count," " count(*) version_ms_count" " from inventory_program as p" " join inventory_programinstance as pi on (pi.program_id = p.id)" " join inventory_machinesnapshot_program_instances as mspi on(mspi.programinstance_id = pi.id)" " join inventory_currentmachinesnapshot as cms on (mspi.machinesnapshot_id = cms.machine_snapshot_id)" " join inventory_source as s on (cms.source_id = s.id)" f" {wheres_str}" " group by p.id, p.name, p.identifying_number, p.version, s.name, s.id" ") select name, identifying_number, program_ms_count ms_count," "jsonb_agg(" "jsonb_build_object(" " 'pk', id," " 'version', version," " 'source_name', source_name," " 'source_pk', source_id," " 'ms_count', version_ms_count" ")) versions," "count(*) over () as full_count " "from ap " "group by name, identifying_number, ms_count " f"order by {order_str}" ) return query, args class EnrollmentSecretForm(forms.ModelForm): class Meta: model = EnrollmentSecret fields = ("meta_business_unit", "tags", "serial_numbers", "udids", "quota") def __init__(self, *args, **kwargs): self.no_restrictions = kwargs.pop("no_restrictions", False) self.no_serial_numbers = kwargs.pop("no_serial_numbers", False) self.no_udids = kwargs.pop("no_udids", False) self.meta_business_unit = kwargs.pop("meta_business_unit", None) super().__init__(*args, **kwargs) mbu_field = self.fields["meta_business_unit"] mbu_field.queryset = MetaBusinessUnit.objects.available_for_api_enrollment() if self.meta_business_unit: mbu_field.queryset = mbu_field.queryset.filter(pk=self.meta_business_unit.pk) mbu_field.initial = self.meta_business_unit.pk mbu_field.widget = forms.HiddenInput() self.fields['tags'].queryset = Tag.objects.available_for_meta_business_unit(self.meta_business_unit) if self.no_restrictions: for field_name in ("serial_numbers", "udids", "quota"): self.fields[field_name].widget = forms.HiddenInput() else: if self.no_serial_numbers: self.fields["serial_numbers"].widget = forms.HiddenInput() if self.no_udids: self.fields["udids"].widget = forms.HiddenInput() def clean(self): super().clean() meta_business_unit = self.cleaned_data["meta_business_unit"] or self.meta_business_unit if meta_business_unit: tag_set = set(self.cleaned_data['tags']) wrong_tag_set = tag_set - set(Tag.objects.available_for_meta_business_unit(meta_business_unit)) if wrong_tag_set: raise forms.ValidationError( "Tag{} {} not available for this business unit".format( "" if len(wrong_tag_set) == 1 else "s", ", ".join(str(t) for t in wrong_tag_set) ) ) return self.cleaned_data def save(self, *args, **kwargs): commit = kwargs.pop("commit",
:param aging: enable aging or not :type re_c: boolean :param re_c: recount centers of the circles or not """ maps = [] for i in clust: mapy, _, _, _ = cluster(data,i,level,levels=levels, border = border, aging=False, re_c=False) maps.append(mapy) return maps def update_mg(pay, time, last_t, m, v, p, value,norm=l1_norm, tok=False, aging=True, re_c=True): """ Update of maps from new transaction :type pay: numeric array :param pay: [latitude, lontitude] of the new transaction :type time: string :param time: date and time of th transaction :type last_t: string :param last_t: date and time of the latest transaction :type m: string list :param m: list with centers of circles :type v: numeric list :param v: list with values, corresponding to already existing circles :type p: numeric list :param p: list with probabilities corresponding to the existing circles :type value: numeric :param value: value, corresponding to the transaction :type norm: function :param norm: distance function :type tok: boolean :param tok: first iteration flag :type aging: boolean :param aging: enable aging or not :type re_c: boolean :param re_c: recount centers of the circles or not """ massive, values_massive, probs_massive = list(m), list(v), list(p) i=pay[0] j=pay[1] f=False if(tok): for o in range(len(massive)): massive[o][0]=' '.join([str(i),str(j)]) values_massive[o][0]=10.0 probs_massive[o][0]=1.0 last_t=time else: if(aging): alpha = sigmoid_dt_(last_t,time) else: alpha=1 last_t=time for o in range(len(massive)): idx = [] la = i lo = j val = value*(0.1**(o)) if(val==0): val=0.1 gigy=0 is_in=False for samp in massive[o]: if(check_incl(samp, la, lo, val, norm=norm)): is_in=True if(re_c): massive[o][gigy]=re_count(s = samp,x = la, y = lo,mas = massive,val= val,l1=o,l2=o+1, norm=norm) idx.append(gigy) gigy+=1 if(not is_in): f=True for k in range(o,len(massive)): massive[k] = np.append(massive[k],' '.join([str(i),str(j)])) values_massive[k]*=alpha values_massive[k] = np.append(values_massive[k], 10.0) probs_massive[k] = np.append(probs_massive[k], 0.0) else: values_massive[o]*alpha for z in idx: pass values_massive[o][z]+=10.0 if(f): probs_massive = update_pg(values_massive, probs_massive) break return last_t, np.array(massive), np.array(values_massive), np.array(probs_massive) def update_pg(mas_v,probs_massive): """ Probabilities update after new transaction :type mas_v: numeric list :param mas_v: list with values of circles :type probs_massive: numeric list :param probs_massive: list with probabilities to update afer new transaction """ for i in range(len(mas_v)): for j in range(len(mas_v[i])): probs_massive[i][j]=(mas_v[i][j]*1.0/sum(mas_v[i])) return probs_massive def global_map(usr1, levels=2, border=100, re_c=True, aging=True, sq=True): """ Builds local maps< if no activity encountered dring the period it will be replaced by global map :type usr1: pandas DataFrame :param usr1: dataframe with data of the specified client :type levels: int :param levels: number of levels on the local map :type aging: boolean :param aging: enable aging or not :type sq: boolean :param: use sqrt during calculation :type re_c: boolean :param re_c: recount centers of the circles or not """ gm,gl,gp = None, None, None glob = False gmassive = list(np.ndarray(shape=(35,levels,1), dtype=object)) gvalues = list(np.ndarray(shape=(35,levels,1), dtype=float)) gprobs = list(np.ndarray(shape=(35,levels,1), dtype=float)) VALUE = 10.0 NORM = l2_norm opp = 0 for day in range(1,8): ss = usr1.loc[usr1['Day_week']==day] l = ss.shape[0] for part_day in range(5): last_t=0 tmp = (usr1.loc[(usr1['Part_day']==part_day) & (usr1['Day_week']==day)]).iloc[:,:-2] fl =True if(len(tmp)!=0): for i in tmp.index: dt = ' '.join(tmp.loc[i,['Time','Date']].values) p = tmp.loc[i,['lat','lon']].values if(fl): tok=True fl=False else: tok=False last_t, gmassive[opp], gvalues[opp], gprobs[opp] = update_mg(p, dt, last_t, gmassive[opp], gvalues[opp], gprobs[opp], border, norm=l2_norm, tok=tok, re_c=re_c, aging=aging) else: if(not glob): glob=True gm,gv,gp = cluster3(usr1,levels,border,re_c=re_c, aging=aging, sq=sq) gmassive[opp], gvalues[opp], gprobs[opp] = gm, gv, gp opp+=1 return gmassive, gvalues, gprobs def cluster(data, uid, level, levels = 4, border = 100, aging=True, local=True, re_c=True): """ Builds global mapfor the client with specified uid :type data: pandas dataFrame :param data: dataframe with all data :type uid: string :param uid: index of the client :type level: int :param level: number of level on which to visualize map :type levels: int :param levels: number of levels on the global map :type border: numeric :param border: radius of the largest circle :type aging: boolean :param aging: enable aging or not :type local: boolean :param local: to localize time or not :type re_c: boolean :param re_c: recount centers of the circles or not """ usr1 = data.loc[data['user_id']==uid] usr1 = usr1.groupby(['Date', 'Time']).apply(pd.DataFrame.reset_index) usr1 = usr1.iloc[:,[1,2,3,4,5]].reset_index(drop=True) if(local): dataFrame_localization(usr1) last_t=0 massive = np.ndarray(shape=(levels,1), dtype=object) values = np.ndarray(shape=(levels,1), dtype=float) probs = np.ndarray(shape=(levels,1), dtype=float) VALUE = 10.0 BORDER_VALUE = border NORM = l2_norm for i in range(usr1.shape[0]): dt = ' '.join(usr1.loc[i,['Time','Date']].values) p = usr1.loc[i,['lat','lon']].values if(i==0): tok=True else: tok=False last_t, massive, values, probs = update_mg(p, dt, last_t, massive, values, probs, BORDER_VALUE, norm=l2_norm, tok=tok, aging=aging, re_c = re_c) lat = usr1['lat'] lon = usr1['lon'] VALUE = 10.0 BORDER_VALUE*= 1000 map3 = folium.Map(location=[lat.values[0],lon.values[0]], zoom_start = 12) level=level if level>(levels-1) or level<0: level=(levels-1) t=level-levels val = BORDER_VALUE*(0.1**(level)) s=1 for i in zip(lat,lon): folium.Marker(location=i, radius = 10, popup=usr1.loc[s-1,'Time']+' '+usr1.loc[s-1,'Date'], icon=folium.Icon(color = 'green')).add_to(map3) s+=1 idx = 0 for i in massive[level]: ss = i.split(' ') la = float(ss[0]) lo = float(ss[1]) folium.vector_layers.Circle([la,lo], val, popup=None, color=color_change(probs[t][idx]), opacity=probs[t][idx], fill_color=color_change(probs[t][idx]), fill_opacity=probs[t][idx]).add_to(map3) idx+=1 map3.save("map3.html") return map3, massive, values, probs def cluster2(usr1, border = 10, level=-1): """ Builds global mapfor the client with specified client on the specified layer :type usr1: pandas dataFrame :param usr1: dataframe slice with client's data :type level: int :param level: number of level on which to build map :type border: numeric :param border: radius of the circle """ massive = np.ndarray(shape=(1,1), dtype=object) values = np.ndarray(shape=(1,1), dtype=float) probs = np.ndarray(shape=(1,1), dtype=float) last_t=0.0 VALUE = 10.0 BORDER_VALUE = border*10 NORM = l2_norm for i in range(usr1.shape[0]): dt = ' '.join(usr1.loc[i,['Time','Date']].values) p = usr1.loc[i,['lat','lon']].values if(i==0): tok=True else: tok=False last_t, massive, values, probs = update_mg(p, dt, last_t, massive, values, probs, BORDER_VALUE, norm=l2_norm, tok=tok) return massive[level], values[level], probs[level] def cluster3(usr1, levels, border, re_c=True, aging=True, sq=True): """ Builds global map for the client with specified client :type usr1: pandas dataFrame :param usr1: dataframe slice with client's data :type levels: int :param levels: number of levels on the map :type border: numeric :param border: radius of the largest circle :type aging: boolean :param aging: enable aging or not :type aging: boolean :param aging: to enable aging or not :type re_c: boolean :param re_c: recount centers of the circles or not """ last_t=0 massive = np.ndarray(shape=(levels,1), dtype=object) values = np.ndarray(shape=(levels,1), dtype=float) probs = np.ndarray(shape=(levels,1), dtype=float) VALUE = 10.0 BORDER_VALUE = border NORM = l2_norm for i in range(usr1.shape[0]): dt = ' '.join(usr1.loc[i,['Time','Date']].values) p = usr1.loc[i,['lat','lon']].values if(i==0): tok=True else: tok=False last_t, massive, values, probs = update_mg(p, dt, last_t, massive, values, probs, BORDER_VALUE, norm=l2_norm, tok=tok, re_c=re_c, aging=aging) return massive, values, probs def low_level_transaction(lat,lon, mp, pbs, pogr=100): """ low level check of validity of the transaction based on history :type lat: numeric :param lat: latitude of the transaction :type lon: numeric :param lon: lontitude of the transaction :type mp: string list :param mp: list with centers of circles of the selected level :type pbs: numeric list :param pbs: list with probabilities corresponding to the circles :type pogr: numeric :param pogr:value used to count probability """ prob = 0.0 for i,j in zip(mp,pbs): s = i.split(' ') lt,ln = float(s[0]),float(s[1]) rng = l2_norm(lat, lon, lt, ln) if(rng<1): prob += j/np.log2(pogr) else: prob += j/rng print(prob) return prob def transaction(data, lat,lon,time, date, uid, local=False): """ Checks full legitimicy of the transaction :type data: pandas dataFrame :param data: dataFrame withall the data :type lat: numeric :param lat: latitude of the transaction :type lon: numeric :param lon: lontitude of the transaction :type time: string :param time: time of the transaction :type date: string :param date: date of the transaction :type uid: string :param uid: index of the client
only, to, training after the moment. :param model: :param optimizer: :param train_queue: :param valid_queue: :param args: :param search_space: :return: res_dict, best_valids, best_tests from evlutionary search """ # merge the evaluation phase inside. # optimizer = self.optimizer # scheduler = self.scheduler # model = self.parallel_model # reset the random seed for reproducibility # evaluate before the post-search phase. if not self.args.evaluate_after_search: # return 0, None fitness_dict = self.evaluate(self.epoch, self._datasets[2], train_queue=self._datasets[0]) self.save_results(self.epoch, rank_details=True) ep_k = [k for k in self.ranking_per_epoch.keys()][-1] best_id = self.ranking_per_epoch[ep_k][-1][1].geno_id return best_id, self.search_space.topologies[best_id] logging.info(">=== Post Search Phase ====") epoch = self.epoch self.save_duplicate_arch_pool('valid', epoch) tr, va, te = self.load_dataset(shuffle_test=False) utils.torch_random_seed(self.args.seed) tr, va, te = self.load_dataset(shuffle_test=True) nb_batch_per_eval = self.args.evaluate_nb_batch if self.args.neweval_num_train_batches > 0: query_fn = partial(procedure_ops._query_model_with_train_further, nb_batch=nb_batch_per_eval, model=self.parallel_model, train_queue=tr, valid_queue=va, test_queue=te, policy=self) logging.info("> Finetune before evaluation query_fn.") else: query_fn = partial(procedure_ops._query_model_by_eval, nb_batch=nb_batch_per_eval, model=self.parallel_model, valid_queue=va, test_queue=te, search_space=self.search_space) logging.info("> normal evaluation query_fn.") logging.info("> Using sampler {}".format(self.args.evaluate_sampler)) if self.args.evaluate_sampler == 'random': res = procedure_ops.run_random_search_over_cnn_search(self.search_space, self.args, query_fn) elif self.args.evaluate_sampler == 'evolutionary': res = procedure_ops.run_evolutionary_search_on_search_space(self.search_space, self.args, query_fn) else: raise NotImplementedError(f"self.args.evaluate_sampler {self.args.evaluate_sampler} not yet.") search_res_path = self.args.main_path + '/' + self.args.evaluate_sampler + '_results.json' search_arch_path = self.args.main_path + '/' + self.args.evaluate_sampler + '_archs.json' # implement this outside the loop ... # test if all is id res_dict = res[0] res_specs = res[-1] mids = list(res_dict.keys()) est_perfs = [res_dict[i]['test_accuracy'] for i in mids] if all(map(lambda x: isinstance(x, int), list(mids))): utils.save_json(res, search_res_path) # compute the kendall tau and do the best gt_ranks = [self.search_space.rank_by_mid[i] for i in mids] logging.info("Kendall tau of given search: {}".format(kendalltau(gt_ranks, est_perfs).correlation)) if self.args.neweval_num_train_batches > 0: est_perfs_old = [res_dict[i]['test_accuracy_before'] for i in mids] logging.info("Kendall tau of given search before finetune: {}".format(kendalltau(gt_ranks, est_perfs_old).correlation)) # post search top 5 results top_K_indices = np.argsort(est_perfs)[::-1][:5] best_ids = [mids[i] for i in top_K_indices] best_specs = [self.search_space.topologies[i] for i in best_ids] utils.save_json([best_ids, [str(s) for s in best_specs]], search_arch_path) # let pick 5 best models using res. else: # with new architecture, we just simply return the top 5 by the validation accuracy... top_K_indices = np.argsort(est_perfs)[::-1][:5] best_ids = [mids[i] if isinstance(mids[i], int) else -1 for i in top_K_indices] best_specs = [res_specs[mids[i]] for i in top_K_indices] utils.save_json([best_ids, [str(s) for s in best_specs]], search_arch_path) return best_ids, best_specs ########################### ### Utility functions ########################### def cpu(self): self.model = self.model.cpu() def initialize_search_space(self): """ This function should align with dataset """ if 'nasbench201' in self.args.search_space: # NB201 search space self.search_space = search_space.NASBench201SearchSpace(self.args) self.model_fn = self.search_space.model_fn elif 'darts_nds' in self.args.search_space: self.search_space = search_space.DARTSSearchSpaceNDS(self.args) self.model_fn = self.search_space.model_fn elif 'nasbench101' in self.args.search_space: from utils import DictAttr, wrap_config # from nasws.cnn.search_space.nasbench101 import nasbench_build_config from nasws.cnn.search_space.nasbench101.lib.config import build_config as nasbench_build_config nasbench_search_config = DictAttr(nasbench_build_config()) wrap_config(nasbench_search_config, 'nasbench', args=self.args, keys=[ 'module_vertices', # add more if necessary. ]) self.args.nasbench_config = nasbench_search_config if 'fixchannel' in self.args.search_space: self.search_space = search_space.NasBenchSearchSpaceFixChannels(self.args) else: self.search_space = search_space.NASbenchSearchSpace(self.args) self.model_fn = self.search_space.model_fn else: raise NotImplementedError(f'initialize search space not supported for {self.args.search_space}') self._change_model_fn = self.search_space.change_model_spec def initialize_run(self, sub_dir_path=None): tr, va, te = self.load_dataset() logging.info('Creating the loss function with CrossEntropy') criterion = nn.CrossEntropyLoss() criterion = criterion.cuda() if self.args.label_smooth > 0: self._eval_loss = criterion logging.info(f'Label smoothing enabled with {self.args.label_smooth}') criterion = CrossEntropyLabelSmooth(self.num_classes, self.args.label_smooth) criterion = criterion.cuda() self._loss = criterion return tr, va, te, criterion def initialize_model(self, resume=True): """ Initialize model, may change across different model. :return: """ args = self.args model = self.model_fn(args) num_gpus = torch.cuda.device_count() if args.apex_enable: args.distributed = False if 'WORLD_SIZE' in os.environ: args.distributed = int(os.environ['WORLD_SIZE']) > 1 args.gpu = num_gpus args.world_size = 1 args.learning_rate = args.learning_rate*float(args.batch_size*args.world_size)/1024 model = model.cuda().to(memory_format=torch.contiguous_format) else: if num_gpus > 0: model = model.cuda() logging.info("param size = %fMB", utils.count_parameters_in_MB(model)) if args.optimizer == 'sgd': optimizer = torch.optim.SGD( model.parameters(), args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) logging.info("Creating SGD : init_lr {} weight_decay {}, momentum {}".format( args.learning_rate, args.momentum, args.weight_decay)) elif args.optimizer == 'rmsprop': from nasws.cnn.search_space.nasbench101.optimizer import RMSprop as RMSpropTF optimizer = RMSpropTF( model.parameters(), args.learning_rate, eps=1.0, weight_decay=args.weight_decay, momentum=args.momentum, ) logging.info("Creating RMSProp : init_lr {} weight_decay {}, momentum {}".format( args.learning_rate, args.momentum, args.weight_decay)) elif args.optimizer == 'adam': raise ValueError("todo later") else: raise NotImplementedError('optimizer not supported...') if args.apex_enable: import apex.amp as amp model, optimizer = amp.initialize( model, optimizer, opt_level='O1', # official mixed precision # keep_batchnorm_fp32=True, # bn 32 to accelarate further. loss_scale=None) # do not scale args.apex_opt_level='O1' self.amp = amp self.model = model # this is a normal cpu model... self.parallel_model = nn.DataParallel(model) if num_gpus > 1 else model lr_epochs = args.epochs if args.epochs_lr <= 0 else args.epochs_lr logging.info(f'Creating learning rate scheduler: {args.learning_rate_scheduler} with max epoch {lr_epochs}') if args.learning_rate_scheduler == 'cosine': # scheduler as Cosine. scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( optimizer, float(lr_epochs), eta_min=args.learning_rate_min) elif args.learning_rate_scheduler == 'cosinewarm': # scheduler as Cosine With Warmup scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts( optimizer, int(lr_epochs / 2), eta_min=args.learning_rate_min ) elif args.learning_rate_scheduler == 'cosineimagenet': from nasws.cnn.operations.lr_scheduler import CosineWarmupImagenetScheduler scheduler = CosineWarmupImagenetScheduler( optimizer, args.supernet_warmup_epoch, float(lr_epochs), eta_min=args.learning_rate_min ) elif args.learning_rate_scheduler == 'step': # step wise lr setting # scheduler = torch.optim.lr_scheduler.StepLR( # optimizer, step_size=int(args.epochs * 0.6 / 3), gamma=0.1, last_epoch=int(args.epochs * 0.7) # ) scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[int(lr_epochs * i) for i in [0.3, 0.6, 1.0]], gamma=0.1) elif args.learning_rate_scheduler == 'constant': scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=args.epochs, gamma=1.0) else: raise ValueError("LR Scheduler {} not supported.".format(args.learning_rate_scheduler)) self.optimizer = optimizer self.scheduler = scheduler # here it is, but lets try to reload this. if args.resume and resume: self.resume_from_checkpoint() return self.parallel_model, optimizer, scheduler def load_dataset(self, shuffle_test=False): if self._datasets: return self._datasets args = self.args if args.dataset == 'cifar10': train_queue, valid_queue, test_queue = load_supernet_cifar10(args, shuffle_test) self.num_classes = 10 elif args.dataset == 'imagenet': # train_queue, valid_queue, test_queue = load_supernet_cifar10(args, shuffle_test, debug_imgnet=True) train_queue, valid_queue, test_queue = load_supernet_imagenet(args) self.num_classes = 1000 else: raise NotImplementedError("Temporary not used.") self._datasets = train_queue, valid_queue, test_queue return self._datasets @staticmethod def next_batches(dataloader, num_batches): queue = [] _batch_count = 0 for data in dataloader: _batch_count += 1 queue.append(data) if _batch_count > num_batches: # process iteration break return queue def op_sampler(self, model, architect, args): return self.search_space.op_sampler(model, architect, args) def random_sampler(self, model, architect, args): return self.search_space.random_sampler(model, architect, args) @staticmethod def _compute_kendall_tau(ranking_per_epoch, compute_across_time=False): """ Compute Kendall tau given the ranking per epochs. :param ranking_per_epoch: :param compute_across_time: True for ranking-per-epoch always fixed, False for dynamic list of models. :return: kd_tau dict{epoch_key: KendallTau} """ if compute_across_time: # Compute Kendall tau for every epochs and save them into result. epoch_keys = [k for k in reversed(ranking_per_epoch.keys())] epoch_keys.insert(0, 10000000) kd_tau = {} for ind, k in enumerate(epoch_keys[:-1]): elem = [] if ind == 0: # Sort the ground-truth ranking p = sorted([elem[1] for elem in ranking_per_epoch[epoch_keys[ind + 1]]], key=itemgetter(3)) rank_1 = np.array([elem.geno_id for elem in p], dtype=np.uint) else: rank_1 = np.array([elem[1].geno_id for elem in ranking_per_epoch[k]], dtype=np.uint) for j in epoch_keys[ind + 1:]: rank_2 = np.array([elem[1].geno_id for elem in ranking_per_epoch[j]], dtype=np.uint) elem.append(kendalltau(rank_1, rank_2)) kd_tau[k] = elem logging.info("Latest Kendall Tau (ground-truth vs {}): {}".format(epoch_keys[1], kd_tau[10000000][0])) return kd_tau, kd_tau[10000000][0].correlation else: # Dynamic ranking per epoch size, thus only compute the KDT against the final ranking. epoch_keys = [k for k in reversed(ranking_per_epoch.keys())] kd_tau = {} # only sort across the ground-truth for ind, k in enumerate(epoch_keys): p = sorted([elem[1] for elem in ranking_per_epoch[k]], key=itemgetter(3)) rank_gt = np.array([elem.geno_id for elem in p], dtype=np.uint) rank_2 = np.array([elem[1].geno_id for elem in ranking_per_epoch[k]], dtype=np.uint) kd_tau[k] = kendalltau(rank_gt, rank_2) # IPython.embed(header='check kendall tau computation again for DARTS search space') kd_tau[10000000] = kd_tau[epoch_keys[0]] logging.info("Latest Kendall Tau (ground-truth vs {}): {}".format(epoch_keys[0], kd_tau[epoch_keys[0]][0])) return kd_tau, kd_tau[epoch_keys[0]][0] def _save_ranking_results(self, save_data, epoch, prefix=None, compute_kdt_before=False, sparse_kdt=True, sparse_kdt_threshold=1e-3, percentile=True, percentile_top_K=(3, 5, 10, 20), random_kdt=True, random_kdt_numrepeat=5, random_kdt_num_archs=(10, 20, 50, 100)): """ Save the ranking results if necessary. 13.09.2019: Adding the sparse kendall tau, percentile, random kendall tau. :param save_data: :param epoch: :param prefix: Prefix to the tensorboard scalar. :param compute_kdt_before: True to compute the kendall tau for additional evaluation approachs. :param sparse_kdt: True to compute the sparse kendall tau based on the GT accuracy. :param percentile: True to compute the top K model percentile. :param percentile_top_K: Number of top K architectures for percentile. :param random_kdt: True to compute the random K architectures's kendall tau. :param random_kdt_numrepeat: Number of repeated times for this random
<reponame>mkelcb/knet<filename>knet/com/application/logic/knet/knet_manager.py # -*- coding: utf-8 -*- #MIT License #Copyright (c) 2017 <NAME> #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. from ....application.utils import plotgen from ....application.utils import geno_qc from ....application.logic.knet import knet_main from ....io import knet_IO import gc import numpy as np from numpy.linalg import norm from scipy import stats from pathlib import Path import random import os lastLayerSize_MAX = int(1000) # int(4096 /2) # delta = (Ve/Vg) # delta = (1-h2) / h2 #args, args.epochs, args.learnRate, args.momentum, args.evalFreq, args.savFreq, args.predictPheno, args.loadWeights, args.saveWeights, args.randomSeed, args.hidCount, args.hidl2, args.hidAct # V(G) 0.168545 0.004763 #V(e) 0.006826 0.002168 def addActivation(myNet, hidAct): if hidAct == 1 : H_Act = knet_main.knSigmoid( myNet) elif hidAct == 2 : H_Act = knet_main.knRELU( myNet) elif hidAct == 3 : print("no activatioN") elif hidAct == 5 : H_Act = knet_main.knLeakyRELU( myNet) else : H_Act = knet_main.knSoftplus( myNet) def getNetworkStructure(myNet) : layernum = 0 for layerIndex in range(0,len(myNet.layers)) : layer = myNet.layers[layerIndex] if type(layer) == knet_main.knnLayer: # for non input types, we have if layer.Weights_W is not None : layernum += 1 print("layer " + str(layernum) + " has weight matrix shaped: " + str(layer.Weights_W.shape)) def runKnet(args) : hLayerCount = args.hidCount hiddenShrinkage = args.hidl2 # default QC settings used for all non AMBLUP versions _minObserved = 0.95 _minMAF = 0.01 _minVariance = 0.02 # load plink binary / phenotypes want to load them here, so that we can release the memory once the raw data is no longer used cc = True if args.cc == 0 : cc = False recodecc = True if args.recodecc == 0 : recodecc = False genotypeData = knet_IO.loadPLINK(args.knet, loadPhenos = False) M = genotypeData["M"] irsIds = genotypeData["rsid"] IDs = genotypeData["IDs"] indicesKept = np.asarray( range(M.shape[1]) ) del genotypeData ; gc.collect() # dont need this y = knet_IO.loadPLINKPheno(args.pheno, caseControl = cc, recodeCaseControl = recodecc) y = stats.zscore(y) # zscore it so that Beta -> h2 computations work # if we have a validation set M_validation = None y_validation = None if args.validSet : genotypeData = knet_IO.loadPLINK(args.validSet, loadPhenos = False, replaceMissing = True) # want to replace -1 with 0s, as we otherwise would have -1s, as later we just delete indices that failed QC for the training set, but won't care for individual missing datas M_validation = genotypeData["M"] IDs_validation = genotypeData["IDs"] print("Loaded number of people for validatin: ", len(M_validation), flush=True ) del genotypeData ; gc.collect() # dont need this if args.validPhen : y_validation = knet_IO.loadPLINKPheno(args.validPhen, caseControl = cc, recodeCaseControl = recodecc) y_validation = stats.zscore(y_validation) # zscore it so that Beta -> h2 computations work if args.inference == 0 : # 1. standardise data if args.qc == 1 : qc_data = geno_qc.genoQC_all(M, rsIds = irsIds, minObserved = _minObserved, minMAF = _minMAF, minVariance = _minVariance) # we MUST perform QC with the EXACT SAME settings as the 'region scanner' otherwise the region coordinates will be mismatched #M = qc_data["X"] rsIds_qc = qc_data["rsIds"] # save away the surviving SNP list that we have used indicesToRemove = qc_data["indicesToRemove"] indicesKept = qc_data["indicesKept"] irsIds = rsIds_qc.tolist() del qc_data; gc.collect() # overwrite qc_data = geno_qc.removeList(M, indicesToRemove) M = qc_data["X"] del qc_data; gc.collect() # overwrite else : print("Skipping internal QC", flush=True) M, mns, sstd = geno_qc.standardise_Genotypes(M) ; gc.collect() print("After standardising, training data in MBs is: ",geno_qc.getSizeInMBs(M) ) else : print("Inference data QC", flush=True) if args.snpIndices is not None : indicesToKeep = knet_IO.loadIndices(args.snpIndices) M = M[:,indicesToKeep] mns = knet_IO.loadVectorFromDisk( args.mns , 'float32') # these are always float32 even in 64 runs sstd = knet_IO.loadVectorFromDisk( args.sstd , 'float32') snpIDs = knet_IO.loadsnpIDs(args.snpIDs) M = M.astype('float32') M -= mns M /= sstd # load final list of RSids # load mean /SDs #M = geno_qc.standardise_Genotypes(M) ; gc.collect() #print("After standardising, training data in MBs is: ",geno_qc.getSizeInMBs(M) ) # get Zscores: have to standardise ONLY over the training, and not the training+ validation together: https://blog.slavv.com/37-reasons-why-your-neural-network-is-not-working-4020854bd607 # will have to implement this for genetic data if M_validation is not None : if args.qc == 1 : # depending on if we are in inference mode, make sure we have the same set of SNPs if args.inference == 0 : M_validation = np.delete(M_validation, indicesToRemove, axis=1) else : M_validation = M_validation[:,indicesToKeep] #qc_data = geno_qc.removeList(M_validation, indicesToRemove) M_validation = M_validation.astype('float32') M_validation -= mns M_validation /= sstd indices_validation = np.asarray( range(len(M_validation)) ) # is used for storting print("After standardising, validation data in MBs is: ",geno_qc.getSizeInMBs(M_validation) ) # Pre-process data: evalTrainResults = True BNEnabled = int(args.bnorm) == 1 decay_Enabled = int(args.lr_decay) == 1 # Shuffle data before producing the minibatches to avoid having all-case or all-control minibatches np.random.seed(args.randomSeed) random.seed(args.randomSeed) indices = np.asarray( range(len(M)) ) # is used for storting random.shuffle(indices) M = M[indices] y = y[indices] IDs[0] = np.array(IDs[0]) IDs[1] = np.array(IDs[1]) IDs[0] = IDs[0][indices] IDs[1] = IDs[1][indices] # reshape data to be the right dimensions for Convolutions if args.convLayers > 0 : M = M.reshape(M.shape[0], 1 , 1, M.shape[1]) if M_validation is not None : M_validation = M_validation.reshape(M_validation.shape[0], 1 , 1, M_validation.shape[1]) # 2. create minibatch list numIndividuals = M.shape[0] numSNPs = M.shape[1] # numSNPs = bed.get_nb_markers(), as we may have removed SNPs, we want to know how many are left len_M = len(M) len_M_validation = 0 train_GWAS = list() train_y = list() minibatch_size = args.batch_size #M.shape[0] # 64 if args.batch_size == 0 : minibatch_size = len(M) num_batches = len(M) // minibatch_size # scale the delta by minibatch_size, if we dont have minibatches ratio = float(minibatch_size) / numIndividuals # this is 1 if there are no minibatches print("orig L2 Regularizer : " + str(hiddenShrinkage) + " minibatches scaled to " + str(hiddenShrinkage * ratio) ) hiddenShrinkage *= ratio start = 0 end = minibatch_size # for i in range(num_batches) : # train_GWAS.append(M[start:end] ) # train_y.append(y[start:end]) # print("adding batch " + str(i) + " , start/end: " + str(start) + "/" + str(end) ) # start = end # end += minibatch_size y_batched = y.copy() # do this in a more RAM efficient way: keep deleting the bits from the original matrix to free up space as we go along otherwise this step would double the RAM requirements temporarily for i in range(num_batches) : train_GWAS.append(M[0:minibatch_size] ) M = M[minibatch_size:len(M)] train_y.append(y_batched[0:minibatch_size]) y_batched = y_batched[minibatch_size:len(y_batched)] print("adding batch " + str(i) + ", minibatch size: " + str(minibatch_size) + " / num left in pool: " + str(len(M)) ) gc.collect() print("train_GWAS[0].shape: " + str( train_GWAS[0].shape) + " // train_y.shape: " + str( train_y[0].shape) ) del M; gc.collect() # free up memory if M_validation is not None : len_M_validation = len(M_validation) if args.batch_size == 0 : minibatch_size = len(M_validation) test_GWAS = list() test_y = list() evalResults = True num_batches = len(M_validation) // minibatch_size print("len_M_validation is: " + str(len_M_validation) + ", minibatch size: " + str(minibatch_size) + " args.batch_size: " + str(args.batch_size) + " num_batches is: " + str(num_batches)) start = 0 end = minibatch_size for i in
<gh_stars>0 # Copyright (c) 2010-2011 Lazy 8 Studios, LLC. # All rights reserved. import hashlib, pkg_resources from mako import lookup from front import models from front.lib import db, xjson, urls, gametime from front.backend import deferred from front.data import load_json, schemas, assets from front.models import chips, region from front.callbacks import run_callback, MISSION_CB import logging logger = logging.getLogger(__name__) # The path relative to this package where the mission data is stored. MISSION_DEFINITIONS = pkg_resources.resource_filename('front', 'data/mission_definitions.json') # Template cache. _template_lookup = lookup.TemplateLookup(input_encoding='utf-8', output_encoding='utf-8') # Fields in speciesList which support Mako templating. TEMPLATE_FIELDS = ['title', 'summary', 'description'] def add_mission(ctx, user, mission_definition, mission_parent=None, **kwargs): """ Create a new Mission Model object for the given user. Note: specifics is for configuring generic missions for the user's specific needs, and is serialized JSON stored as a string in the database. The specifics_hash is populated with the hash of the specifics as the name implies; it's there so that the user can't do the exact same mission twice. The mission_id is the combination of the mission_definition and the specifics, with the parent_id having a similar formulation. NOTE: If the given mission_definition has already been added to this user, then this function will log a warning and return None indicating the mission already existed. This behavior exists so that if the ordering of when missions are added is changed on the live system to reflect for instance a change in the story, then if a user had already received a mission in the previous version of the story it will not raise an exception here, hopefully allowing a smoother migration experience for existing users to the new story version. :param ctx: The database context. :param user: The User who will own this Mission. :param mission_definition: str The key which identifies this mission type. Defined in mission_definitions.json. :param mission_parent: Mission The optional Mission instance which is the parent of this Mission. :param kwargs: dict All other keyword arguments will be passed through to the creation_hook for this Mission's mission_callbacks callback. These might be useful when creating the mission specifics. """ # As we change the story script, sometimes we change the order when a mission is being added # to the game. This guard is intended to make that migration more smooth. NOTE: It is critical # that a given MIS_ key always refers to the same 'mission concept'. if user.missions.get_only_by_definition(mission_definition) is not None: logger.warning("Refusing to add exising mission_definition to user. [%s][%s]", mission_definition, user.user_id) return None # Determine the md5 hashes of the mission specifics for this Mission instance by running # the create_specifics callback for the mission code associated with this mission_definition. specifics = run_callback(MISSION_CB, "create_specifics", mission_definition, ctx=ctx, user=user, **kwargs) dumped_specifics = xjson.dumps(specifics) md5 = hashlib.md5() md5.update(dumped_specifics) specifics_hash = md5.hexdigest() if mission_parent: parent_hash = mission_parent.specifics_hash else: parent_hash = '' params = {} params['mission_definition'] = mission_definition params['specifics'] = dumped_specifics params['specifics_hash'] = specifics_hash params['parent_hash'] = parent_hash params['done'] = 0 params['done_at'] = None params['started_at'] = user.epoch_now params['viewed_at'] = None # We need to snapshot the existing list of regions for this user as once the # new mission is added to the gamestate it will potentially influence the list # of regions, which will potentially make the check if it is a new region later # in this factory function fail. current_user_regions = user.regions.keys() with db.conn(ctx) as ctx: db.run(ctx, "insert_mission", user_id=user.user_id, created=gametime.now(), **params) new_mission = user.missions.create_child(mission_parent=mission_parent, user=user, **params) # If we have a parent, add ourselves to the hierarchy. if mission_parent != None: mission_parent.parts.append(new_mission) # Issue ADD chips for any regions defined/available for this mission at creation time. for region_id, constructor_args in new_mission.region_list_callback(): # Adding a region more than once may cause inconsistencies with ADD/DELETE chips. assert region_id not in current_user_regions region.add_region_to_user(ctx, user, region_id, **constructor_args) current_user_regions.append(region_id) # Issue the mission ADD chip. new_mission.send_chips(ctx, user) # If this mission has any children, add them now. child_parts = run_callback(MISSION_CB, "create_parts", mission_definition, mission=new_mission) for child_mission_def in child_parts: add_mission(ctx, user, child_mission_def, mission_parent=new_mission, **kwargs) # Trigger the was_created callback. run_callback(MISSION_CB, "was_created", mission_definition, ctx=ctx, user=user, mission=new_mission) return new_mission class Mission(chips.Model, models.UserChild): # These fields come from the mission definitions JSON file. DEFINITION_FIELDS = frozenset(['title', 'summary', 'description', 'done_notice', 'parent_definition', 'type', 'sort', 'title_icon', 'description_icon']) id_field = 'mission_id' fields = frozenset(['mission_definition', 'done', 'done_at', 'specifics', 'specifics_hash', 'started_at', 'viewed_at', 'region_ids', 'parent_id', 'parent_hash', 'mission_parent', 'parts']).union(DEFINITION_FIELDS) # The list of region_ids being provided to the gamestate by the mission, in its current # done/not done state. Provided to the gamestate in the 'region_ids' field. # Note that because LazyFields values are cached, if the 'done' state of this mission changes # the value of region_ids might need refreshing. region_ids = chips.LazyField("region_ids", lambda m: m._region_list_ids()) computed_fields = { 'started_at_date': models.EpochDatetimeField('started_at'), 'viewed_at_date': models.EpochDatetimeField('viewed_at'), } server_only_fields = frozenset(['parts', 'parent_hash', 'specifics_hash', 'mission_parent']) unmanaged_fields = frozenset(['mission_parent']) # user_id, created and updated are database only fields. def __init__(self, mission_definition, parent_hash, done, specifics, specifics_hash, user, mission_parent=None, user_id=None, created=None, updated=None, **params): # Populate the fields which come from the mission definition. definition = get_mission_definition(mission_definition) for field in self.DEFINITION_FIELDS: params[field] = definition.get(field, None) # This comes from the mission definition file. parent_definition = params.get('parent_definition') if mission_parent is not None: params['parent_id'] = mission_parent.mission_id elif parent_definition is not None and parent_hash is not None: params['parent_id'] = "%s-%s" % (parent_definition, parent_hash) else: params['parent_id'] = None params['parts'] = [] # Convert the specifics hash which is stored in the DB as serialized JSON back into # a Python dict. specifics = xjson.loads(specifics) # Construct the mission id which is the definition name and the md5 hash of the specifics. mission_id = make_mission_id(mission_definition, specifics_hash) # Render the title, summary and description fields. params['title'] = _render_template(mission_definition, 'title', {'user': user}) if params['summary'] is not None: params['summary'] = _render_template(mission_definition, 'summary', {'user': user}) if params['description'] is not None: params['description'] = _render_template(mission_definition, 'description', {'user': user}) super(Mission, self).__init__(mission_id=mission_id, mission_definition=mission_definition, mission_parent = mission_parent, parent_hash=parent_hash, done=done, specifics=specifics, specifics_hash=specifics_hash, **params) @property def user(self): # self.parent is user.missions, the parent of that is the User itself return self.parent.parent def is_root_mission(self): """ Returns True if this mission is a 'root' mission, either a childless single mission or the parent mission for one or more children. NOTE: This is not called is_root as that method already exists in chips.Model """ return self.parent_id == None def is_done(self): return self.done == 1 def was_viewed(self): return self.viewed_at != None @property def url_title_icon(self): definition = assets.mission_icon_definition(self.title_icon) return definition['done'] if self.is_done() else definition['active'] @property def url_description_icon(self): definition = assets.mission_icon_definition(self.description_icon) return definition['done'] if self.is_done() else definition['active'] def next_step(self): """ Return the next step/sibling mission to this mission. This asserts that this mission has a parent. If there is no next step, None is returned. """ assert self.mission_parent != None # We should have a parent. # Will raise ValueError if somehow this mission is not known to the parent. index = self.mission_parent.parts.index(self) # We are the first step, there is not previous. if index == len(self.mission_parent.parts) - 1: return None else: return self.mission_parent.parts[index + 1] def previous_step(self): """ Return the previous step/sibling mission to this mission. This asserts that this mission has a parent. If there is no previous step, None is returned. """ assert self.mission_parent != None # We should have a parent. # Will raise ValueError if somehow this mission is not known to the parent. index = self.mission_parent.parts.index(self) # We are the first step, there is not previous. if index == 0: return None else: return self.mission_parent.parts[index - 1] def siblings(self): """ Return the array of all other siblings, not including self. """ assert self.mission_parent != None # We should have a parent. return [part for part in self.mission_parent.parts if part != self] def done_siblings(self): """ Return the array of done siblings, not including self. """ assert self.mission_parent != None # We should have a parent. return [part for part in self.mission_parent.parts if part != self and part.is_done()] def mark_done(self): # As we change the story script, sometimes we change the order when a mission is being marked done # in the game. This
<gh_stars>10-100 __author__ = "<NAME>, <NAME>" __copyright__ = "Copyright 2012-2013, The SAGA Project" __license__ = "MIT" """ Attribute interface """ import radical.utils as ru import radical.utils.signatures as rus from . import exceptions as se # ------------------------------------------------------------------------------ import datetime import datetime import traceback import inspect import string import copy import re from pprint import pprint # FIXME: add a tagging 'Monitorable' interface, which enables callbacks. now = datetime.datetime.now never = datetime.datetime.min # ------------------------------------------------------------------------------ # # define a couple of constants for the attribute API, mostly for registering # attributes. # # type enums ANY = 'any' # any python type can be set URL = 'url' # URL type (string + URL parser checks) INT = 'int' # Integer type FLOAT = 'float' # float type STRING = 'string' # string, duh! BOOL = 'bool' # True or False or Maybe ENUM = 'enum' # value is any one of a list of candidates TIME = 'time' # seconds since epoch, or any py time thing # which can be converted into such # FIXME: conversion not implemented # mode enums WRITEABLE = 'writeable' # the consumer of the interface can change # the attrib value READONLY = 'readonly' # the consumer of the interface can not # change the attrib value. The # implementation can still change it. FINAL = 'final' # neither consumer nor implementation can # change the value anymore ALIAS = 'alias' # variable is deprecated, and alias'ed to # a different variable. # attrib extensions EXTENDED = 'extended' # attribute added as extension PRIVATE = 'private' # attribute added as private # flavor enums SCALAR = 'scalar' # the attribute value is a single data element DICT = 'dict' # the attribute value is a dict of data elements VECTOR = 'vector' # the attribute value is a list of data elements # ------------------------------------------------------------------------------ # # Callback (Abstract) Class # class Callback () : """ Callback base class. All objects using the Attribute Interface allow to register a callback for any changes of its attributes, such as 'state' and 'state_detail'. Those callbacks can be python call'ables, or derivates of this callback base class. Instances which inherit this base class MUST implement (overload) the cb() method. The callable, or the callback's cb() method is what is invoked whenever the SAGA implementation is notified of an change on the monitored object's attribute. The cb instance receives three parameters upon invocation: - obj: the watched object instance - key: the watched attribute (e.g. 'state' or 'state_detail') - val: the new value of the watched attribute If the callback returns 'True', it will remain registered after invocation, to monitor the attribute for the next subsequent state change. On returning 'False' (or nothing), the callback will not be called again. To register a callback on a object instance, use:: class MyCallback (saga.Callback): def __init__ (self): pass def cb (self, obj, key, val) : print(" %s\\n %s (%s) : %s" % self._msg, obj, key, val) jd = saga.job.Description () jd.executable = "/bin/date" js = saga.job.Service ("fork://localhost/") job = js.create_job(jd) cb = MyCallback() job.add_callback(saga.STATE, cb) job.run() See documentation of the :class:`saga.Attribute` interface for further details and examples. """ def __call__ (self, obj, key, val) : return self.cb (obj, key, val) def cb (self, obj, key, val) : """ This is the method that needs to be implemented by the application Keyword arguments:: obj: the watched object instance key: the watched attribute val: the new value of the watched attribute Return:: keep: bool, signals to keep (True) or remove (False) the callback after invocation Callback invocation MAY (and in general will) happen in a separate thread -- so the application need to make sure that the callback code is thread-safe. The boolean return value is used to signal if the callback should continue to listen for events (return True) , or if it rather should get unregistered after this invocation (return False). """ pass # ------------------------------------------------------------------------------ # class _AttributesBase (object) : """ This class only exists to host properties -- as object itself does *not* have properties! This class is not part of the public attribute API. """ # -------------------------------------------------------------------------- # @rus.takes ('_AttributesBase') @rus.returns (rus.nothing) def __init__ (self) : pass # ------------------------------------------------------------------------------ # class Attributes (_AttributesBase, ru.DictMixin) : """ Attribute Interface Class The Attributes interface implements the attribute semantics of the SAGA Core API specification (http://ogf.org/documents/GFD.90.pdf). Additionally, this implementation provides that semantics the python property interface. Note that a *single* set of attributes is internally managed, no matter what interface is used for access. A class which uses this interface can internally specify which attributes can be set, and what type they have. Also, default values can be specified, and the class provides a rudimentary support for converting scalar attributes into vector attributes and back. Also, the consumer of this API can register callbacks, which get triggered on changes to specific attribute values. Example use case:: # -------------------------------------------------------------------------------- class Transliterator ( saga.Attributes ) : def __init__ (self, *args, **kwargs) : # setting attribs to non-extensible will cause the cal to init below to # complain if attributes are specified. Default is extensible. # self._attributes_extensible (False) # pass args to base class init (requires 'extensible') super (Transliterator, self).__init__ (*args, **kwargs) # setup class attribs self._attributes_register ('apple', 'Appel', URL, SCALAR, WRITEABLE) self._attributes_register ('plum', 'Pruim', STRING, SCALAR, READONLY) # setting attribs to non-extensible at *this* point will have allowed # custom user attribs on __init__ time (via args), but will then forbid # any additional custom attributes. # self._attributes_extensible (False) # -------------------------------------------------------------------------------- if __name__ == "__main__": # define a callback method. This callback can get registered for # attribute changes later. # ---------------------------------------------------------------------------- def cb (key, val, obj) : # the callback gets information about what attribute was changed # on what object: print("called: %s - %s - %s" % (key, str(val), type (obj))) # returning True will keep the callback registered for further # attribute changes. return True # ---------------------------------------------------------------------------- # create a class instance and add a 'cherry' attribute/value on # creation. trans = Transliterator (cherry='Kersche') # use the property interface to mess with the pre-defined # 'apple' attribute print("\\n -- apple") print(trans.apple) trans.apple = 'Abbel' print(trans.apple) # add our callback to the apple attribute, and trigger some changes. # Note that the callback is also triggered when the attribute's # value changes w/o user control, e.g. by some internal state # changes. trans.add_callback ('apple', cb) trans.apple = 'Apfel' # Setting an attribute final is actually an internal method, used by # the implementation to signal that no further changes on that # attribute are expected. We use that here for demonstrating the # concept though. Callback is invoked on set_final(). trans._attributes_set_final ('apple') trans.apple = 'Abbel' print(trans.apple) # mess around with the 'plum' attribute, which was marked as # ReadOnly on registration time. print("\\n -- plum") print(trans.plum) # trans.plum = 'Pflaume' # raises readonly exception # trans['plum'] = 'Pflaume' # raises readonly exception print(trans.plum) # check if the 'cherry' attribute exists, which got created on # instantiation time. print("\\n -- cherry") print(trans.cherry) # as we have 'extensible' set, we can add a attribute on the fly, # via either the property interface, or via the GFD.90 API of # course. print("\\n -- peach") print(trans.peach) trans.peach = 'Birne' print(trans.peach) This example will result in:: -- apple Appel Appel Abbel called: apple - Abbel Appel - <class '__main__.Transliterator'> called: apple - Apfel - <class '__main__.Transliterator'> called: apple - Apfel - <class '__main__.Transliterator'> Apfel -- plum Pruim Pruim -- cherry Kersche -- peach Berne Birne """ # internally used constants to distinguish API from adaptor calls _UP = '_up' _DOWN = '_down' # two regexes for converting CamelCase into under_score_casing, as static # class vars to avoid frequent recompilation _camel_case_regex_1 = re.compile('(.)([A-Z][a-z]+)') _camel_case_regex_2 = re.compile('([a-z0-9])([A-Z])') # -------------------------------------------------------------------------- # @rus.takes ('Attributes', rus.anything, rus.anything) @rus.returns (rus.nothing) def __init__ (self, *args, **kwargs) : """ This method is not supposed to be directly called by the consumer of this API -- it should be called via derived object construction. _attributes_t_init makes sure that the basic structures are in place
= int(round_up_to_even(number_finger / (fan_factor ** i)) / 2) dp_num_tot = dp_num_tot + dp_num_half_fan[2 * i] + dp_num_half_fan[2 * i + 1] dp_num_half_fan.sort() for i in range(number_fan * 2): if (i == 0): dp_index_first_half_fan[i] = 0 dp_index_end_half_fan[i] = dp_num_half_fan[i] - 1 else: dp_index_first_half_fan[i] = dp_index_first_half_fan[i - 1] + dp_num_half_fan[i - 1] dp_index_end_half_fan[i] = dp_index_end_half_fan[i - 1] + dp_num_half_fan[i] for i in range(number_fan): dp_index_first_half_fan_odd[i] = dp_index_first_half_fan[2 * i] dp_index_first_half_fan_even[i] = dp_index_first_half_fan[2 * i + 1] al_num_half_fan = ['' for i in range(number_fan * 2)] al_index_first_half_fan = ['' for i in range(number_fan * 2)] al_index_end_half_fan = ['' for i in range(number_fan * 2)] al_index_first_half_fan_odd = ['' for i in range(number_fan)] al_index_first_half_fan_even = ['' for i in range(number_fan)] al_num_tot = 0 for i in range(number_fan): if (i == 0): al_num_half_fan[i] = int(number_finger_al / 2) al_num_half_fan[i + 1] = int(number_finger_al / 2) else: al_num_half_fan[2 * i] = int(round_up_to_even(number_finger_al / (fan_factor ** i)) / 2) al_num_half_fan[2 * i + 1] = int(round_up_to_even(number_finger_al / (fan_factor ** i)) / 2) al_num_tot = al_num_tot + al_num_half_fan[2 * i] + al_num_half_fan[2 * i + 1] al_num_half_fan.sort() for i in range(number_fan * 2): if (i == 0): al_index_first_half_fan[i] = 0 al_index_end_half_fan[i] = al_num_half_fan[i] - 1 else: al_index_first_half_fan[i] = al_index_first_half_fan[i - 1] + al_num_half_fan[i - 1] al_index_end_half_fan[i] = al_index_end_half_fan[i - 1] + al_num_half_fan[i] for i in range(number_fan): al_index_first_half_fan_odd[i] = al_index_first_half_fan[2 * i] al_index_first_half_fan_even[i] = al_index_first_half_fan[2 * i + 1] # placements parameters al_row_layout = ['' for i in range(al_num_tot)] dp_row_layout = ['' for i in range(dp_num_tot)] cm_ref_layout = ['' for i in range(int(number_finger_cm_ref / 2))] cm_row_layout = ['' for i in range(cm_num_tot)] max_finger = max(al_num_tot, dp_num_tot, cm_num_tot) guardring_n = ['' for i in range(max_finger + int(number_finger_cm_ref * 0.5) + number_fan * 4)] guardring_p = ['' for i in range(max_finger + int(number_finger_cm_ref * 0.5) + number_fan * 4)] # placements # always place reference current mirror first for i in range(int(number_finger_cm_ref / 2)): if (i == 0): cm_ref_layout[0] = laygen.relplace(templatename=['currentmirror_ref_n'], gridname=pb, xy=[-2, 0], direction='left') else: cm_ref_layout[i] = laygen.relplace(templatename=['currentmirror_ref_n'], gridname=pb, refobj=cm_ref_layout[i - 1], direction='left') # if finger number of current mirror is the greatest if (number_finger_cm >= 2 * number_finger and number_finger_cm >= 2 * number_finger_al): # current mirror placement flag1 = 0 for i in range(int(cm_num_tot)): if (i == 0): cm_row_layout[0] = laygen.relplace(templatename=['currentmirror_single_n'], gridname=pb, refobj=cm_ref_layout[0], xy=[2, 0], direction='right') elif (i in cm_index_first_eachfan): cm_row_layout[i] = laygen.relplace(templatename=['currentmirror_single_n'], gridname=pb, refobj=cm_row_layout[i - 1], xy=[8, 0], direction='right') flag1 = flag1 + 1 else: cm_row_layout[i] = laygen.relplace(templatename=['currentmirror_single_n'], gridname=pb, refobj=cm_row_layout[i - 1], direction='right') # if number_finger >= number_finger_al if (number_finger >= number_finger_al): # diff pair placement flag2 = 0 for i in range(dp_num_tot): if (i in dp_index_first_half_fan_odd): dp_row_layout[i] = laygen.relplace(templatename=['diffpair_two_finger_n'], gridname=pb, refobj=cm_row_layout[cm_index_first_eachfan[flag2]], direction='top') flag2 = flag2 + 1 elif (i in dp_index_first_half_fan_even): dp_row_layout[i] = laygen.relplace(templatename=['diffpair_two_finger_n'], gridname=pb, refobj=dp_row_layout[i - 1], xy=[2, 0], direction='right') else: dp_row_layout[i] = laygen.relplace(templatename=['diffpair_two_finger_n'], gridname=pb, refobj=dp_row_layout[i - 1], direction='right') # active load placement flag3 = 0 for i in range(al_num_tot): if (i in al_index_first_half_fan): al_row_layout[i] = laygen.relplace(templatename=['activeload_two_finger_p'], gridname=pb, refobj=dp_row_layout[dp_index_first_half_fan[flag3]], direction='top') flag3 = flag3 + 1 else: al_row_layout[i] = laygen.relplace(templatename=['activeload_two_finger_p'], gridname=pb, refobj=al_row_layout[i - 1], direction='right') # if number_finger < number_finger_al else: # active load placement flag3 = 0 for i in range(al_num_tot): if (i in al_index_first_half_fan_odd): al_row_layout[i] = laygen.relplace(templatename=['activeload_two_finger_p'], gridname=pb, refobj=cm_row_layout[cm_index_first_eachfan[flag3]], xy=[0, 1], direction='top') flag3 = flag3 + 1 elif (i in al_index_first_half_fan_even): al_row_layout[i] = laygen.relplace(templatename=['activeload_two_finger_p'], gridname=pb, refobj=al_row_layout[i - 1], xy=[2, 0], direction='right') else: al_row_layout[i] = laygen.relplace(templatename=['activeload_two_finger_p'], gridname=pb, refobj=al_row_layout[i - 1], direction='right') # diff pair placement flag2 = 0 for i in range(dp_num_tot): if (i in dp_index_first_half_fan): dp_row_layout[i] = laygen.relplace(templatename=['diffpair_two_finger_n'], gridname=pb, refobj=al_row_layout[al_index_first_half_fan[flag2]], direction='bottom') flag2 = flag2 + 1 else: dp_row_layout[i] = laygen.relplace(templatename=['diffpair_two_finger_n'], gridname=pb, refobj=dp_row_layout[i - 1], direction='right') # if finger number of diff pair is the greatest elif (2 * number_finger >= number_finger_cm and number_finger >= number_finger_al): # diff pair placement for i in range(dp_num_tot): if (i == 0): dp_row_layout[0] = laygen.relplace(templatename=['diffpair_two_finger_n'], gridname=pb, refobj=cm_ref_layout[0], xy=[4, 0], direction='top') elif (i in dp_index_first_half_fan_odd): dp_row_layout[i] = laygen.relplace(templatename=['diffpair_two_finger_n'], gridname=pb, refobj=dp_row_layout[i - 1], xy=[8, 0], direction='right') elif (i in dp_index_first_half_fan_even): dp_row_layout[i] = laygen.relplace(templatename=['diffpair_two_finger_n'], gridname=pb, refobj=dp_row_layout[i - 1], xy=[2, 0], direction='right') else: dp_row_layout[i] = laygen.relplace(templatename=['diffpair_two_finger_n'], gridname=pb, refobj=dp_row_layout[i - 1], direction='right') # current mirror placement flag1 = 0 for i in range(cm_num_tot): if (i in cm_index_first_eachfan): cm_row_layout[i] = laygen.relplace(templatename=['currentmirror_single_n'], gridname=pb, refobj=dp_row_layout[dp_index_first_half_fan_odd[flag1]], direction='bottom') flag1 = flag1 + 1 else: cm_row_layout[i] = laygen.relplace(templatename=['currentmirror_single_n'], gridname=pb, refobj=cm_row_layout[i - 1], direction='right') # active load placement flag2 = 0 for i in range(al_num_tot): if (i in al_index_first_half_fan): al_row_layout[i] = laygen.relplace(templatename=['activeload_two_finger_p'], gridname=pb, refobj=dp_row_layout[dp_index_first_half_fan[flag2]], direction='top') flag2 = flag2 + 1 else: al_row_layout[i] = laygen.relplace(templatename=['activeload_two_finger_p'], gridname=pb, refobj=al_row_layout[i - 1], direction='right') # if finger number of active load is the greatest else: # active load placement for i in range(al_num_tot): if (i == 0): al_row_layout[0] = laygen.relplace(templatename=['activeload_two_finger_p'], gridname=pb, refobj=cm_ref_layout[0], xy=[4, 1], direction='top') elif (i in al_index_first_half_fan_odd): al_row_layout[i] = laygen.relplace(templatename=['activeload_two_finger_p'], gridname=pb, refobj=al_row_layout[i - 1], xy=[8, 0], direction='right') elif (i in al_index_first_half_fan_even): al_row_layout[i] = laygen.relplace(templatename=['activeload_two_finger_p'], gridname=pb, refobj=al_row_layout[i - 1], xy=[2, 0], direction='right') else: al_row_layout[i] = laygen.relplace(templatename=['activeload_two_finger_p'], gridname=pb, refobj=al_row_layout[i - 1], direction='right') # diff pair placement flag1 = 0 for i in range(dp_num_tot): if (i in dp_index_first_half_fan): dp_row_layout[i] = laygen.relplace(templatename=['diffpair_two_finger_n'], gridname=pb, refobj=al_row_layout[al_index_first_half_fan[flag1]], direction='bottom') flag1 = flag1 + 1 else: dp_row_layout[i] = laygen.relplace(templatename=['diffpair_two_finger_n'], gridname=pb, refobj=dp_row_layout[i - 1], direction='right') # current mirror placement flag2 = 0 for i in range(cm_num_tot): if (i in cm_index_first_eachfan): cm_row_layout[i] = laygen.relplace(templatename=['currentmirror_single_n'], gridname=pb, refobj=dp_row_layout[dp_index_first_half_fan_odd[flag2]], direction='bottom') flag2 = flag2 + 1 else: cm_row_layout[i] = laygen.relplace(templatename=['currentmirror_single_n'], gridname=pb, refobj=cm_row_layout[i - 1], direction='right') # Guard Ring placement for i in range(max_finger + int(number_finger_cm_ref * 0.5) + number_fan * 4): if (i == 0): guardring_n[i] = laygen.relplace(templatename=['guard_ring_nwell'], gridname=pb, refobj=cm_ref_layout[int(number_finger_cm_ref / 2) - 1], xy=[0, 2], direction='top') guardring_p[i] = laygen.relplace(templatename=['guard_ring_psub'], gridname=pb, refobj=cm_ref_layout[int(number_finger_cm_ref / 2) - 1], direction='bottom') else: guardring_n[i] = laygen.relplace(templatename=['guard_ring_nwell'], gridname=pb, refobj=guardring_n[i - 1], direction='right') guardring_p[i] = laygen.relplace(templatename=['guard_ring_psub'], gridname=pb, refobj=guardring_p[i - 1], direction='right') # routes # current mirror self routing idc = laygen.route(xy0=[0, 0], xy1=[-2, 0], gridname0=rg23, refobj0=cm_ref_layout[-1][0].pins['D'], refobj1=cm_ref_layout[-1][0].pins['D'], via0=[0, 0]) vss = laygen.route(xy0=[0, 0], xy1=[1, 0], gridname0=rg12, refobj0=cm_ref_layout[-1][0].pins['S0'], refobj1=cm_ref_layout[-1][0].pins['S0']) laygen.route(xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=cm_ref_layout[-1][0].pins['S0'], refobj1=cm_row_layout[-1][0].pins['S1']) laygen.route(xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=cm_ref_layout[-1][0].pins['G'], refobj1=cm_row_layout[-1][0].pins['G']) for i in range(int(number_finger_cm_ref / 2) - 1): laygen.route(xy0=[0, 0], xy1=[0, 0], gridname0=rg23, refobj0=cm_ref_layout[i][0].pins['D'], refobj1=cm_ref_layout[i + 1][0].pins['D'], via0=[0, 0], via1=[0, 0]) for i in range(number_fan): for j in range(cm_num_eachfan[i] - 1): laygen.route(xy0=[0, 0], xy1=[0, 0], gridname0=rg23, refobj0=cm_row_layout[cm_index_first_eachfan[i] + j][0].pins['D'], refobj1=cm_row_layout[cm_index_first_eachfan[i] + j + 1][0].pins['D'], via0=[0, 0], via1=[0, 0]) # diff pair routing # diff pair two inputs and two outputs for i in range(2 * number_fan): if (i == 0): inp = laygen.route(xy0=[0, 0], xy1=[-2, 0], gridname0=rg12, refobj0=dp_row_layout[0][0].pins['G'], refobj1=dp_row_layout[0][0].pins['G'], via0=[0, 0]) elif (i == 1): inm = laygen.route(xy0=[0, 0], xy1=[-2, 0], gridname0=rg12, refobj0=dp_row_layout[dp_index_first_half_fan[i]][0].pins['G'], refobj1=dp_row_layout[dp_index_first_half_fan[i]][0].pins['G'], via0=[0, 0]) else: laygen.route(xy0=[0, 0], xy1=[-2, 0], gridname0=rg12, refobj0=dp_row_layout[dp_index_first_half_fan[i]][0].pins['G'], refobj1=dp_row_layout[dp_index_first_half_fan[i]][0].pins['G'], via0=[0, 0]) outm = laygen.route(xy0=[0, 0], xy1=[0, 2], gridname0=rg23, refobj0=dp_row_layout[dp_index_end_half_fan[-2]][0].pins['D'], refobj1=dp_row_layout[dp_index_end_half_fan[-2]][0].pins['D'], via0=[0, 0]) outp = laygen.route(xy0=[0, 0], xy1=[0, 2], gridname0=rg23, refobj0=dp_row_layout[-1][0].pins['D'], refobj1=dp_row_layout[-1][0].pins['D'], via0=[0, 0]) # diff pair gate and drain self connection for i in range(2 * number_fan): for j in range(dp_num_half_fan[i] - 1): laygen.route(xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=dp_row_layout[dp_index_first_half_fan[i] + j][0].pins['G'], refobj1=dp_row_layout[dp_index_first_half_fan[i] + j + 1][0].pins['G'], via0=[0, 0], via1=[0, 0]) laygen.route(xy0=[0, 0], xy1=[0, 0], gridname0=rg23, refobj0=dp_row_layout[dp_index_first_half_fan[i] + j][0].pins['D'], refobj1=dp_row_layout[dp_index_first_half_fan[i] + j + 1][0].pins['D'], via0=[0, 0], via1=[0, 0]) # diff pair: drain of i connect to gate of i+1 for i in range(number_fan - 1): for j in range(dp_num_half_fan[2 * i] - 1): laygen.route(xy0=[0, -2], xy1=[0, -2], gridname0=rg34, refobj0=dp_row_layout[dp_index_first_half_fan_odd[i] + j][0].pins['D'], refobj1=dp_row_layout[dp_index_first_half_fan_odd[i] + j + 1][0].pins['D'], via0=[0, 0], via1=[0, 0]) laygen.route(xy0=[0, 0], xy1=[0, 0], gridname0=rg34, refobj0=dp_row_layout[dp_index_first_half_fan_even[i] + j][0].pins['D'], refobj1=dp_row_layout[dp_index_first_half_fan_even[i] + j + 1][0].pins['D'], via0=[0, 0], via1=[0, 0]) laygen.route(xy0=[0, -2], xy1=[-2, -2], gridname0=rg34, refobj0=dp_row_layout[dp_index_first_half_fan_odd[i]][0].pins['D'], refobj1=dp_row_layout[dp_index_first_half_fan_odd[i + 1]][0].pins['D'], via0=[0, 0], via1=[0, 0]) laygen.route(xy0=[-2, -2], xy1=[-2, -1], gridname0=rg23, refobj0=dp_row_layout[dp_index_first_half_fan_odd[i + 1]][0].pins['D'], refobj1=dp_row_layout[dp_index_first_half_fan_odd[i + 1]][0].pins['D'], via1=[0, 0]) laygen.route(xy0=[0, 0], xy1=[-2, 0], gridname0=rg34, refobj0=dp_row_layout[dp_index_first_half_fan_even[i]][0].pins['D'], refobj1=dp_row_layout[dp_index_first_half_fan_even[i + 1]][0].pins['D'], via0=[0, 0], via1=[0, 0]) laygen.route(xy0=[-2, 0], xy1=[-2, -1], gridname0=rg23, refobj0=dp_row_layout[dp_index_first_half_fan_even[i + 1]][0].pins['D'], refobj1=dp_row_layout[dp_index_first_half_fan_even[i + 1]][0].pins['D'], via1=[0, 0]) # diff pair source self connection for i in range(number_fan): laygen.route(xy0=[0, 0], xy1=[0, 0],
<gh_stars>1-10 import copy import numpy as np class MET(object): """ MET returns the ID of the resource that executes the current task with the minimum time """ def __init__(self, env): self.env = env def schedule(self, state): """ :param env_storage: data stored in environment :return scheduled_tasks: Scheduled tasks and their resources """ scheduled_tasks = {} env_storage = self.env.env_storage # Initialize a list to record number of assigned tasks to a PE # for every scheduling instance # Initialize a list assigned = [0] * (len(self.env.pes)) # For all tasks in the ready queue, find the resource with minimum execution time of the task for idx, task in enumerate(env_storage.TaskQueues.ready.list): exec_times = [np.inf] * (len(self.env.pes)) # initialize execution time for all resources to infinite for i in range(len(self.env.resource_matrix_list)): if task.name in self.env.resource_matrix_list[i].supported_functionalities: ind = self.env.resource_matrix_list[i].supported_functionalities.index(task.name) exec_times[i] = self.env.resource_matrix_list[i].performance[ind] min_of_exec_times = min(exec_times) # the minimum execution time of the task among PEs count_minimum = exec_times.count(min_of_exec_times) # check if there are multiple resources with minimum execution time # if there are two or more PEs satisfying minimum execution # then we should try to utilize all those PEs if count_minimum > 1: # if there are tow or more PEs satisfying minimum execution # populate the IDs of those PEs into a list min_PE_IDs = [i for i, x in enumerate(exec_times) if x == min_of_exec_times] # then check whether those PEs are busy or idle PE_check_list = [True if not self.env.pes[index].idle else False for i, index in enumerate(min_PE_IDs)] # assign tasks to the idle PEs instead of the ones that are currently busy if (True in PE_check_list) and (False in PE_check_list): for PE in PE_check_list: # if a PE is currently busy remove that PE from $min_PE_IDs list # to schedule the task to a idle PE if PE: min_PE_IDs.remove(min_PE_IDs[PE_check_list.index(PE)]) # then compare the number of the assigned tasks to remaining PEs # and choose the one with the lowest number of assigned tasks assigned_tasks = [assigned[x] for i, x in enumerate(min_PE_IDs)] PE_ID_index = assigned_tasks.index(min(assigned_tasks)) scheduled_tasks[task.ID] = (min_PE_IDs[PE_ID_index], idx, []) else: scheduled_tasks[task.ID] = (exec_times.index(min_of_exec_times), idx, []) # end of if count_minimum >1: # since one task is just assigned to a PE, increase the number by 1 assigned[task.PE_ID] += 1 # end of if task.PE_ID == -1: # end of for task in list_of_ready: # At the end of this loop, we should have a valid (non-negative ID) # that can run next_task return scheduled_tasks class EFT(object): def __init__(self, env): super(EFT, self).__init__(env) self.args = env.args def schedule(self, state): ''' This scheduler compares the execution times of the current task for available resources and also considers if a resource has already a task running. it picks the resource which will give the earliest finish time for the task ''' scheduled_tasks = {} env_storage = self.env.env_storage for idx, task in enumerate(env_storage.TaskQueues.ready.list): comparison = [np.inf] * len(self.env.pes) # Initialize the comparison vector comm_ready = [0] * len(self.env.pes) # A list to store the max communication times for each PE if self.args.verbose: print('[D] Time %s: The scheduler function is called with task %s' % (self.env.now(), task.ID)) for i in range(len(self.env.resource_matrix_list)): # if the task is supported by the resource, retrieve the index of the task if task.name in self.env.resource_matrix_list[i].supported_functionalities: ind = self.env.resource_matrix_list[i].supported_functionalities.index(task.name) # $PE_comm_wait_times is a list to store the estimated communication time # (or the remaining communication time) of all predecessors of a task for a PE # As simulation forwards, relevant data is being sent after a task is completed # based on the time instance, one should consider either whole communication # time or the remaining communication time for scheduling PE_comm_wait_times = [] # $PE_wait_time is a list to store the estimated wait times for a PE # till that PE is available if the PE is currently running a task PE_wait_time = [] job_ID = -1 # Initialize the job ID # Retrieve the job ID which the current task belongs to for ii, job in enumerate(self.env.jobs.list): if job.name == task.jobname: job_ID = ii for predecessor in self.env.jobs.list[job_ID].task_list[task.base_ID].predecessors: # data required from the predecessor for $ready_task c_vol = self.env.jobs.list[job_ID].comm_vol[predecessor, task.base_ID] # retrieve the real ID of the predecessor based on the job ID real_predecessor_ID = predecessor + task.ID - task.base_ID # Initialize following two variables which will be used if # PE to PE communication is utilized predecessor_PE_ID = -1 predecessor_finish_time = -1 for completed in env_storage.TaskQueues.completed.list: if completed.ID == real_predecessor_ID: predecessor_PE_ID = completed.PE_ID predecessor_finish_time = completed.finish_time if self.args.shared_memory: # Compute the communication time considering the shared memory # only consider memory to PE communication time # since the task passed the 1st phase (PE to memory communication) # and its status changed to ready memory_to_PE_band = self.env.resource_matrix.comm_band[self.env.resource_matrix_list[-1].ID, i] shared_memory_comm_time = int(c_vol / memory_to_PE_band) PE_comm_wait_times.append(shared_memory_comm_time) if self.args.verbose: print('[D] Time %s: Estimated communication time between ' 'memory to PE %s from task %s to task %s is %d' % (self.env.now(), i, real_predecessor_ID, task.ID, PE_comm_wait_times[-1])) # PE_to_PE else: # Compute the PE to PE communication time PE_to_PE_band = self.env.resource_matrix.comm_band[predecessor_PE_ID, i] PE_to_PE_comm_time = int(c_vol / PE_to_PE_band) PE_comm_wait_times.append(max((predecessor_finish_time + PE_to_PE_comm_time - self.env.now()), 0)) if self.args.verbose: print('[D] Time %s: Estimated communication time between PE %s to PE' ' %s from task %s to task %s is %d' % (self.env.now(), predecessor_PE_ID, i, real_predecessor_ID, task.ID, PE_comm_wait_times[-1])) # $comm_ready contains the estimated communication time # for the resource in consideration for scheduling # maximum value is chosen since it represents the time required for all # data becomes available for the resource. comm_ready[i] = (max(PE_comm_wait_times)) # end of for for predecessor in self.jobs.list[job_ID].task_list[ind].predecessors: # if a resource currently is executing a task, then the estimated remaining time # for the task completion should be considered during scheduling PE_wait_time.append(max((self.env.pes[i].available_time - self.env.now()), 0)) # update the comparison vector accordingly comparison[i] = self.env.resource_matrix_list[i].performance[ind] \ + max(comm_ready[i], PE_wait_time[-1]) # end of if (task.name in... # end of for i in range(len(self.env.resource_matrix_list)): # after going over each resource, choose the one which gives the minimum result task_PE_ID = comparison.index(min(comparison)) # Finally, update the estimated available time of the resource to which # a task is just assigned self.env.pes[task_PE_ID].available_time = self.env.now() + comparison[task_PE_ID] scheduled_tasks[task.ID] = (task_PE_ID, idx, []) return scheduled_tasks class ETF(object): def __init__(self, env): super(ETF, self).__init__(env) self.args = self.env.args def schedule(self, state): env_storage = self.env.env_storage ready_list = copy.deepcopy(env_storage.TaskQueues.ready.list) task_counter = 0 scheduled_tasks = {} # Iterate through the list of ready tasks until all of them are scheduled while len(ready_list) > 0: shortest_task_exec_time = np.inf shortest_task_pe_id = -1 shortest_comparison = [np.inf] * len(self.env.pes) for task in ready_list: comparison = [np.inf] * len(self.env.pes) # Initialize the comparison vector comm_ready = [0] * len(self.env.pes) # A list to store the max communication times for each PE if self.args.verbose: print('[D] Time %s: The scheduler function is called with task %s' % (self.env.now(), task.ID)) for i in range(len(self.env.resource_matrix_list)): # if the task is supported by the resource, retrieve the index of the task if task.name in self.env.resource_matrix_list[i].supported_functionalities: ind = self.env.resource_matrix_list[i].supported_functionalities.index(task.name) # $PE_comm_wait_times is a list to store the estimated communication time # (or the remaining communication time) of all predecessors of a task for a PE # As simulation forwards, relevant data is being sent after a task is completed # based on the time instance, one should consider either whole communication # time or the remaining communication time for scheduling PE_comm_wait_times = [] # $PE_wait_time is a list to store the estimated wait times for a PE # till that PE is available if the PE is currently running a task PE_wait_time = [] job_ID = -1 # Initialize the job ID # Retrieve the job ID which the current task belongs to for ii, job in enumerate(self.env.jobs.list): if job.name == task.jobname: job_ID = ii for predecessor in self.env.jobs.list[job_ID].task_list[task.base_ID].predecessors: # data required from the predecessor for $ready_task c_vol = self.env.jobs.list[job_ID].comm_vol[predecessor, task.base_ID] # retrieve the real
company_id, customer_payment_journal_id, if_match=None): return client.delete_customer_payment_journals(company_id=company_id, customer_payment_journal_id=customer_payment_journal_id, if_match=if_match) def financials_financial_company_delete_dimension(client, company_id, dimension_id, if_match=None): return client.delete_dimensions(company_id=company_id, dimension_id=dimension_id, if_match=if_match) def financials_financial_company_delete_dimension_value(client, company_id, dimension_value_id, if_match=None): return client.delete_dimension_values(company_id=company_id, dimension_value_id=dimension_value_id, if_match=if_match) def financials_financial_company_delete_employee(client, company_id, employee_id, if_match=None): return client.delete_employees(company_id=company_id, employee_id=employee_id, if_match=if_match) def financials_financial_company_delete_general_ledger_entry(client, company_id, general_ledger_entry_id, if_match=None): return client.delete_general_ledger_entries(company_id=company_id, general_ledger_entry_id=general_ledger_entry_id, if_match=if_match) def financials_financial_company_delete_item(client, company_id, item_id, if_match=None): return client.delete_items(company_id=company_id, item_id=item_id, if_match=if_match) def financials_financial_company_delete_item_category(client, company_id, item_category_id, if_match=None): return client.delete_item_categories(company_id=company_id, item_category_id=item_category_id, if_match=if_match) def financials_financial_company_delete_journal(client, company_id, journal_id, if_match=None): return client.delete_journals(company_id=company_id, journal_id=journal_id, if_match=if_match) def financials_financial_company_delete_journal_line(client, company_id, journal_line_id, if_match=None): return client.delete_journal_lines(company_id=company_id, journal_line_id=journal_line_id, if_match=if_match) def financials_financial_company_delete_payment_method(client, company_id, payment_method_id, if_match=None): return client.delete_payment_methods(company_id=company_id, payment_method_id=payment_method_id, if_match=if_match) def financials_financial_company_delete_payment_term(client, company_id, payment_term_id, if_match=None): return client.delete_payment_terms(company_id=company_id, payment_term_id=payment_term_id, if_match=if_match) def financials_financial_company_delete_picture(client, company_id, picture_id, if_match=None): return client.delete_picture(company_id=company_id, picture_id=picture_id, if_match=if_match) def financials_financial_company_delete_purchase_invoice(client, company_id, purchase_invoice_id, if_match=None): return client.delete_purchase_invoices(company_id=company_id, purchase_invoice_id=purchase_invoice_id, if_match=if_match) def financials_financial_company_delete_purchase_invoice_line(client, company_id, purchase_invoice_line_id, if_match=None): return client.delete_purchase_invoice_lines(company_id=company_id, purchase_invoice_line_id=purchase_invoice_line_id, if_match=if_match) def financials_financial_company_delete_sale_credit_memo(client, company_id, sales_credit_memo_id, if_match=None): return client.delete_sales_credit_memos(company_id=company_id, sales_credit_memo_id=sales_credit_memo_id, if_match=if_match) def financials_financial_company_delete_sale_credit_memo_line(client, company_id, sales_credit_memo_line_id, if_match=None): return client.delete_sales_credit_memo_lines(company_id=company_id, sales_credit_memo_line_id=sales_credit_memo_line_id, if_match=if_match) def financials_financial_company_delete_sale_invoice(client, company_id, sales_invoice_id, if_match=None): return client.delete_sales_invoices(company_id=company_id, sales_invoice_id=sales_invoice_id, if_match=if_match) def financials_financial_company_delete_sale_invoice_line(client, company_id, sales_invoice_line_id, if_match=None): return client.delete_sales_invoice_lines(company_id=company_id, sales_invoice_line_id=sales_invoice_line_id, if_match=if_match) def financials_financial_company_delete_sale_order(client, company_id, sales_order_id, if_match=None): return client.delete_sales_orders(company_id=company_id, sales_order_id=sales_order_id, if_match=if_match) def financials_financial_company_delete_sale_order_line(client, company_id, sales_order_line_id, if_match=None): return client.delete_sales_order_lines(company_id=company_id, sales_order_line_id=sales_order_line_id, if_match=if_match) def financials_financial_company_delete_sale_quote(client, company_id, sales_quote_id, if_match=None): return client.delete_sales_quotes(company_id=company_id, sales_quote_id=sales_quote_id, if_match=if_match) def financials_financial_company_delete_sale_quote_line(client, company_id, sales_quote_line_id, if_match=None): return client.delete_sales_quote_lines(company_id=company_id, sales_quote_line_id=sales_quote_line_id, if_match=if_match) def financials_financial_company_delete_shipment_method(client, company_id, shipment_method_id, if_match=None): return client.delete_shipment_methods(company_id=company_id, shipment_method_id=shipment_method_id, if_match=if_match) def financials_financial_company_delete_tax_area(client, company_id, tax_area_id, if_match=None): return client.delete_tax_areas(company_id=company_id, tax_area_id=tax_area_id, if_match=if_match) def financials_financial_company_delete_tax_group(client, company_id, tax_group_id, if_match=None): return client.delete_tax_groups(company_id=company_id, tax_group_id=tax_group_id, if_match=if_match) def financials_financial_company_delete_unit_of_measure(client, company_id, unit_of_measure_id, if_match=None): return client.delete_units_of_measure(company_id=company_id, unit_of_measure_id=unit_of_measure_id, if_match=if_match) def financials_financial_company_delete_vendor(client, company_id, vendor_id, if_match=None): return client.delete_vendors(company_id=company_id, vendor_id=vendor_id, if_match=if_match) def financials_financial_company_list_account(client, company_id, orderby=None, select=None, expand=None): return client.list_accounts(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_aged_account_payable(client, company_id, orderby=None, select=None, expand=None): return client.list_aged_accounts_payable(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_aged_account_receivable(client, company_id, orderby=None, select=None, expand=None): return client.list_aged_accounts_receivable(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_company_information(client, company_id, orderby=None, select=None, expand=None): return client.list_company_information(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_country_region(client, company_id, orderby=None, select=None, expand=None): return client.list_countries_regions(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_currency(client, company_id, orderby=None, select=None, expand=None): return client.list_currencies(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_customer(client, company_id, orderby=None, select=None, expand=None): return client.list_customers(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_customer_payment(client, company_id, orderby=None, select=None, expand=None): return client.list_customer_payments(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_customer_payment_journal(client, company_id, orderby=None, select=None, expand=None): return client.list_customer_payment_journals(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_dimension(client, company_id, orderby=None, select=None, expand=None): return client.list_dimensions(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_dimension_value(client, company_id, orderby=None, select=None, expand=None): return client.list_dimension_values(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_employee(client, company_id, orderby=None, select=None, expand=None): return client.list_employees(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_general_ledger_entry(client, company_id, orderby=None, select=None, expand=None): return client.list_general_ledger_entries(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_item(client, company_id, orderby=None, select=None, expand=None): return client.list_items(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_item_category(client, company_id, orderby=None, select=None, expand=None): return client.list_item_categories(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_journal(client, company_id, orderby=None, select=None, expand=None): return client.list_journals(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_journal_line(client, company_id, orderby=None, select=None, expand=None): return client.list_journal_lines(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_payment_method(client, company_id, orderby=None, select=None, expand=None): return client.list_payment_methods(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_payment_term(client, company_id, orderby=None, select=None, expand=None): return client.list_payment_terms(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_picture(client, company_id, orderby=None, select=None, expand=None): return client.list_picture(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_purchase_invoice(client, company_id, orderby=None, select=None, expand=None): return client.list_purchase_invoices(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_purchase_invoice_line(client, company_id, orderby=None, select=None, expand=None): return client.list_purchase_invoice_lines(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_sale_credit_memo(client, company_id, orderby=None, select=None, expand=None): return client.list_sales_credit_memos(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_sale_credit_memo_line(client, company_id, orderby=None, select=None, expand=None): return client.list_sales_credit_memo_lines(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_sale_invoice(client, company_id, orderby=None, select=None, expand=None): return client.list_sales_invoices(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_sale_invoice_line(client, company_id, orderby=None, select=None, expand=None): return client.list_sales_invoice_lines(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_sale_order(client, company_id, orderby=None, select=None, expand=None): return client.list_sales_orders(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_sale_order_line(client, company_id, orderby=None, select=None, expand=None): return client.list_sales_order_lines(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_sale_quote(client, company_id, orderby=None, select=None, expand=None): return client.list_sales_quotes(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_sale_quote_line(client, company_id, orderby=None, select=None, expand=None): return client.list_sales_quote_lines(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_shipment_method(client, company_id, orderby=None, select=None, expand=None): return client.list_shipment_methods(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_tax_area(client, company_id, orderby=None, select=None, expand=None): return client.list_tax_areas(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_tax_group(client, company_id, orderby=None, select=None, expand=None): return client.list_tax_groups(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_unit_of_measure(client, company_id, orderby=None, select=None, expand=None): return client.list_units_of_measure(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_list_vendor(client, company_id, orderby=None, select=None, expand=None): return client.list_vendors(company_id=company_id, orderby=orderby, select=select, expand=expand) def financials_financial_company_set_company_information_picture(client, company_id, company_information_id, data): return client.set_company_information_picture(company_id=company_id, company_information_id=company_information_id, data=data) def financials_financial_company_set_picture_content(client, company_id, picture_id, data): return client.set_picture_content(company_id=company_id, picture_id=picture_id, data=data) def financials_financial_company_show_account(client, company_id, account_id, select=None, expand=None): return client.get_accounts(company_id=company_id, account_id=account_id, select=select, expand=expand) def financials_financial_company_show_aged_account_payable(client, company_id, aged_accounts_payable_id, select=None, expand=None): return client.get_aged_accounts_payable(company_id=company_id, aged_accounts_payable_id=aged_accounts_payable_id, select=select, expand=expand) def financials_financial_company_show_aged_account_receivable(client, company_id, aged_accounts_receivable_id, select=None, expand=None): return client.get_aged_accounts_receivable(company_id=company_id, aged_accounts_receivable_id=aged_accounts_receivable_id, select=select, expand=expand) def financials_financial_company_show_company_information(client, company_id, company_information_id, select=None, expand=None): return client.get_company_information(company_id=company_id, company_information_id=company_information_id, select=select, expand=expand) def financials_financial_company_show_company_information_picture(client, company_id, company_information_id): return client.get_company_information_picture(company_id=company_id, company_information_id=company_information_id) def financials_financial_company_show_country_region(client, company_id, country_region_id, select=None, expand=None): return client.get_countries_regions(company_id=company_id, country_region_id=country_region_id, select=select, expand=expand) def financials_financial_company_show_currency(client, company_id, currency_id, select=None, expand=None): return client.get_currencies(company_id=company_id, currency_id=currency_id, select=select, expand=expand) def financials_financial_company_show_customer(client, company_id, customer_id, select=None, expand=None): return client.get_customers(company_id=company_id, customer_id=customer_id, select=select, expand=expand) def financials_financial_company_show_customer_payment(client, company_id, customer_payment_id, select=None, expand=None): return client.get_customer_payments(company_id=company_id, customer_payment_id=customer_payment_id, select=select, expand=expand) def financials_financial_company_show_customer_payment_journal(client, company_id, customer_payment_journal_id, select=None, expand=None): return client.get_customer_payment_journals(company_id=company_id, customer_payment_journal_id=customer_payment_journal_id, select=select, expand=expand) def financials_financial_company_show_dimension(client, company_id, dimension_id, select=None, expand=None): return client.get_dimensions(company_id=company_id, dimension_id=dimension_id, select=select, expand=expand) def financials_financial_company_show_dimension_value(client, company_id, dimension_value_id, select=None, expand=None): return client.get_dimension_values(company_id=company_id, dimension_value_id=dimension_value_id, select=select, expand=expand) def financials_financial_company_show_employee(client, company_id, employee_id, select=None, expand=None): return client.get_employees(company_id=company_id, employee_id=employee_id, select=select, expand=expand) def financials_financial_company_show_general_ledger_entry(client, company_id, general_ledger_entry_id, select=None, expand=None): return client.get_general_ledger_entries(company_id=company_id, general_ledger_entry_id=general_ledger_entry_id, select=select, expand=expand) def financials_financial_company_show_item(client, company_id, item_id, select=None, expand=None): return client.get_items(company_id=company_id, item_id=item_id, select=select, expand=expand) def financials_financial_company_show_item_category(client, company_id, item_category_id, select=None, expand=None): return client.get_item_categories(company_id=company_id, item_category_id=item_category_id, select=select, expand=expand) def financials_financial_company_show_journal(client, company_id, journal_id, select=None, expand=None): return client.get_journals(company_id=company_id, journal_id=journal_id, select=select, expand=expand) def financials_financial_company_show_journal_line(client, company_id, journal_line_id, select=None, expand=None): return client.get_journal_lines(company_id=company_id, journal_line_id=journal_line_id, select=select, expand=expand) def financials_financial_company_show_payment_method(client, company_id, payment_method_id, select=None, expand=None): return client.get_payment_methods(company_id=company_id, payment_method_id=payment_method_id, select=select, expand=expand) def financials_financial_company_show_payment_term(client, company_id, payment_term_id, select=None, expand=None): return client.get_payment_terms(company_id=company_id, payment_term_id=payment_term_id, select=select, expand=expand) def financials_financial_company_show_picture(client, company_id, picture_id, select=None, expand=None): return client.get_picture(company_id=company_id, picture_id=picture_id, select=select, expand=expand) def financials_financial_company_show_picture_content(client, company_id, picture_id): return client.get_picture_content(company_id=company_id, picture_id=picture_id) def financials_financial_company_show_purchase_invoice(client, company_id, purchase_invoice_id, select=None, expand=None): return client.get_purchase_invoices(company_id=company_id, purchase_invoice_id=purchase_invoice_id, select=select, expand=expand) def financials_financial_company_show_purchase_invoice_line(client, company_id, purchase_invoice_line_id, select=None, expand=None): return client.get_purchase_invoice_lines(company_id=company_id, purchase_invoice_line_id=purchase_invoice_line_id, select=select, expand=expand) def financials_financial_company_show_sale_credit_memo(client, company_id, sales_credit_memo_id, select=None, expand=None): return client.get_sales_credit_memos(company_id=company_id, sales_credit_memo_id=sales_credit_memo_id, select=select, expand=expand) def financials_financial_company_show_sale_credit_memo_line(client, company_id, sales_credit_memo_line_id, select=None, expand=None): return client.get_sales_credit_memo_lines(company_id=company_id, sales_credit_memo_line_id=sales_credit_memo_line_id, select=select, expand=expand) def financials_financial_company_show_sale_invoice(client, company_id, sales_invoice_id, select=None, expand=None): return client.get_sales_invoices(company_id=company_id, sales_invoice_id=sales_invoice_id, select=select, expand=expand) def financials_financial_company_show_sale_invoice_line(client, company_id, sales_invoice_line_id, select=None, expand=None): return client.get_sales_invoice_lines(company_id=company_id, sales_invoice_line_id=sales_invoice_line_id, select=select, expand=expand) def financials_financial_company_show_sale_order(client, company_id, sales_order_id, select=None, expand=None): return client.get_sales_orders(company_id=company_id, sales_order_id=sales_order_id, select=select, expand=expand) def financials_financial_company_show_sale_order_line(client, company_id, sales_order_line_id, select=None, expand=None): return client.get_sales_order_lines(company_id=company_id, sales_order_line_id=sales_order_line_id, select=select, expand=expand) def financials_financial_company_show_sale_quote(client, company_id, sales_quote_id, select=None, expand=None): return client.get_sales_quotes(company_id=company_id, sales_quote_id=sales_quote_id, select=select, expand=expand) def financials_financial_company_show_sale_quote_line(client, company_id, sales_quote_line_id, select=None, expand=None): return client.get_sales_quote_lines(company_id=company_id, sales_quote_line_id=sales_quote_line_id, select=select, expand=expand) def financials_financial_company_show_shipment_method(client, company_id, shipment_method_id, select=None, expand=None): return client.get_shipment_methods(company_id=company_id, shipment_method_id=shipment_method_id, select=select, expand=expand) def financials_financial_company_show_tax_area(client, company_id, tax_area_id, select=None, expand=None): return client.get_tax_areas(company_id=company_id, tax_area_id=tax_area_id, select=select, expand=expand) def financials_financial_company_show_tax_group(client, company_id, tax_group_id, select=None, expand=None): return client.get_tax_groups(company_id=company_id, tax_group_id=tax_group_id, select=select, expand=expand) def financials_financial_company_show_unit_of_measure(client, company_id, unit_of_measure_id, select=None, expand=None): return client.get_units_of_measure(company_id=company_id, unit_of_measure_id=unit_of_measure_id, select=select, expand=expand) def financials_financial_company_show_vendor(client, company_id, vendor_id, select=None, expand=None): return client.get_vendors(company_id=company_id, vendor_id=vendor_id, select=select, expand=expand) def financials_financial_company_update_account(client, company_id, account_id, id_=None, blocked=None, category=None, display_name=None, last_modified_date_time=None, number=None, sub_category=None): body = {} body['id'] = id_ body['blocked'] = blocked body['category'] = category body['display_name'] = display_name body['last_modified_date_time'] = last_modified_date_time body['number'] = number body['sub_category'] = sub_category return client.update_accounts(company_id=company_id, account_id=account_id, body=body) def financials_financial_company_update_aged_account_payable(client, company_id, aged_accounts_payable_id, id_=None, aged_as_of_date=None, balance_due=None, currency_code=None, current_amount=None, name=None, period1_amount=None, period2_amount=None, period3_amount=None, period_length_filter=None, vendor_number=None): body = {} body['id'] = id_ body['aged_as_of_date'] = aged_as_of_date body['balance_due'] = balance_due body['currency_code'] = currency_code body['current_amount'] = current_amount body['name'] = name body['period1_amount'] = period1_amount body['period2_amount'] = period2_amount body['period3_amount'] = period3_amount body['period_length_filter'] = period_length_filter body['vendor_number'] = vendor_number return client.update_aged_accounts_payable(company_id=company_id, aged_accounts_payable_id=aged_accounts_payable_id, body=body) def financials_financial_company_update_aged_account_receivable(client, company_id, aged_accounts_receivable_id, id_=None, aged_as_of_date=None, balance_due=None, currency_code=None, current_amount=None, customer_number=None, name=None, period1_amount=None, period2_amount=None, period3_amount=None, period_length_filter=None): body = {} body['id'] = id_ body['aged_as_of_date'] = aged_as_of_date body['balance_due'] = balance_due body['currency_code'] = currency_code body['current_amount'] = current_amount body['customer_number'] = customer_number body['name'] = name body['period1_amount'] = period1_amount body['period2_amount'] = period2_amount body['period3_amount'] = period3_amount body['period_length_filter'] = period_length_filter return client.update_aged_accounts_receivable(company_id=company_id, aged_accounts_receivable_id=aged_accounts_receivable_id, body=body) def financials_financial_company_update_company_information(client, company_id, company_information_id, id_=None, address=None, currency_code=None, current_fiscal_year_start_date=None, display_name=None, email=None, fax_number=None, industry=None, last_modified_date_time=None, phone_number=None, picture=None, tax_registration_number=None, website=None): body = {} body['id'] = id_ body['address'] = address body['currency_code'] = currency_code body['current_fiscal_year_start_date'] = current_fiscal_year_start_date body['display_name'] = display_name body['email'] = email body['fax_number'] = fax_number body['industry'] = industry body['last_modified_date_time'] = last_modified_date_time body['phone_number'] = phone_number body['picture'] = picture body['tax_registration_number'] = tax_registration_number body['website'] = website return client.update_company_information(company_id=company_id, company_information_id=company_information_id, body=body) def financials_financial_company_update_country_region(client, company_id, country_region_id, id_=None, address_format=None, code=None, display_name=None, last_modified_date_time=None): body = {} body['id'] = id_ body['address_format'] = address_format body['code'] = code body['display_name'] = display_name body['last_modified_date_time'] = last_modified_date_time return client.update_countries_regions(company_id=company_id, country_region_id=country_region_id, body=body) def financials_financial_company_update_currency(client, company_id, currency_id, id_=None, amount_decimal_places=None, amount_rounding_precision=None, code=None, display_name=None, last_modified_date_time=None, symbol=None): body = {} body['id'] = id_ body['amount_decimal_places'] = amount_decimal_places body['amount_rounding_precision'] = amount_rounding_precision body['code'] = code body['display_name'] = display_name body['last_modified_date_time'] = last_modified_date_time body['symbol'] = symbol return client.update_currencies(company_id=company_id, currency_id=currency_id, body=body) def financials_financial_company_update_customer(client, company_id, customer_id, id_=None, address=None, blocked=None, currency_code=None, currency_id=None, display_name=None, email=None, last_modified_date_time=None, number=None, payment_method_id=None, payment_terms_id=None, phone_number=None, shipment_method_id=None, tax_area_display_name=None, tax_area_id=None, tax_liable=None, tax_registration_number=None, type_=None, website=None, currency=None, payment_method=None, payment_term=None, picture=None, shipment_method=None): body = {} body['id'] = id_ body['address'] = address body['blocked'] = blocked body['currency_code'] = currency_code body['currency_id'] = currency_id body['display_name'] = display_name body['email'] = email body['last_modified_date_time'] = last_modified_date_time body['number'] = number body['payment_method_id'] = payment_method_id body['payment_terms_id']
# constant grid for ROC fpr_grid = np.linspace(0, 1, num=20) # get class scores class_score = PyPLS.predict(self, x=x) # binery classification if n_classes == 2: y_pred = self.predict(x) accuracy = metrics.accuracy_score(y, y_pred) precision = metrics.precision_score(y, y_pred) recall = metrics.recall_score(y, y_pred) misclassified_samples = np.where(y.ravel() != y_pred.ravel())[0] f1_score = metrics.f1_score(y, y_pred) conf_matrix = metrics.confusion_matrix(y, y_pred) zero_oneloss = metrics.zero_one_loss(y, y_pred) matthews_mcc = metrics.matthews_corrcoef(y, y_pred) # Interpolated ROC curve and AUC roc_curve = metrics.roc_curve(y, class_score.ravel()) tpr = roc_curve[1] fpr = roc_curve[0] interpolated_tpr = np.zeros_like(fpr_grid) interpolated_tpr += interp(fpr_grid, fpr, tpr) roc_curve = (fpr_grid, interpolated_tpr, roc_curve[2]) auc_area = metrics.auc(fpr_grid, interpolated_tpr) else: # multi class classification y_pred = self.predict(x) accuracy = metrics.accuracy_score(y, y_pred) precision = metrics.precision_score(y, y_pred, average='weighted') recall = metrics.recall_score(y, y_pred, average='weighted') misclassified_samples = np.where(y.ravel() != y_pred.ravel())[0] f1_score = metrics.f1_score(y, y_pred, average='weighted') conf_matrix = metrics.confusion_matrix(y, y_pred) zero_oneloss = metrics.zero_one_loss(y, y_pred) matthews_mcc = np.nan roc_curve = list() auc_area = list() # Generate multiple ROC curves - one for each class the multiple class case for predclass in range(self.n_classes): current_roc = metrics.roc_curve(y, class_score[:, predclass], pos_label=predclass) # Interpolate all ROC curves to a finite grid # Makes it easier to average and compare multiple models - with CV in mind tpr = current_roc[1] fpr = current_roc[0] interpolated_tpr = np.zeros_like(fpr_grid) interpolated_tpr += interp(fpr_grid, fpr, tpr) roc_curve.append([fpr_grid, interpolated_tpr, current_roc[2]]) auc_area.append(metrics.auc(fpr_grid, interpolated_tpr)) # Obtain residual sum of squares for whole data set and per component # Same as Chemometrics PLS, this is so we can use VIP's and other metrics as usual if self.n_classes > 2: cm_fit = self.cummulativefit(x, dummy_mat) else: cm_fit = self.cummulativefit(x, y) # save the model params self.m_params = {'PLS': {'R2Y': R2Y, 'R2X': R2X, 'SSX': cm_fit['SSX'], 'SSY': cm_fit['SSY'], 'SSXcomp': cm_fit['SSXcomp'], 'SSYcomp': cm_fit['SSYcomp']}, 'DA': {'Accuracy': accuracy, 'AUC': auc_area, 'ConfusionMatrix': conf_matrix, 'ROC': roc_curve, 'MisclassifiedSamples': misclassified_samples, 'Precision': precision, 'Recall': recall, 'F1': f1_score, '0-1Loss': zero_oneloss, 'MatthewsMCC': matthews_mcc, 'ClassPredictions': y_pred}} except ValueError as verr: raise verr def score(self, x, y, sample_weight=None): """ Predict and calculate the R2 for the model using one of the data blocks (X or Y) provided. Equivalent to the scikit-learn ClassifierMixin score method. :param x: Data matrix to fit the PLS model. :type x: numpy.ndarray, shape (rows : samples , columns : variables ) :param y: target variable :type y: list or 1d array :param str block_to_score: Which of the data blocks (X or Y) to calculate the R2 goodness of fit. :param sample_weight: Optional sample weights to use in scoring. :type sample_weight: numpy.ndarray, shape [n_samples] or None defaults to None :return R2Y: The model's R2Y, calculated by predicting Y from X and scoring. :rtype: float :return R2X: The model's R2X, calculated by predicting X from Y and scoring. :rtype: float :raise ValueError: If block to score argument is not acceptable or date mismatch issues with the provided data. """ try: # return metrics.accuracy_score(y, self.predict(x), sample_weight=sample_weight) return PyPLS.score(self, x, y, block_to_score='x') except ValueError as verr: raise verr def predict(self, x): """ predict the value of the target variable based on predictive variable x :param x: data metrix to be fit :type x: numpy.ndarray, shape (rows : samples , columns : variables ) :param y: target variable :type y: list or 1d array :return: Predicted data block Y by as discret values using argmin :rtype: numpy.ndarray, shape (n_samples, n_features) :raise ValueError: If no data matrix is passed, or dimensions mismatch issues with the provided data. :raise AttributeError: Calling the method without fitting the model before. """ try: if self.isfitted is False: raise AttributeError("Model is not fitted") # based on original encoding as 0, 1 (binery classification ) if self.n_classes == 2: y_pred = PyPLS.predict(self, x) class_pred = np.argmin(np.abs(y_pred - np.array([0, 1])), axis=1) else: # multiclass classification pred_scores = self.transform(x=x) # encode the predicted variable closest_class_mean = lambda x: np.argmin(np.linalg.norm((x - self.class_means), axis=1)) class_pred = np.apply_along_axis(closest_class_mean, axis=1, arr=pred_scores) return class_pred except ValueError as verr: raise verr except AttributeError as atter: raise atter def inverse_transform(self, t=None, u=None): """ transform T and U scores to get X and Y :param t: T scores corresponding to the X data matrix. defaults to None :type numpy array :param u: Y scores corresponding to the Y data vector/matrix defaults to None :type numpy array :return x: data metrix to be fit (rows : samples , columns : variables ) :return y: depentent variable or target variable :rtype: numpy.ndarray, shape (n_samples, n_features) or None :raise ValueError: If dimensions of input data are mismatched. """ try: if self.isfitted is True: if t is not None and u is not None: raise ValueError('T or U scores must be set to None ') elif t is None and u is None: raise ValueError('T and U cant be both None ') # If T is given, return U elif t is not None: # calculate x prediction xpred = np.dot(t, self.loadings_p.T) if self.x_scaler is not None: xscaled = self.x_scaler.inverse_transform(xpred) else: xscaled = xpred return xscaled # If U is given, return T elif u is not None: # calculate y bases on loading transpose ypred = np.dot(u, self.loadings_q.T) return ypred except ValueError as verr: raise verr def transform(self, x=None, y=None): """ calculate U or T metrix equivalent to sklearn TransformeMixin :param x: data metrix to be fit :type x: numpy.ndarray, shape (rows : samples , columns : variables ) :param y: target variable :type y: list or 1d array :return: Latent Variable scores (T) for the X matrix and for the Y vector/matrix (U). :rtype: tuple with 2 numpy.ndarray, shape (n_samples, n_comps) :raise ValueError: If dimensions of input data are mismatched. :raise AttributeError: When calling the method before the model is fitted. """ try: # Check if model is fitted or not if self.isfitted is True: # If X and Y are passed, complain and do nothing if (x is not None) and (y is not None): raise ValueError('one of the variable must be None') # If nothing is passed at all, complain and do nothing elif (x is None) and (y is None): raise ValueError('both variables are set to None') # If Y is given, return U elif x is None: # verify that y is a single vector if y.ndim != 1: raise TypeError('Please supply a dummy vector with integer as class membership') # muticlass classification if self.n_classes > 2: y = self.y_scaler.transform(pd.get_dummies(y).values) else: # binery classification if y.ndim == 1: y = y.reshape(-1, 1) y = self.y_scaler.transform(y) U = np.dot(y, self.rotations_cs) return U # If X is given, return T elif y is None: # add extra dimention to x if its a vector if x.ndim == 1: x = x.reshape(-1, 1) if self.x_scaler == None: xscaled = x else: xscaled = self.x_scaler.fit_transform(x) T = np.dot(xscaled, self.rotations_ws) return T else: raise AttributeError('Model not fitted yet ') except ValueError as verr: raise verr except AttributeError as atter: raise atter def cross_validation(self, x, y, cv_method=KFold(7, shuffle=True), outputdist=False, ): """ cross validation result of the model and calculate Q2 :param x: data metrix to be fit :type x: numpy.ndarray, shape (rows : samples , columns : variables ) :param y: target varibale :type y: list or 1d array :param cv_method: cross valiation method :param bool outputdist: Output the whole distribution for. Useful when ShuffleSplit or CrossValidators other than KFold defaults to false :return: dict of cross validation scores :rtype dict :raise TypeError: If the cv_method passed is not a scikit-learn CrossValidator object. :raise ValueError: If the x and y data matrices are invalid. """ try: # Check if global model is fitted... and if not, fit it using all of X if self.isfitted is False: self.fit(x, y) # Make a copy of the object, to ensure the internal state of the object is not modified during # the cross_validation method call cv_pipeline = deepcopy(self) # Number of splits ncvrounds = cv_method.get_n_splits() # Number of classes
import random import re import math import numpy as np from src import constants from src.multi_agent.elements.camera import Camera, CameraRepresentation from src.my_utils import constant_class from src.my_utils.my_math.bound import bound_angle_btw_minus_pi_plus_pi, bound from src.my_utils.my_math.line import distance_btw_two_point, Line from src.my_utils.string_operations import parse_list class MobileCameraType: """ Camera types dof = degree of freedom 1) FIX -- 1 dof beta 2) ROTATIVE -- 2 dof beta,alpha 3) RAIL -- 3 dof beta,alpha,(x,y)=f(s) 4) FREE -- 4 dof beta,alpha,x,y """ FIX = 0 ROTATIVE = 1 RAIL = 2 FREE = 3 class MobileCameraRepresentation(CameraRepresentation): """ Class MobileCameraRepresentation. Description : :param 8. (MobileCameraType) camera_type -- describe what feature the camera has 9. (Trajectory) trajectory -- only used for RAIL camera :attibutes 8. (MobileCameraType) camera_type -- describe what feature the camera has 9. (Trajectory) trajectory -- only used for RAIL camera """ def __init__(self, id=None, xc=None, yc=None, alpha=None, beta=None, field_depth=None, type=None, color=None): CameraRepresentation.__init__(self, id, xc, yc, alpha, beta, field_depth, color) self.camera_type = type self.trajectory = TrajectoryPlaner([]) def update_from_camera(self, camera): super().update_from_camera(camera) self.camera_type = camera.camera_type self.trajectory = TrajectoryPlaner(camera.trajectory.trajectory) class MobileCamera(Camera, MobileCameraRepresentation): """ Class MobileCameraRepresentation. Description : :param :attibutes """ def __init__(self, id=None, xc=None, yc=None, alpha=None, beta=None, trajectory=None, field_depth=None, color=None, t_add=None, t_del=None, type=None, vx_vy_min=None, vx_vy_max=None, v_alpha_min=None, v_alpha_max=None, delta_beta=None, v_beta_min=None, v_beta_max=None): Camera.__init__(self, id, xc, yc, alpha, beta, field_depth, color, t_add, t_del) camera_attributes_not_to_txt = self.attributes_not_to_txt MobileCameraRepresentation.__init__(self, id, xc, yc, alpha, beta, field_depth, type, color) self.attributes_not_to_txt += [elem for elem in camera_attributes_not_to_txt if elem not in self.attributes_not_to_txt] self.attributes_not_to_txt += ["coeff_field", "coeff_std_position", "coeff_std_speed", "coeff_std_acc", "swipe_angle_direction", "swipe_delta_alpha", "last_swipe_direction_change", "dt_next_swipe_direction_change", "last_swipe_configuration", "last_swipe_position_change","beta_min","beta_max"] """Limit the variation""" self.vx_vy_min = vx_vy_min self.vx_vy_max = vx_vy_max self.v_alpha_min = v_alpha_min self.v_alpha_max = v_alpha_max self.v_beta_min = v_beta_min self.v_beta_max = v_beta_max self.delta_beta = delta_beta """Zoom""" self.coeff_field = constants.COEFF_VARIATION_FROM_FIELD_DEPTH self.coeff_std_position = constants.COEFF_STD_VARIATION_MEASURMENT_ERROR_POSITION self.coeff_std_speed = constants.COEFF_STD_VARIATION_MEASURMENT_ERROR_SPEED self.coeff_std_acc = constants.COEFF_STD_VARIATION_MEASURMENT_ERROR_ACCELERATION """Trajectory""" self.trajectory = TrajectoryPlaner(trajectory) """Variables for the swipe""" self.swipe_angle_direction = 1 self.swipe_delta_alpha = 0.2 self.last_swipe_direction_change = constants.get_time() self.dt_next_swipe_direction_change = -10 self.last_swipe_position_change = -10 from src.multi_agent.tools.configuration import Configuration self.last_swipe_configuration = Configuration(None, None, random.uniform(0, constants.ROOM_DIMENSION_X), random.uniform(0, constants.ROOM_DIMENSION_Y), 1, 1, self.field_depth, False) self.default_parameters() def default_parameters(self): """Default option""" if not self.camera_type == MobileCameraType.RAIL: self.trajectory = TrajectoryPlaner([]) if self.camera_type == MobileCameraType.FIX or self.camera_type == MobileCameraType.ROTATIVE: self.vx_vy_min = 0 self.vx_vy_max = 0 if self.camera_type == MobileCameraType.FIX: self.v_alpha_min = 0 self.v_alpha_max = 0 if self.delta_beta is not None and self.beta is not None: self.beta_min = bound_angle_btw_minus_pi_plus_pi(self.beta - self.delta_beta) self.beta_max = bound_angle_btw_minus_pi_plus_pi(self.beta + self.delta_beta) else: self.beta_min = None self.beta_max = None def angle_degToRad(self): """ :description Transforms angle attribues to radians supposing it is in degree """ super().angle_degToRad() if self.delta_beta is not None: self.delta_beta = math.radians(self.delta_beta) if self.beta_min is not None: self.beta_min = math.radians(self.beta_min) if self.beta_max is not None: self.beta_max = math.radians(self.beta_max) self.v_alpha_min = math.radians(self.v_alpha_min) self.v_alpha_max = math.radians(self.v_alpha_max) self.v_beta_min = math.radians(self.v_beta_min) self.v_beta_max = math.radians(self.v_beta_max) def angle_radToDeg(self): """ :description Transforms angle attribues to degrees supposing it is in radians """ super().angle_radToDeg() if self.delta_beta is not None: self.delta_beta = math.degrees(self.delta_beta) if self.beta_min is not None: self.beta_min = math.degrees(self.beta_min) if self.beta_max is not None: self.beta_max = math.degrees(self.beta_max) self.v_alpha_min = math.degrees(self.v_alpha_min) self.v_alpha_max = math.degrees(self.v_alpha_max) self.v_beta_min = math.degrees(self.v_beta_min) self.v_beta_max = math.degrees(self.v_beta_max) def load_from_save_to_txt(self, s): """ :description Load attributes for a txt string representation :param 1. (string) s -- string description of the object, method save_to_txt. """ super().load_from_save_to_txt(s) self.trajectory = TrajectoryPlaner(self.trajectory) self.default_parameters() def my_rand(self, bound): """ :description Random function used in randomize :param 1. ((int,int)) bound -- limit of the random variable that is created. :return 1. (float) random value btw bound[0] and bound[1] """ return random.uniform(bound[0], bound[1]) def randomize(self, camera_type, beta_bound, delta_beta_bound, field_bound, v_xy_min_bound, v_xy_max_bound, v_alpha_min_bound, v_alpha_max_bound, v_beta_min_bound, v_beta_max_bound): """ :description Create a mobile camera with random :param 1.(MobileCameraType) camera_type -- Camera type 2.((int,int))beta_bound - [degree] -- random bound of beta 3.((int,int))delta_beta_bound - [degree] -- random bound of delta_beta 4.((int,int))field_bound - [m] -- random bound of field_detph 5.((int,int))v_xx_min_bound -[m/s] -- random bound of v_min in x and y axis 6.((int,int))v_xy_max_bound -[m/s] -- random bound of v_max in x and y axis 7.((int,int))v_alpha_min_bound - [degree/s] -- random bound of alpha min 8.((int,int))v_alpha_max_bound - [degree/s] -- random bound of alpha max 9.((int,int))v_beta_min_bound - [degree/s] -- random bound of beta min 10((int,int))v_beta_ùax_bound - [degree/s] -- random bound of beta max :return set severals attributes to random values bounded btw parameters """ self.xc = self.my_rand((0, constants.ROOM_DIMENSION_X)) self.yc = self.my_rand((0, constants.ROOM_DIMENSION_Y)) self.alpha = bound_angle_btw_minus_pi_plus_pi(self.my_rand((-math.pi, math.pi))) self.beta = self.my_rand(beta_bound) self.delta_beta = self.my_rand(delta_beta_bound) self.field_depth = self.my_rand(field_bound) self.t_add = [0] self.t_del = [1000] self.vx_vy_min = self.my_rand(v_xy_min_bound) self.vx_vy_max = self.my_rand(v_xy_max_bound) self.v_alpha_min = self.my_rand(v_alpha_min_bound) self.v_alpha_max = self.my_rand(v_alpha_max_bound) self.v_beta_min = self.my_rand(v_beta_min_bound) self.v_beta_max = self.my_rand(v_beta_max_bound) self.trajectory = TrajectoryPlaner([]) self.camera_type = camera_type """Default values""" self.set_default_values(xc=self.xc, yc=self.yc, alpha=self.alpha, beta=self.beta, field_depth=self.field_depth) self.beta_min = self.beta - self.delta_beta self.beta_max = self.beta + self.delta_beta self.angle_degToRad() def compute_field_depth_variation_for_a_new_beta(self, new_beta): """ :description the field depth is inversaly propotional to beta :param 1. (float) new_beta - [radians] -- new angle from the camera :return 1. (float) field_depth - [m] -- field depth corresponding to the new beta """ delta = new_beta - self.beta field_depth = self.field_depth - delta * self.coeff_field field_depth = bound(field_depth, constants.AGENT_CAMERA_FIELD_MIN * self.default_field_depth, constants.AGENT_CAMERA_FIELD_MAX * self.default_field_depth) return field_depth def zoom(self, speed, dt): """ :description Modelize the zoom of a camera (modifies beta and field_depth) effects : zoom in / zoom out 1) on the field geometry: a. Increase/decrease beta b. Decrease/increase the field depth 2) on the precision c. Decrease/increase the std on the measure self.coeff_speed -- value > 0, defines the proportionality btw a. and b. self.coeff_std -- value > 0, defines the proportionality btw a. and c. :param 1. (float) speed -- going from -1 to 1, + to zoom out - to zoom 2. (float) dt -- time """ sign = np.sign(speed) if self.beta_min <= self.beta <= self.beta_max: if speed == 0: delta = 0 else: delta = sign * dt * (self.v_beta_min + math.fabs(speed) * (self.v_beta_max - self.v_beta_min)) elif self.beta < self.beta_min or self.beta_max > 0: self.beta = bound(self.beta, self.beta_min, self.beta_max) delta = 0 else: delta = 0 print("problem in beta target") self.field_depth = self.compute_field_depth_variation_for_a_new_beta(self.beta + delta) self.beta += delta if constants.ERROR_VARIATION_ZOOM: self.std_measurement_error_position -= delta * self.coeff_std_position self.std_measurement_error_speed -= delta * self.coeff_std_speed self.std_measurement_error_acceleration -= delta * self.coeff_std_acc self.std_measurement_error_position = bound(self.std_measurement_error_position, 0, self.std_measurement_error_position * 10) self.std_measurement_error_speed = bound(self.std_measurement_error_speed, 0, self.std_measurement_error_speed * 10) self.std_measurement_error_acceleration = bound(self.std_measurement_error_acceleration, 0, self.std_measurement_error_acceleration * 10) def rotate(self, speed, dt): """ :description Rotate the camera in the room '(modifies angle alpha) :param 1. (float) speed -- going from -1 to 1 2. (float) dt -- time """ if not self.camera_type == MobileCameraType.FIX: sign = np.sign(speed) if speed == 0: delta = 0 else: delta = sign * dt * (self.v_alpha_min + math.fabs(speed) * (self.v_alpha_max - self.v_alpha_min)) self.alpha += delta self.alpha = bound_angle_btw_minus_pi_plus_pi(self.alpha) def move(self, speed_x, speed_y, dt): """ :description Move the camera in the room (modifies xc and yc) :param 1. (float) speed_x -- going from -1 to 1 1. (float) speed_y -- going from -1 to 1 2. (float) dt -- time """ sign_x = np.sign(speed_x) sign_y = np.sign(speed_y) if speed_x == 0: delta_x = 0 else: delta_x = sign_x * dt * (self.vx_vy_min + math.fabs(speed_x) * (self.vx_vy_max - self.vx_vy_min)) if speed_y == 0: delta_y = 0 else: delta_y = sign_y * dt * (self.vx_vy_min + math.fabs(speed_y) * (self.vx_vy_max - self.vx_vy_min)) if self.camera_type == MobileCameraType.RAIL: "On the rail it is only 1 dimension" delta = delta_x x_new, y_new = self.trajectory.move_on_trajectory(self.xc, self.yc, delta) self.xc = x_new self.yc = y_new elif self.camera_type == MobileCameraType.FREE: self.xc += delta_x self.yc += delta_y self.xc = bound(self.xc, self.xc_min, self.xc_max) self.yc = bound(self.yc, self.yc_min, self.yc_max) def set_configuration(self, configuration): """ :description Set the parameters thanks to a configuration :param 1. (Configuration) configuration -- group several parameters """ self.xc = configuration.x self.yc = configuration.y self.alpha = configuration.alpha self.beta = configuration.beta self.field_depth = configuration.field_depth def get_edge_points_world_frame(self): """ :description #TODO - petite description """ # angles of edge of field of view in cam frame angle_min, angle_max = -self.beta / 2, self.beta / 2 # distance of depth field along these angles min_edge = (self.field_depth * math.cos(angle_min), self.field_depth * math.sin(angle_min)) max_edge = (self.field_depth * math.sin(angle_max), self.field_depth * math.sin(angle_max))
: An administrator password that you can use to sign in to the Puppet Enterprise console after the server is online. - *(dict) --* A name and value pair that is specific to the engine of the server. - **Name** *(string) --* The name of the engine attribute. - **Value** *(string) --* The value of the engine attribute. - **EngineVersion** *(string) --* The engine version of the server. For a Chef server, the valid value for EngineVersion is currently ``12`` . For a Puppet server, the valid value is ``2017`` . - **InstanceProfileArn** *(string) --* The instance profile ARN of the server. - **InstanceType** *(string) --* The instance type for the server, as specified in the CloudFormation stack. This might not be the same instance type that is shown in the EC2 console. - **KeyPair** *(string) --* The key pair associated with the server. - **MaintenanceStatus** *(string) --* The status of the most recent server maintenance run. Shows ``SUCCESS`` or ``FAILED`` . - **PreferredMaintenanceWindow** *(string) --* The preferred maintenance period specified for the server. - **PreferredBackupWindow** *(string) --* The preferred backup period specified for the server. - **SecurityGroupIds** *(list) --* The security group IDs for the server, as specified in the CloudFormation stack. These might not be the same security groups that are shown in the EC2 console. - *(string) --* - **ServiceRoleArn** *(string) --* The service role ARN used to create the server. - **Status** *(string) --* The server's status. This field displays the states of actions in progress, such as creating, running, or backing up the server, as well as the server's health state. - **StatusReason** *(string) --* Depending on the server status, this field has either a human-readable message (such as a create or backup error), or an escaped block of JSON (used for health check results). - **SubnetIds** *(list) --* The subnet IDs specified in a CreateServer request. - *(string) --* - **ServerArn** *(string) --* The ARN of the server. :type DisableAutomatedBackup: boolean :param DisableAutomatedBackup: Setting DisableAutomatedBackup to ``true`` disables automated or scheduled backups. Automated backups are enabled by default. :type BackupRetentionCount: integer :param BackupRetentionCount: Sets the number of automated backups that you want to keep. :type ServerName: string :param ServerName: **[REQUIRED]** The name of the server to update. :type PreferredMaintenanceWindow: string :param PreferredMaintenanceWindow: ``DDD:HH:MM`` (weekly start time) or ``HH:MM`` (daily start time). Time windows always use coordinated universal time (UTC). Valid strings for day of week (``DDD`` ) are: ``Mon`` , ``Tue`` , ``Wed`` , ``Thr`` , ``Fri`` , ``Sat`` , or ``Sun`` . :type PreferredBackupWindow: string :param PreferredBackupWindow: ``DDD:HH:MM`` (weekly start time) or ``HH:MM`` (daily start time). Time windows always use coordinated universal time (UTC). Valid strings for day of week (``DDD`` ) are: ``Mon`` , ``Tue`` , ``Wed`` , ``Thr`` , ``Fri`` , ``Sat`` , or ``Sun`` . :rtype: dict :returns: """ pass def update_server_engine_attributes(self, ServerName: str, AttributeName: str, AttributeValue: str = None) -> Dict: """ Updates engine-specific attributes on a specified server. The server enters the ``MODIFYING`` state when this operation is in progress. Only one update can occur at a time. You can use this command to reset a Chef server's public key (``CHEF_PIVOTAL_KEY`` ) or a Puppet server's admin password (``PUPPET_ADMIN_PASSWORD`` ). This operation is asynchronous. This operation can only be called for servers in ``HEALTHY`` or ``UNHEALTHY`` states. Otherwise, an ``InvalidStateException`` is raised. A ``ResourceNotFoundException`` is thrown when the server does not exist. A ``ValidationException`` is raised when parameters of the request are not valid. See also: `AWS API Documentation <https://docs.aws.amazon.com/goto/WebAPI/opsworkscm-2016-11-01/UpdateServerEngineAttributes>`_ **Request Syntax** :: response = client.update_server_engine_attributes( ServerName='string', AttributeName='string', AttributeValue='string' ) **Response Syntax** :: { 'Server': { 'AssociatePublicIpAddress': True|False, 'BackupRetentionCount': 123, 'ServerName': 'string', 'CreatedAt': datetime(2015, 1, 1), 'CloudFormationStackArn': 'string', 'DisableAutomatedBackup': True|False, 'Endpoint': 'string', 'Engine': 'string', 'EngineModel': 'string', 'EngineAttributes': [ { 'Name': 'string', 'Value': 'string' }, ], 'EngineVersion': 'string', 'InstanceProfileArn': 'string', 'InstanceType': 'string', 'KeyPair': 'string', 'MaintenanceStatus': 'SUCCESS'|'FAILED', 'PreferredMaintenanceWindow': 'string', 'PreferredBackupWindow': 'string', 'SecurityGroupIds': [ 'string', ], 'ServiceRoleArn': 'string', 'Status': 'BACKING_UP'|'CONNECTION_LOST'|'CREATING'|'DELETING'|'MODIFYING'|'FAILED'|'HEALTHY'|'RUNNING'|'RESTORING'|'SETUP'|'UNDER_MAINTENANCE'|'UNHEALTHY'|'TERMINATED', 'StatusReason': 'string', 'SubnetIds': [ 'string', ], 'ServerArn': 'string' } } **Response Structure** - *(dict) --* - **Server** *(dict) --* Contains the response to an ``UpdateServerEngineAttributes`` request. - **AssociatePublicIpAddress** *(boolean) --* Associate a public IP address with a server that you are launching. - **BackupRetentionCount** *(integer) --* The number of automated backups to keep. - **ServerName** *(string) --* The name of the server. - **CreatedAt** *(datetime) --* Time stamp of server creation. Example ``2016-07-29T13:38:47.520Z`` - **CloudFormationStackArn** *(string) --* The ARN of the CloudFormation stack that was used to create the server. - **DisableAutomatedBackup** *(boolean) --* Disables automated backups. The number of stored backups is dependent on the value of PreferredBackupCount. - **Endpoint** *(string) --* A DNS name that can be used to access the engine. Example: ``myserver-asdfghjkl.us-east-1.opsworks.io`` - **Engine** *(string) --* The engine type of the server. Valid values in this release include ``Chef`` and ``Puppet`` . - **EngineModel** *(string) --* The engine model of the server. Valid values in this release include ``Monolithic`` for Puppet and ``Single`` for Chef. - **EngineAttributes** *(list) --* The response of a createServer() request returns the master credential to access the server in EngineAttributes. These credentials are not stored by AWS OpsWorks CM; they are returned only as part of the result of createServer(). **Attributes returned in a createServer response for Chef** * ``CHEF_PIVOTAL_KEY`` : A base64-encoded RSA private key that is generated by AWS OpsWorks for Chef Automate. This private key is required to access the Chef API. * ``CHEF_STARTER_KIT`` : A base64-encoded ZIP file. The ZIP file contains a Chef starter kit, which includes a README, a configuration file, and the required RSA private key. Save this file, unzip it, and then change to the directory where you've unzipped the file contents. From this directory, you can run Knife commands. **Attributes returned in a createServer response for Puppet** * ``PUPPET_STARTER_KIT`` : A base64-encoded ZIP file. The ZIP file contains a Puppet starter kit, including a README and a required private key. Save this file, unzip it, and then change to the directory where you've unzipped the file contents. * ``PUPPET_ADMIN_PASSWORD`` : An administrator password that you can use to sign in to the Puppet Enterprise console after the server is online. - *(dict) --* A name and value pair that is specific to the engine of the server. - **Name** *(string) --* The name of the engine attribute. - **Value** *(string) --* The value of the engine attribute. - **EngineVersion** *(string) --* The engine version of the server. For a Chef server, the valid value for EngineVersion is currently ``12`` . For a Puppet server, the valid value is ``2017`` . - **InstanceProfileArn** *(string) --* The instance profile ARN of the server. - **InstanceType** *(string) --* The instance type for the server, as specified in the CloudFormation stack. This might not be the same instance type that is shown in the EC2 console. - **KeyPair** *(string) --* The key pair associated with the server. - **MaintenanceStatus** *(string) --* The status of the most recent server maintenance run. Shows ``SUCCESS`` or ``FAILED`` . - **PreferredMaintenanceWindow** *(string) --* The preferred maintenance period specified for the server. - **PreferredBackupWindow** *(string) --* The preferred backup period specified for the server. - **SecurityGroupIds** *(list) --* The security group
# Copyright [2018-2022] EMBL-European Bioinformatics Institute # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import mysql.connector from mysql.connector import Error import gspread from oauth2client.service_account import ServiceAccountCredentials import pprint import unicodedata import time import datetime import argparse #import traceback def fetch_db_data(query,database,host,port,user,password): try: conn = mysql.connector.connect(database=database, host=host, port=port, user=user, password=password) cursor = conn.cursor() cursor.execute(query) rows = cursor.fetchall() except Error as e: print(e) finally: cursor.close() conn.close() return rows def update_assembly_sheet(assembly_db_data,meta_db_data,existing_sheet_records,assembly_sheet,gettime,worksheet_name): # This method creates a dictionary for both the lists from the db and sheets and makes both # dicts key on the versioned GCA (which is unique). Once the dicts are generated keys in the # assembly db dict are compared to the keys in the sheets dict. If a key is not in the sheets # dict then it is a new entry and gets made into a new row and added to the sheet. If the key # is present then some tests are done to see if anything needs updating. Some of these tests # could be made generic, but there are some complex cases like when the filters need updating # The filters are basically tags for the assemblies that are then used to create the filter # views in sheets min_contig_n50_filter = 100000 assembly_db_dict = {} existing_sheet_dict = {} max_version_dict = {} existing_annotations_dict = {} # This ordering needs to match the ordering of the query on the assembly db assembly_db_columns = ['subspecies_name','common_name','chain','version','clade','contig_N50','assembly_level','assembly_date','refseq_accession','assembly_name','genome_rep','rnaseq_data', 'genebuilder','progress_status','assembly_group'] # This ordering needs to match the ordering of the columns on the sheet assembly_sheet_columns = ['GCA','Clade','Species name','Common name','Contig N50','Assembly level','Assembly date','Assembly name','RNAseq data','RefSeq accession','Genebuilder','Status','Assembly group','Expected release','Grant','Notes','Filter: Max version','Filter: Genome rep','Filter: N50','Filter: Non-human'] # This makes a dict for the db on the versioned GCA and also makes a dict to track the highest # version for a particular GCA (used in filtering later) # Note the db has entries that are in unicode in some cases and need to be converted for row in assembly_db_data: chain = row[assembly_db_columns.index('chain')] version = row[assembly_db_columns.index('version')] chain.encode('ascii','ignore') gca = make_gca(chain,version) assembly_db_dict[gca] = row if chain in max_version_dict: current_max_version = max_version_dict[chain] if version > current_max_version: max_version_dict[chain] = version else: max_version_dict[chain] = version # This makes an existing annotations dict based on the meta data db. Note that this db only # goes back to e80, so there is a small chance that assemblies that were once annotated are not marked # as handed over in the filters, but this shouldn't be a problem for row in meta_db_data: gca = row[0] gca.encode('ascii','ignore') existing_annotations_dict[gca] = 1 # This just makes a dict for the sheet based on the versioned GCA for row in existing_sheet_records: gca = row[0] gca.encode('ascii','ignore') if(gca == 'GCA'): next else: existing_sheet_dict[gca] = row # This is where the majority of the work occurs. All assembly GCAs are examined to determined what # should be added/updated # Note that currently a three second sleep is needed to avoid exhausting the Sheets REST API quota for gca in assembly_db_dict: # Check that time since last authentication is < 1hr # If greater than 1 hr, then re-authenticate if(time.time() - gettime > 60* 59): print("Re-authenticating API's connection ") # use creds to create a client to interact with the Google Drive API scope = ['https://spreadsheets.google.com/feeds','https://www.googleapis.com/auth/drive'] creds = ServiceAccountCredentials.from_json_keyfile_name(credentials_path, scope) client = gspread.authorize(creds) gettime = time.time() # Find a workbook by name and open the first sheet # Make sure you use the right name here. assembly_sheet = client.open(worksheet_name).worksheet("EnsemblAssemblyRegistry") assembly_row = assembly_db_dict[gca] species_name = assembly_row[assembly_db_columns.index('subspecies_name')] common_name = assembly_row[assembly_db_columns.index('common_name')] chain = assembly_row[assembly_db_columns.index('chain')] chain.encode('ascii','ignore') version = assembly_row[assembly_db_columns.index('version')] clade = assembly_row[assembly_db_columns.index('clade')] contig_N50 = assembly_row[assembly_db_columns.index('contig_N50')] assembly_level = assembly_row[assembly_db_columns.index('assembly_level')] assembly_date = assembly_row[assembly_db_columns.index('assembly_date')] refseq_accession = assembly_row[assembly_db_columns.index('refseq_accession')] assembly_name = assembly_row[assembly_db_columns.index('assembly_name')] genome_rep = assembly_row[assembly_db_columns.index('genome_rep')] rnaseq_data = assembly_row[assembly_db_columns.index('rnaseq_data')] gca = make_gca(chain,version) genebuilder = assembly_row[assembly_db_columns.index('genebuilder')] annotation_status = assembly_row[assembly_db_columns.index('progress_status')] assembly_group = assembly_row[assembly_db_columns.index('assembly_group')] # If GCA is in meta db, then it means db has been handed over if gca in existing_annotations_dict: annotation_status = 'Handed over' # If the row does not exist then add it in with the filtering info if not gca in existing_sheet_dict: # Depending on the assembly group, we match the display to the right project naming convention # For example, Darwin Tree of Life (DToL), Vertebrates Genomes Project (VGP), etc. # Ungrouped refers to non-project specific assemblies if assembly_group == 'dtol': assembly_group = 'DToL' elif assembly_group == 'ungrouped': assembly_group = assembly_group.capitalize() else: assembly_group.upper() # When an assembly is first written to sheets, its status should be set to 'Not started' and genebuilder set to 'Not assigned' annotation_status = 'Not started' genebuilder = 'Not assigned' new_row = [gca,clade,species_name,common_name,contig_N50,assembly_level,assembly_date.strftime('%Y-%m-%d'),assembly_name,rnaseq_data,refseq_accession,genebuilder,annotation_status,assembly_group,'','Not assigned',''] # This section sets various filters # Setting filter of versioned GCA if version == max_version_dict[chain]: new_row.append(1) else: new_row.append(0) # Setting filter for genome representation if genome_rep == 'full': new_row.append(1) else: new_row.append(0) # Setting contig_N50 filter if contig_N50 >= min_contig_n50_filter: new_row.append(1) else: new_row.append(0) # Set RNASeq status based on contig_N50 if not already assigned if rnaseq_data is None: if contig_N50 >= 100000: new_row[8] = 'No RNAseq data' else: new_row[8] = 'Non candidate assembly' else: new_row[8] = rnaseq_data.capitalize() # There is an issue with the db at the moment with trailing spaces on the species names, but this should get fixed if not (species_name == "Homo sapiens " or species_name == "Homo sapiens"): new_row.append(1) else: new_row.append(0) # Add new record to sheets print(new_row) insert_index = 2 assembly_sheet.append_row(new_row) time.sleep(3) # If it does exist we need to check if an update is required. There are only a few columns this might pertain to else: sheet_row = existing_sheet_dict[gca] sheet_clade_index = assembly_sheet_columns.index('Clade') sheet_clade_val = sheet_row[sheet_clade_index] sheet_filter_version_index = assembly_sheet_columns.index('Filter: Max version') sheet_filter_N50_index = assembly_sheet_columns.index('Filter: N50') sheet_filter_version_val = sheet_row[sheet_filter_version_index] sheet_filter_N50_val = sheet_row[sheet_filter_N50_index] sheet_refseq_accession_index = assembly_sheet_columns.index('RefSeq accession') sheet_assembly_name_index = assembly_sheet_columns.index('Assembly name') sheet_refseq_accession_val = sheet_row[sheet_refseq_accession_index] sheet_assembly_name_val = sheet_row[sheet_assembly_name_index] sheet_rnaseq_data_index = assembly_sheet_columns.index('RNAseq data') sheet_rnaseq_data_val = sheet_row[sheet_rnaseq_data_index] sheet_contig_N50_index = assembly_sheet_columns.index('Contig N50') sheet_contig_N50_val = sheet_row[sheet_contig_N50_index] sheet_annotation_status_index = assembly_sheet_columns.index('Status') sheet_annotation_status_val = sheet_row[sheet_annotation_status_index] sheet_genebuilder_index = assembly_sheet_columns.index('Genebuilder') sheet_genebuilder_val = sheet_row[sheet_genebuilder_index] sheet_assembly_group_index = assembly_sheet_columns.index('Assembly group') sheet_assembly_group_val = sheet_row[sheet_assembly_group_index] # Check if transcriptomic data status from db is null. # If yes, check if assembly has been handed over or if assembly meets candidate assembly criteria if ((rnaseq_data is None) and (sheet_rnaseq_data_val == 'Non candidate assembly' or sheet_rnaseq_data_val == 'No RNAseq data' or sheet_rnaseq_data_val == 'Not available')): # Nothing to update print("No update on rnaseq data status for: " + gca) # It is possible to annotate a species and handover without RNASeq data elif rnaseq_data is None and annotation_status == 'Handed over': # update the RNASeq data status as not applicable rnaseq_data = 'N/A' print("Updating rnaseq data status for: " + gca) row_update_index = assembly_sheet.find(gca).row update_cell_val(assembly_sheet,row_update_index,sheet_rnaseq_data_index,rnaseq_data) time.sleep(3) elif rnaseq_data.lower() != sheet_rnaseq_data_val.lower(): rnaseq_data = rnaseq_data.capitalize() # update the RNASeq data status with value from db print("Updating rnaseq data status for: " + gca) row_update_index = assembly_sheet.find(gca).row update_cell_val(assembly_sheet,row_update_index,sheet_rnaseq_data_index,rnaseq_data) time.sleep(3) # Sometimes we could have assemblies with no contig_N50 value in the sheet. This can cause issues with comparison if sheet_contig_N50_val is None: # Set a default value for contig_N50 sheet_contig_N50_val = 0 if contig_N50 != int(sheet_contig_N50_val): # Update the contig info on the sheet print("Updating the contig for: " + gca) row_update_index = assembly_sheet.find(gca).row update_cell_val(assembly_sheet,row_update_index,sheet_contig_N50_index,contig_N50) time.sleep(3) # Compare clade vlaues between db and sheets if clade != sheet_clade_val: # Update the clade print("Updating the clade for: " + gca) row_update_index = assembly_sheet.find(gca).row update_cell_val(assembly_sheet,row_update_index,sheet_clade_index,clade) time.sleep(3) # Updating specific filters if sheet_filter_version_val == "1" and str(version) != str(max_version_dict[chain]): # update
# # Copyright (c) 2019 ISP RAS (http://www.ispras.ru) # Ivannikov Institute for System Programming of the Russian Academy of Sciences # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # import copy import uuid from collections import defaultdict from django.db import transaction from django.db.models import Q, F, Count from django.utils.functional import cached_property from bridge.vars import SAFE_VERDICTS, UNSAFE_VERDICTS, ASSOCIATION_TYPE from marks.models import ( MarkSafe, MarkSafeHistory, MarkUnsafe, MarkUnsafeHistory, MarkUnknown, MarkSafeReport, MarkUnsafeReport, MarkUnknownReport, MarkSafeTag, MarkUnsafeTag, Tag ) from caches.models import ( ASSOCIATION_CHANGE_KIND, ReportSafeCache, ReportUnsafeCache, ReportUnknownCache, SafeMarkAssociationChanges, UnsafeMarkAssociationChanges, UnknownMarkAssociationChanges ) from reports.verdicts import safe_verdicts_sum, unsafe_verdicts_sum, BugStatusCollector @transaction.atomic def update_cache_atomic(queryset, data): for rep_cache in queryset.select_for_update(): if rep_cache.report_id not in data: continue for field, value in data[rep_cache.report_id].items(): setattr(rep_cache, field, value) rep_cache.save() class UpdateSafeCachesOnMarkChange: def __init__(self, mark, old_links, new_links): self._mark = mark self._old_links = old_links self._new_links = new_links self._affected_reports = self._old_links | self._new_links self._cache_queryset = ReportSafeCache.objects.filter(report_id__in=self._affected_reports) self._markreport_qs = MarkSafeReport.objects\ .filter(report_id__in=self._affected_reports, associated=True).select_related('mark') self._collected = set() self._old_data = self.__collect_old_data() self._new_data = self.__init_new_data() def save(self): update_cache_atomic(self._cache_queryset, self._new_data) return self.__create_changes_cache() def __collect_old_data(self): old_data = {} for cache_obj in self._cache_queryset: old_data[cache_obj.report_id] = { 'decision_id': cache_obj.decision_id, 'verdict': cache_obj.verdict, 'tags': cache_obj.tags } return old_data def __init_new_data(self): return dict((cache_obj.report_id, {}) for cache_obj in self._cache_queryset) def update_all(self): if 'verdicts' in self._collected and 'tags' in self._collected: return for cache_obj in self._cache_queryset: self._new_data[cache_obj.report_id]['verdict'] = SAFE_VERDICTS[4][0] self._new_data[cache_obj.report_id]['tags'] = {} self._new_data[cache_obj.report_id]['marks_total'] = 0 self._new_data[cache_obj.report_id]['marks_confirmed'] = 0 self._new_data[cache_obj.report_id]['marks_automatic'] = 0 # Count automatic associations automatic_qs = MarkSafeReport.objects\ .filter(report_id__in=self._affected_reports, type=ASSOCIATION_TYPE[2][0]).values('report_id')\ .annotate(number=Count('report_id')).values_list('report_id', 'number') for report_id, automatic_num in automatic_qs: self._new_data[report_id]['marks_automatic'] = automatic_num for mr in self._markreport_qs: self.__add_verdict(mr.report_id, mr.mark.verdict) self.__add_tags(mr.report_id, mr.mark.cache_tags) self._new_data[mr.report_id]['marks_total'] += 1 self._new_data[mr.report_id]['marks_confirmed'] += int(mr.type == ASSOCIATION_TYPE[3][0]) self._collected.add('verdicts') self._collected.add('tags') def update_verdicts(self): if 'verdicts' in self._collected: return for cache_obj in self._cache_queryset: self._new_data[cache_obj.report_id]['verdict'] = SAFE_VERDICTS[4][0] for mr in self._markreport_qs: self.__add_verdict(mr.report_id, mr.mark.verdict) self._collected.add('verdicts') def update_tags(self): if 'tags' in self._collected: return for cache_obj in self._cache_queryset: self._new_data[cache_obj.report_id]['tags'] = {} for mr in self._markreport_qs: self.__add_tags(mr.report_id, mr.mark.cache_tags) self._collected.add('tags') def __get_change_kind(self, report_id): if report_id in self._old_links: if report_id in self._new_links: return ASSOCIATION_CHANGE_KIND[0][0] return ASSOCIATION_CHANGE_KIND[2][0] # Report is always in new links as method called with needed report id return ASSOCIATION_CHANGE_KIND[1][0] @cached_property def _change_kinds(self): return dict((report_id, self.__get_change_kind(report_id)) for report_id in self._affected_reports) def __add_verdict(self, report_id, verdict): self._new_data[report_id]['verdict'] = safe_verdicts_sum(self._new_data[report_id]['verdict'], verdict) def __add_tags(self, report_id, tags_list): for tag in tags_list: self._new_data[report_id]['tags'].setdefault(tag, 0) self._new_data[report_id]['tags'][tag] += 1 def __create_changes_cache(self): # Remove old association changes cache SafeMarkAssociationChanges.objects.filter(mark=self._mark).delete() # Create new association changes identifier = uuid.uuid4() changes_objects = [] for report_id in self._affected_reports: verdict_old = self._old_data[report_id]['verdict'] verdict_new = self._new_data[report_id].get('verdict', verdict_old) tags_old = self._old_data[report_id]['tags'] tags_new = self._new_data[report_id].get('tags', tags_old) changes_objects.append(SafeMarkAssociationChanges( identifier=identifier, mark=self._mark, decision_id=self._old_data[report_id]['decision_id'], report_id=report_id, kind=self._change_kinds[report_id], verdict_old=verdict_old, verdict_new=verdict_new, tags_old=tags_old, tags_new=tags_new )) SafeMarkAssociationChanges.objects.bulk_create(changes_objects) return str(identifier) class UpdateUnsafeCachesOnMarkChange: def __init__(self, mark, old_links, new_links): self._mark = mark self._old_links = old_links self._new_links = new_links self._affected_reports = self._old_links | self._new_links self._cache_queryset = ReportUnsafeCache.objects.filter(report_id__in=self._affected_reports) self._markreport_qs = MarkUnsafeReport.objects\ .filter(report_id__in=self._affected_reports, associated=True).select_related('mark') self._collected = set() self._old_data = self.__collect_old_data() self._new_data = self.__init_new_data() def save(self): update_cache_atomic(self._cache_queryset, self._new_data) return self.__create_changes_cache() def __collect_old_data(self): old_data = {} for cache_obj in self._cache_queryset: old_data[cache_obj.report_id] = { 'decision_id': cache_obj.decision_id, 'verdict': cache_obj.verdict, 'status': cache_obj.status, 'tags': cache_obj.tags } return old_data def __init_new_data(self): return dict((cache_obj.report_id, {}) for cache_obj in self._cache_queryset) def update_all(self): if 'verdicts' in self._collected and 'tags' in self._collected: return for cache_obj in self._cache_queryset: self._new_data[cache_obj.report_id]['verdict'] = UNSAFE_VERDICTS[5][0] self._new_data[cache_obj.report_id]['status'] = None self._new_data[cache_obj.report_id]['tags'] = {} self._new_data[cache_obj.report_id]['marks_total'] = 0 self._new_data[cache_obj.report_id]['marks_confirmed'] = 0 self._new_data[cache_obj.report_id]['marks_automatic'] = 0 # Count automatic associations automatic_qs = MarkUnsafeReport.objects \ .filter(report_id__in=self._affected_reports, type=ASSOCIATION_TYPE[2][0]).values('report_id') \ .annotate(number=Count('report_id')).values_list('report_id', 'number') for report_id, automatic_num in automatic_qs: self._new_data[report_id]['marks_automatic'] = automatic_num statuses_collector = BugStatusCollector() for mr in self._markreport_qs: self.__add_verdict(mr.report_id, mr.mark.verdict) statuses_collector.add(mr.report_id, mr.mark.verdict, mr.mark.status) self.__add_tags(mr.report_id, mr.mark.cache_tags) self._new_data[mr.report_id]['marks_total'] += 1 self._new_data[mr.report_id]['marks_confirmed'] += int(mr.type == ASSOCIATION_TYPE[3][0]) for report_id, status in statuses_collector.result.items(): self._new_data[report_id]['status'] = status self._collected.add('verdicts') self._collected.add('statuses') self._collected.add('tags') def update_verdicts(self): if 'verdicts' in self._collected: return for cache_obj in self._cache_queryset: self._new_data[cache_obj.report_id]['verdict'] = UNSAFE_VERDICTS[5][0] for mr in self._markreport_qs: self.__add_verdict(mr.report_id, mr.mark.verdict) self._collected.add('verdicts') def update_statuses(self): if 'statuses' in self._collected: return for cache_obj in self._cache_queryset: self._new_data[cache_obj.report_id]['status'] = None statuses_collector = BugStatusCollector() for mr in self._markreport_qs: statuses_collector.add(mr.report_id, mr.mark.verdict, mr.mark.status) for report_id, status in statuses_collector.result.items(): self._new_data[report_id]['status'] = status self._collected.add('statuses') def update_tags(self): if 'tags' in self._collected: return for cache_obj in self._cache_queryset: self._new_data[cache_obj.report_id]['tags'] = {} for mr in self._markreport_qs: self.__add_tags(mr.report_id, mr.mark.cache_tags) self._collected.add('tags') def __get_change_kind(self, report_id): if report_id in self._old_links: if report_id in self._new_links: return ASSOCIATION_CHANGE_KIND[0][0] return ASSOCIATION_CHANGE_KIND[2][0] # Report is always in new links as method called with needed report id return ASSOCIATION_CHANGE_KIND[1][0] @cached_property def _change_kinds(self): return dict((report_id, self.__get_change_kind(report_id)) for report_id in self._affected_reports) def __add_verdict(self, report_id, verdict): self._new_data[report_id]['verdict'] = unsafe_verdicts_sum(self._new_data[report_id]['verdict'], verdict) def __add_tags(self, report_id, tags_list): for tag in tags_list: self._new_data[report_id]['tags'].setdefault(tag, 0) self._new_data[report_id]['tags'][tag] += 1 def __create_changes_cache(self): # Remove old association changes cache UnsafeMarkAssociationChanges.objects.filter(mark=self._mark).delete() # Create new association changes identifier = uuid.uuid4() changes_objects = [] for report_id in self._affected_reports: verdict_old = self._old_data[report_id]['verdict'] verdict_new = self._new_data[report_id].get('verdict', verdict_old) status_old = self._old_data[report_id]['status'] status_new = self._new_data[report_id].get('status', verdict_old) tags_old = self._old_data[report_id]['tags'] tags_new = self._new_data[report_id].get('tags', tags_old) changes_objects.append(UnsafeMarkAssociationChanges( identifier=identifier, mark=self._mark, decision_id=self._old_data[report_id]['decision_id'], report_id=report_id, kind=self._change_kinds[report_id], verdict_old=verdict_old, verdict_new=verdict_new, tags_old=tags_old, tags_new=tags_new, status_old=status_old, status_new=status_new )) UnsafeMarkAssociationChanges.objects.bulk_create(changes_objects) return str(identifier) class UpdateUnknownCachesOnMarkChange: def __init__(self, mark, old_links, new_links): self._mark = mark self._old_links = old_links self._new_links = new_links self._affected_reports = self._old_links | self._new_links self._cache_queryset = ReportUnknownCache.objects.filter(report_id__in=self._affected_reports) self._markreport_qs = MarkUnknownReport.objects.filter(report_id__in=self._affected_reports, associated=True) self._collected = False self._old_data = self.__collect_old_data() self._new_data = self.__init_new_data() def save(self): if self._collected: update_cache_atomic(self._cache_queryset, self._new_data) self._collected = False return self.__create_changes_cache() def __collect_old_data(self): old_data = {} for cache_obj in self._cache_queryset: old_data[cache_obj.report_id] = { 'decision_id': cache_obj.decision_id, 'problems': cache_obj.problems } return old_data def __init_new_data(self): return dict((cache_obj.report_id, {}) for cache_obj in self._cache_queryset) def update_all(self): for cache_obj in self._cache_queryset: self._new_data[cache_obj.report_id]['problems'] = {} self._new_data[cache_obj.report_id]['marks_total'] = 0 self._new_data[cache_obj.report_id]['marks_confirmed'] = 0 self._new_data[cache_obj.report_id]['marks_automatic'] = 0 # Count automatic associations automatic_qs = MarkUnknownReport.objects \ .filter(report_id__in=self._affected_reports, type=ASSOCIATION_TYPE[2][0]).values('report_id') \ .annotate(number=Count('report_id')).values_list('report_id', 'number') for report_id, automatic_num in automatic_qs: self._new_data[report_id]['marks_automatic'] = automatic_num for mr in self._markreport_qs: self._new_data[mr.report_id]['problems'].setdefault(mr.problem, 0) self._new_data[mr.report_id]['problems'][mr.problem] += 1 self._new_data[mr.report_id]['marks_total'] += 1 self._new_data[mr.report_id]['marks_confirmed'] += int(mr.type == ASSOCIATION_TYPE[3][0]) self._collected = True def __get_change_kind(self, report_id): if report_id in self._old_links: if report_id in self._new_links: return ASSOCIATION_CHANGE_KIND[0][0] return ASSOCIATION_CHANGE_KIND[2][0] # Report is always in new links as method called with needed report id return ASSOCIATION_CHANGE_KIND[1][0] @cached_property def _change_kinds(self): return dict((report_id, self.__get_change_kind(report_id)) for report_id in self._affected_reports) def __create_changes_cache(self): # Remove old association changes cache UnknownMarkAssociationChanges.objects.filter(mark=self._mark).delete() # Create new association changes identifier = uuid.uuid4() changes_objects = [] for report_id in self._affected_reports: problems_old = self._old_data[report_id]['problems'] problems_new = self._new_data[report_id].get('problems', problems_old) changes_objects.append(UnknownMarkAssociationChanges( identifier=identifier, mark=self._mark, decision_id=self._old_data[report_id]['decision_id'], report_id=report_id, kind=self._change_kinds[report_id], problems_old=problems_old, problems_new=problems_new )) UnknownMarkAssociationChanges.objects.bulk_create(changes_objects) return str(identifier) class UpdateCachesOnMarkPopulate: def __init__(self, mark, new_links): self._mark = mark self._new_links = new_links def update(self): if not self._new_links: # Nothing changed return if isinstance(self._mark, MarkSafe): self.__update_safes() elif isinstance(self._mark, MarkUnsafe): self.__update_unsafes() elif isinstance(self._mark, MarkUnknown): self.__update_unknowns() @transaction.atomic def __update_safes(self): for cache_obj in ReportSafeCache.objects.filter(report_id__in=self._new_links).select_for_update(): # All safe links after the population are automatic cache_obj.marks_automatic += 1 if cache_obj.marks_confirmed == 0: # If report has confirmed mark, then new populated mark can't affect its cache cache_obj.verdict = safe_verdicts_sum(cache_obj.verdict, self._mark.verdict) cache_obj.tags = self.__sum_tags(cache_obj.tags) cache_obj.marks_total += 1 # Populated mark can't be confirmed, so we don't need to update confirmed number cache_obj.save() def __update_unsafes(self): # Filter new_links with automatic associations as just such associations can affect report's cache affected_reports = set(MarkUnsafeReport.objects.filter( report_id__in=self._new_links, mark=self._mark, type=ASSOCIATION_TYPE[2][0] ).values_list('report_id', flat=True)) with transaction.atomic(): for cache_obj in ReportUnsafeCache.objects.filter(report_id__in=affected_reports).select_for_update(): cache_obj.marks_automatic += 1 if cache_obj.marks_confirmed == 0: # If report has confirmed mark, then new populated mark can't affect its cache cache_obj.verdict = unsafe_verdicts_sum(cache_obj.verdict, self._mark.verdict) cache_obj.status = BugStatusCollector.sum(cache_obj.status, self._mark.status, cache_obj.verdict) cache_obj.tags = self.__sum_tags(cache_obj.tags) cache_obj.marks_total += 1 # Populated mark can't be confirmed, so we don't need to update confirmed number cache_obj.save() def __update_unknowns(self): new_problems = dict(MarkUnknownReport.objects.filter(mark=self._mark).values_list('report_id', 'problem')) with transaction.atomic(): for cache_obj in ReportUnknownCache.objects.filter(report_id__in=self._new_links)\ .select_for_update(): # All unknown links after the population are automatic cache_obj.marks_automatic += 1 # If report has confirmed mark, then new populated mark can't affect its cache if cache_obj.marks_confirmed == 0 and cache_obj.report_id in new_problems: problem = new_problems[cache_obj.report_id] cache_obj.problems.setdefault(problem, 0) cache_obj.problems[problem] += 1 cache_obj.marks_total += 1 # Populated mark can't be confirmed,
*args, **kwargs): return [{"Roles": [{"RoleName": "fake-role-1"}, {"RoleName": "fake-role-2"}]}] iam_client.get_paginator.return_value = MockPaginator_Roles() with CaptureStdout() as output: kwargs = _get_aws_list_assets_kwargs() iam.list_roles([], argparse.Namespace(**kwargs)) self.assertIn("fake-role-1", output) self.assertIn("fake-role-2", output) def test_iam_fus_list_assets(self): def _get_fus_list_assets_kwargs(**kwargs): # Set default kwargs values, then set user-specified kwargs custom_kwargs = dict( cloud_provider="fusillade", output=None, force=False, exclude_headers=False, ) for kw, val in kwargs.items(): custom_kwargs[kw] = val return custom_kwargs with self.subTest("Fusillade list users"): with mock.patch("dss.operations.iam.FusilladeClient") as fus_client: side_effects = [[ "<EMAIL>", "<EMAIL>" ]] fus_client().paginate = mock.MagicMock(side_effect=side_effects) kwargs = _get_fus_list_assets_kwargs() with CaptureStdout() as output: iam.list_users([], argparse.Namespace(**kwargs)) self.assertIn("<EMAIL>", output) self.assertIn("<EMAIL>", output) with self.subTest("Fusillade list groups"): with mock.patch("dss.operations.iam.FusilladeClient") as fus_client: side_effects = [["fake-group-1", "fake-group-2"]] fus_client().paginate = mock.MagicMock(side_effect=side_effects) kwargs = _get_fus_list_assets_kwargs() with CaptureStdout() as output: iam.list_groups([], argparse.Namespace(**kwargs)) self.assertIn("fake-group-1", output) self.assertIn("fake-group-2", output) with self.subTest("Fusillade list roles"): with mock.patch("dss.operations.iam.FusilladeClient") as fus_client: side_effects = [["fake-role-1", "fake-role-2"]] fus_client().paginate = mock.MagicMock(side_effect=side_effects) kwargs = _get_fus_list_assets_kwargs() with CaptureStdout() as output: iam.list_roles([], argparse.Namespace(**kwargs)) self.assertIn("fake-role-1", output) self.assertIn("fake-role-2", output) def test_secrets_crud(self): # CRUD (create read update delete) test procedure: # - create new secret # - list secrets and verify new secret shows up # - get secret value and verify it is correct # - update secret value # - get secret value and verify it is correct # - delete secret which_stage = os.environ["DSS_DEPLOYMENT_STAGE"] which_store = os.environ["DSS_SECRETS_STORE"] secret_name = random_alphanumeric_string() testvar_name = f"{which_store}/{which_stage}/{secret_name}" testvar_value = "Hello world!" testvar_value2 = "Goodbye world!" unusedvar_name = f"{which_store}/{which_stage}/admin_user_emails" with self.subTest("Create a new secret"): # Monkeypatch the secrets manager with mock.patch("dss.operations.secrets.sm_client") as sm: # Creating a new variable will first call get, which will not find it sm.get_secret_value = mock.MagicMock(return_value=None, side_effect=ClientError({}, None)) # Next we will use the create secret command sm.create_secret = mock.MagicMock(return_value=None) # Create initial secret value: # Dry run first with SwapStdin(testvar_value): secrets.set_secret( [], argparse.Namespace( secret_name=testvar_name, dry_run=True, infile=None, quiet=True, force=True ), ) # Provide secret via stdin with SwapStdin(testvar_value): secrets.set_secret( [], argparse.Namespace( secret_name=testvar_name, dry_run=False, infile=None, quiet=True, force=True ), ) # Provide secret via infile with tempfile.NamedTemporaryFile(prefix='dss-test-operations-new-secret-temp-input', mode='w') as f: f.write(testvar_value) secrets.set_secret( [], argparse.Namespace( secret_name=testvar_name, dry_run=False, infile=f.name, force=True, quiet=True ), ) # Check error-catching with non-existent infile mf = 'this-file-is-not-here' with self.assertRaises(RuntimeError): secrets.set_secret( [], argparse.Namespace( secret_name=testvar_name, dry_run=False, infile=mf, force=True, quiet=True ), ) with self.subTest("List secrets"): with mock.patch("dss.operations.secrets.sm_client") as sm: # Listing secrets requires creating a paginator first, # so mock what the paginator returns class MockPaginator(object): def paginate(self): # Return a mock page from the mock paginator return [{"SecretList": [{"Name": testvar_name}, {"Name": unusedvar_name}]}] sm.get_paginator.return_value = MockPaginator() # Non-JSON output first with CaptureStdout() as output: secrets.list_secrets([], argparse.Namespace(json=False)) self.assertIn(testvar_name, output) # JSON output with CaptureStdout() as output: secrets.list_secrets([], argparse.Namespace(json=True)) all_secrets_output = json.loads("\n".join(output)) self.assertIn(testvar_name, all_secrets_output) with self.subTest("Get secret value"): with mock.patch("dss.operations.secrets.sm_client") as sm: # Requesting the variable will try to get secret value and succeed sm.get_secret_value.return_value = {"SecretString": testvar_value} # Now run get secret value in JSON mode and non-JSON mode # and verify variable name/value is in both. # New output file with tempfile.NamedTemporaryFile(prefix='dss-test-operations-get-secret-temp-output', mode='w') as f: # Try to overwrite outfile without --force with self.assertRaises(RuntimeError): secrets.get_secret( [], argparse.Namespace(secret_name=testvar_name, outfile=f.name, force=False) ) # Overwrite outfile with --force secrets.get_secret( [], argparse.Namespace(secret_name=testvar_name, outfile=f.name, force=True) ) with open(f.name, 'r') as fr: file_contents = fr.read() self.assertIn(testvar_value, file_contents) # Output secret to stdout with CaptureStdout() as output: secrets.get_secret( [], argparse.Namespace(secret_name=testvar_name, outfile=None, force=False) ) self.assertIn(testvar_value, "\n".join(output)) with self.subTest("Update existing secret"): with mock.patch("dss.operations.secrets.sm_client") as sm: # Updating the variable will try to get secret value and succeed sm.get_secret_value = mock.MagicMock(return_value={"SecretString": testvar_value}) # Next we will call the update secret command sm.update_secret = mock.MagicMock(return_value=None) # Update secret: # Dry run first with SwapStdin(testvar_value2): secrets.set_secret( [], argparse.Namespace( secret_name=testvar_name, dry_run=True, infile=None, force=True, quiet=True ), ) # Use stdin with SwapStdin(testvar_value2): secrets.set_secret( [], argparse.Namespace( secret_name=testvar_name, dry_run=False, infile=None, force=True, quiet=True ), ) # Use input file with tempfile.NamedTemporaryFile(prefix='dss-test-operations-update-secret-temp-input', mode='w') as f: f.write(testvar_value2) secrets.set_secret( [], argparse.Namespace( secret_name=testvar_name, dry_run=False, infile=f.name, force=True, quiet=True ), ) with self.subTest("Delete secret"): with mock.patch("dss.operations.secrets.sm_client") as sm: # Deleting the variable will try to get secret value and succeed sm.get_secret_value = mock.MagicMock(return_value={"SecretString": testvar_value}) sm.delete_secret = mock.MagicMock(return_value=None) # Delete secret # Dry run first secrets.del_secret( [], argparse.Namespace(secret_name=testvar_name, force=True, dry_run=True, quiet=True) ) # Real thing secrets.del_secret( [], argparse.Namespace(secret_name=testvar_name, force=True, dry_run=False, quiet=True) ) def test_ssmparams_utilities(self): prefix = f"/{os.environ['DSS_PARAMETER_STORE']}/{os.environ['DSS_DEPLOYMENT_STAGE']}" gold_var = f"{prefix}/dummy_variable" var = "dummy_variable" new_var = fix_ssm_variable_prefix(var) self.assertEqual(new_var, gold_var) var = "/dummy_variable" new_var = fix_ssm_variable_prefix(var) self.assertEqual(new_var, gold_var) var = f"{prefix}/dummy_variable" new_var = fix_ssm_variable_prefix(var) self.assertEqual(new_var, gold_var) var = f"{prefix}/dummy_variable/" new_var = fix_ssm_variable_prefix(var) self.assertEqual(new_var, gold_var) def test_ssmparams_crud(self): # CRUD (create read update delete) test for setting environment variables in SSM param store testvar_name = random_alphanumeric_string() testvar_value = "Hello world!" # Assemble environment to return old_env = {"DUMMY_VARIABLE": "dummy_value"} new_env = dict(**old_env) new_env[testvar_name] = testvar_value ssm_new_env = self._wrap_ssm_env(new_env) with self.subTest("Print the SSM environment"): with mock.patch("dss.operations.lambda_params.ssm_client") as ssm: # listing params will call ssm.get_parameter to get the entire environment ssm.get_parameter = mock.MagicMock(return_value=ssm_new_env) # Now call our params.py module. Output var=value on each line. with CaptureStdout() as output: lambda_params.ssm_environment([], argparse.Namespace(json=False)) self.assertIn(f"{testvar_name}={testvar_value}", output) def test_lambdaparams_crud(self): # CRUD (create read update delete) test for setting lambda function environment variables testvar_name = random_alphanumeric_string() testvar_value = "Hello world!" testvar_value2 = "Goodbye world!" # Assemble an old and new environment to return old_env = {"DUMMY_VARIABLE": "dummy_value"} new_env = dict(**old_env) new_env[testvar_name] = testvar_value ssm_old_env = self._wrap_ssm_env(old_env) ssm_new_env = self._wrap_ssm_env(new_env) lam_old_env = self._wrap_lambda_env(old_env) lam_new_env = self._wrap_lambda_env(new_env) with self.subTest("Create a new lambda parameter"): with mock.patch("dss.operations.lambda_params.ssm_client") as ssm, \ mock.patch("dss.operations.lambda_params.lambda_client") as lam: # If this is not a dry run, lambda_set in params.py # will update the SSM first, so we mock those first. # Before we have set the new test variable for the # first time, we will see the old environment. ssm.put_parameter = mock.MagicMock(return_value=None) ssm.get_parameter = mock.MagicMock(return_value=ssm_old_env) # The lambda_set func in params.py will update lambdas, # so we mock the calls that those will make too. lam.get_function = mock.MagicMock(return_value=None) lam.get_function_configuration = mock.MagicMock(return_value=lam_old_env) lam.update_function_configuration = mock.MagicMock(return_value=None) with SwapStdin(testvar_value): lambda_params.lambda_set( [], argparse.Namespace(name=testvar_name, dry_run=True, quiet=True) ) with SwapStdin(testvar_value): lambda_params.lambda_set( [], argparse.Namespace(name=testvar_name, dry_run=False, quiet=True) ) with self.subTest("List lambda parameters"): with mock.patch("dss.operations.lambda_params.lambda_client") as lam: # The lambda_list func in params.py calls get_deployed_lambas, which calls lam.get_function() # using daemon folder names (this function is called only to ensure no exception is thrown) lam.get_function = mock.MagicMock(return_value=None) # Next we call get_deployed_lambda_environment(), which calls lam.get_function_configuration # (this returns the mocked new env vars json) lam.get_function_configuration = mock.MagicMock(return_value=lam_new_env) # Used to specify a lambda by name stage = os.environ["DSS_DEPLOYMENT_STAGE"] # Non-JSON fmt with CaptureStdout() as output: lambda_params.lambda_list([], argparse.Namespace(json=False)) # Check that all deployed lambdas are present for lambda_name in lambda_params.get_deployed_lambdas(quiet=True): self.assertIn(f"{lambda_name}", output) # JSON fmt with CaptureStdout() as output: lambda_params.lambda_list([], argparse.Namespace(json=True)) # Check that all deployed lambdas are present all_lams_output = json.loads("\n".join(output)) for lambda_name in lambda_params.get_deployed_lambdas(quiet=True): self.assertIn(lambda_name, all_lams_output) with self.subTest("Get environments of each lambda function"): with mock.patch("dss.operations.lambda_params.ssm_client") as ssm, \ mock.patch("dss.operations.lambda_params.lambda_client") as lam: # lambda_environment() function in dss/operations/lambda_params.py calls get_deployed_lambdas() # (which only does local operations) # then it calls get_deployed_lambda_environment() on every lambda, # which calls lambda_client.get_function() (only called to ensure no exception is thrown) lam.get_function = mock.MagicMock(return_value=None) # then calls lambda_client.get_function_configuration() lam.get_function_configuration = mock.MagicMock(return_value=lam_new_env) # TODO: reduce copypasta # Non-JSON, no lambda name specified with CaptureStdout() as output: lambda_params.lambda_environment([], argparse.Namespace(lambda_name=None, json=False)) # Check that all deployed lambdas are present output = "\n".join(output) for lambda_name in lambda_params.get_deployed_lambdas(quiet=True): self.assertIn(lambda_name, output) # Non-JSON, lambda name specified with CaptureStdout() as output: lambda_params.lambda_environment([], argparse.Namespace(lambda_name=f"dss-{stage}", json=False)) output = "\n".join(output) self.assertIn(f"dss-{stage}", output) # JSON, no lambda name specified with CaptureStdout() as output: lambda_params.lambda_environment([], argparse.Namespace(lambda_name=None, json=True)) # Check that all deployed lambdas are present all_lams_output = json.loads("\n".join(output)) for lambda_name in lambda_params.get_deployed_lambdas(quiet=True): self.assertIn(lambda_name, all_lams_output) # JSON, lambda name specified with CaptureStdout() as output: lambda_params.lambda_environment([], argparse.Namespace(lambda_name=f"dss-{stage}", json=True)) all_lams_output = json.loads("\n".join(output)) self.assertIn(f"dss-{stage}", all_lams_output) with self.subTest("Update (set) existing lambda parameters"): with mock.patch("dss.operations.lambda_params.ssm_client") as ssm, \ mock.patch("dss.operations.lambda_params.lambda_client") as lam: # Mock the same way we did for create new param above. # First we mock the SSM param store ssm.get_parameter = mock.MagicMock(return_value=ssm_new_env) ssm.put_parameter = mock.MagicMock(return_value=None) # Next we mock the lambda client lam.get_function = mock.MagicMock(return_value=None) lam.get_function_configuration = mock.MagicMock(return_value=lam_new_env) lam.update_function_configuration = mock.MagicMock(return_value=None) # Dry run
<gh_stars>0 import networkx as nx import tapnx as tapnx import tapnx.utils_graph as utils_graph #from networkx.algorithms.shortest_paths.weighted import _weight_function #from networkx.algorithms.shortest_paths.weighted import _dijkstra_multisource from networkx.algorithms.shortest_paths.generic import _build_paths_from_predecessors import matplotlib.pyplot as plt from collections import defaultdict import numpy as np import time as time def shortest_paths_pred(G,pred): paths = dict() dists = dict() # loop through all nodes in topological order. # store shortest path to current node as sp[node] = sp[pred] + dist(pred, node) for v in pred.keys(): # access the predecessor if pred[v]: u = pred[v][0] dists[v] = dists[u] + G[u][v]['weight'] paths[v] = paths[u] + [v] else: dists[v] = 0 paths[v] = [v] return dists, paths def get_edges_from_pred(pred): edges = [] # loop through all nodes in topological order. # store shortest path to current node as sp[node] = sp[pred] + dist(pred, node) for v in pred.keys(): # access the predecessor if pred[v]: for u in pred[v]: edges.append((u,v)) return edges def shortest_path_dag(G, s): adj_list = nx.to_dict_of_lists(G) stack = list(nx.topological_sort(G)) dist = defaultdict(lambda: float("Inf")) paths = dict() dist[s] = 0 paths[s] = [s] #print(stack) #print(dist) # Process vertices in topological order for u in stack: # Update distances of all adjacent vertices for v in adj_list[u]: if dist[v] > dist[u] + G[u][v]['weight']: dist[v] = dist[u] + G[u][v]['weight'] paths[v] = paths[u] + [v] return dist, paths def longest_path_dag(G, s): adj_list = nx.to_dict_of_lists(G) stack = list(nx.topological_sort(G)) dist = defaultdict(lambda: -float("Inf")) paths = dict() dist[s] = 0 paths[s] = [s] #print(stack) #print(dist) # Process vertices in topological order for u in stack: # Update distances of all adjacent vertices for v in adj_list[u]: if dist[v] < dist[u] + G[u][v]['weight']: dist[v] = dist[u] + G[u][v]['weight'] paths[v] = paths[u] + [v] return dist, paths def divergence_node(shortest_path, longest_path): divergence_node = None # reverse the shortest list nodes = shortest_path[::-1] # scan the nodes in reverse order, exclude last node for u in shortest_path[::-1][1:]: if u in longest_path: divergence_node = u break return divergence_node def algorithm_b(G, trips): no_edges = G.graph['no_edges'] # compute shortest path trees for all origins # return a dict {origin:{B:networkx graph, x:numpy array (length is no edges in G not B!)}} bushes = initialise_bushes(G,trips,no_edges) #bushes = drop_edges(bushes) for origin, bush_dict in bushes.items(): fig, ax = tapnx.plot_graph(bush_dict['bush'], edge_labels=True) plt.show() x = np.zeros(no_edges) # edge attributes used in the calculation of edge travel times a = utils_graph.get_np_array_from_edge_attribute(G, 'a') b = utils_graph.get_np_array_from_edge_attribute(G, 'b') c = utils_graph.get_np_array_from_edge_attribute(G, 'c') n = utils_graph.get_np_array_from_edge_attribute(G, 'n') # update the travel times and derivatives t, t_prime = update_edge_labels(x,a,b,c,n) # update graph weights utils_graph.update_edge_attribute(G, 'weight', t) # update bush weights, required for shortest paths and longest paths bushes = update_bush_weights(bushes, t) # this computes U, L, shortest_paths, longest_paths bushes = update_labels(bushes) # all or nothing assignment bushes = assign_initial_flows(bushes, trips) # compute the total flow on edges from all bushes x = compute_total_flow(bushes, no_edges) # update the travel times and derivatives t, t_prime = update_edge_labels(x,a,b,c,n) # update bush weights, required for shortest paths and longest paths bushes = update_bush_weights(bushes, t) # this computes U, L, shortest_paths, longest_paths bushes = update_labels(bushes) # drop links (if shortest path only computed for destinations, not necessary) bushes = drop_edges(bushes) # this is needed as original bush connects all destinations, however after assignment, some edges # have zero flow and are thus removed, this may disconnected nodes who have a demand of 0 #bushes = clean_up_disconnected_nodes(bushes) # add shortcuts bushes = add_shortcut_edges(bushes, G, t) # update bush weights, required for shortest paths and longest paths bushes = update_bush_weights(bushes, t) i = 1 while True: # this computes U, L, shortest_paths, longest_paths #bushes = update_labels(bushes) # using the shortest_paths and the current flow, compute AEC measure # requires the current flow and current shortest paths, i.e. calculate AEC after computing the new # shortest paths #AEC = aec() # convergence test #if AEC < tol: if i > 5: break for origin, bush_dict in bushes.items(): print('equilibriating bush for origin {}'.format(origin)) while True: # update all_bushes with new weights update_bush_weights(bushes, t) # update bush labels bush_dict = update_bush_labels(bush_dict) # equilibriate bush bush_dict = equilibriate_bush(bush_dict, t_prime, bushes, no_edges, a, b, c, n) # compute total flow x = compute_total_flow(bushes, no_edges) # compute t and t_prime t, t_prime = update_edge_labels(x,a,b,c,n) # update all_bushes with new weights update_bush_weights(bushes, t) #update bush labels bush_dict = update_bush_labels(bush_dict) # drop edges for bush bush_dict, dropped = drop_bush_edges(bush_dict) # add shortcuts for bush bush_dict, no_edges_added = add_shortcut_bush_edges(bush_dict, G, t, dropped) if no_edges_added == 0: break # equilibriate the bushes by shifting flow from longest path to shortest path #bushes = equilibriate_bushes(bushes, t_prime) # compute the total flow on edges from all bushes #x = compute_total_flow(bushes, no_edges) # update the travel times and derivatives #t, t_prime = update_edge_labels(x,a,b,c,n) # update bush weights, required for shortest paths and longest paths #bushes = update_bush_weights(bushes, t) # this computes U, L, shortest_paths, longest_paths #bushes = update_labels(bushes) # drop links (if shortest path only computed for destinations, not necessary) #bushes = drop_edges(bushes) #bushes = clean_up_disconnected_nodes(bushes) # add shortcuts #bushes = add_shortcut_edges(bushes, G, t) # update bush weights, required for shortest paths and longest paths # MAY BE A MORE EFFICIENT WAY TO DO THIS #bushes = update_bush_weights(bushes, t) # for origin, bush_dict in bushes.items(): # fig, ax = tapnx.plot_graph(bush_dict['bush'], edge_labels=True) # plt.show() print(i) print(x) i += 1 # intialise a set of bushes for each origin # note that this computes a bush to every destination, update to only include destinations. subset of pred?? # returns a dict {origin: networkx Graph} def initialise_bushes(G, trips, no_edges): bushes = dict() for origin, destinations in trips.items(): pred, distance = nx.dijkstra_predecessor_and_distance(G, origin, cutoff=None, weight="weight") pred = {key:[value[0]] for key, value in pred.items() if value} edges = get_edges_from_pred(pred) B = G.edge_subgraph(edges).copy() bushes[origin] = {'bush':B, 'x':np.zeros(no_edges), 'L':{}, 'U':{}, 'L_paths':{}, 'U_paths':{}, 'destinations':[], 'origin':origin} return bushes def assign_initial_flows(bushes, trips): for origin, destinations in trips.items(): bush_dict = bushes[origin] for destination in destinations: demand = trips[origin][destination] if not ((demand == 0) or (demand == np.nan)): B = bush_dict['bush'] demand = trips[origin][destination] shortest_path = bush_dict['L_paths'][int(destination)] path_edges = [B[u][v]['id'] for u,v in utils_graph.edges_from_path(shortest_path)] bush_dict['x'][path_edges] += demand bush_dict['destinations'].append(destination) return bushes def compute_total_flow(bushes, no_edges): x = np.zeros(no_edges) for origin, B in bushes.items(): x += B['x'] return x def update_edge_labels(x,a,b,c,n): t = _edge_func_np(x,a,b,c,n) t_prime = _edge_func_derivative_np(x,a,b,c,n) return t, t_prime def update_bush_weights(bushes,t): for origin, bush_dict in bushes.items(): B = bush_dict['bush'] edge_ids = [B[u][v]['id'] for u,v in sorted(B.edges())] B = utils_graph.update_edge_attribute(B, 'weight', t[edge_ids]) return bushes # update the labels for each of the bushes def update_labels(bushes): for origin, bush_dict in bushes.items(): B = bush_dict['bush'] bush_dict['L'], bush_dict['L_paths'] = shortest_path_dag(B,origin) bush_dict['U'], bush_dict['U_paths'] = longest_path_dag(B,origin) return bushes def update_bush_labels(bush_dict): B = bush_dict['bush'] origin = bush_dict['origin'] bush_dict['L'], bush_dict['L_paths'] = shortest_path_dag(B,origin) bush_dict['U'], bush_dict['U_paths'] = longest_path_dag(B,origin) return bush_dict # drop any edge in the bush with zero flow def drop_bush_edges(bush_dict): dropped = [] candidate_edges_for_removal = [] #fig, ax = tapnx.plot_graph(bush_dict['bush'], edge_labels=True) for u,v in bush_dict['bush'].edges(): edge_id = G[u][v]['id'] x = bush_dict['x'] if x[edge_id] == 0: #drop edge if it does not cause an isolate if bush_dict['bush'].in_degree(v) > 1: candidate_edges_for_removal.append((u,v)) for u,v in candidate_edges_for_removal: if bush_dict['bush'].in_degree(v) > 1: #print('removing edge ({},{})'.format(u,v)) bush_dict['bush'].remove_edge(u,v) dropped.append((u,v)) #else: # print('removing edge would result in a isolate({},{})'.format(u,v)) #fig, ax = tapnx.plot_graph(bush_dict['bush'], edge_labels=True) #plt.show() return bush_dict, dropped # drop any edge in the bush with zero flow def drop_edges(bushes): for origin, bush_dict in bushes.items(): candidate_edges_for_removal = [] #fig, ax = tapnx.plot_graph(bush_dict['bush'], edge_labels=True) for u,v in bush_dict['bush'].edges(): edge_id = G[u][v]['id'] x = bush_dict['x'] if x[edge_id] == 0: #drop edge if it does not cause an isolate if bush_dict['bush'].in_degree(v) > 1: candidate_edges_for_removal.append((u,v)) for u,v in candidate_edges_for_removal: if bush_dict['bush'].in_degree(v) > 1: #print('removing edge ({},{})'.format(u,v)) bush_dict['bush'].remove_edge(u,v) #else: # print('removing edge would result in a isolate({},{})'.format(u,v)) #fig, ax = tapnx.plot_graph(bush_dict['bush'], edge_labels=True) #plt.show() return bushes def clean_up_disconnected_nodes(bushes): for origin, bush_dict in bushes.items(): B = bush_dict['bush'] isolates = list(nx.isolates(B)) B.remove_nodes_from(isolates) return bushes def add_shortcut_bush_edges(bush_dict, G, t, dropped): G_edges = set(G.edges()) B = bush_dict['bush'] origin = bush_dict['origin']
def knight_walk_distance(src, dest, board_size = 8): """ The first challenge was to: Compute the number of chess' knight's jumps from src to dest. The squares of a chess board are enumerated sequentially from left to right and top to bottom, starting from 0. src = value for the position of the initial position dest = value for the position of the destination What it does is Breadth-first-search (https://en.wikipedia.org/wiki/Breadth-first_search) The challenge only required 8x8 boards, if I remember correctly. """ from collections import deque def inside(row, col): return (0 <= row and row <= board_size-1 and 0 <= col and col <= board_size-1) # To store if the position has been visited. board = [[False]*board_size for i in range(board_size)] # Deltas that move you like a knight delta_row = [-2, -1, 1, 2, -2, -1, 1, 2] delta_col = [-1, -2, -2, -1, 1, 2, 2, 1] # row and column of the initial position row, col = src//board_size, src%board_size board[row][col] = True # row and column of the destination dest_row, dest_col = dest//board_size, dest%board_size # End-points of the trajectories that still need to be explored q = deque([[row,col,0]]) while (len(q) != 0): t = q.popleft() # Go o the destination if t[0] == dest_row and t[1] == dest_col: return t[2] # Try each knight's jump from where we are now for i in range(8): newpos_row = t[0] + drow[i] newpos_col = t[1] + dcol[i] inSideIs = inside(newpos_row, newpos_col) if inSideIs: # the new position is inside the board. # Let's see if we have been here before. boardVisited = (board[newpos_row][newpos_col] == True) if inSideIs and not boardVisited: # The new position is inside the board and was not # visited before. Add it to the queue of routs to try. board[newpos_row][newpos_col] = True q.append([newpos_row, newpos_col, t[2] + 1]) return 0 # What is this? Why are you here? # And because one must have fun with an easter egg ... def knight_walk_distance_catched(src,dest): """ Returns the number of chess knight's jumps from src to dest. The squares of a chess board are enumerated sequentially from left to right and top to bottom. src = value for the position of the initial position dest = value for the position of the destination This one just has the solutions computed by the previous function. SOLUTIONS = [[0] * 64 for i in range(64)] for i in range(64): for j in range(64): SOLUTIONS[i][j] = knight_walk_distance(i,j) with open('SOLUTIONS.txt','w') as outfile: outfile.write(str(SOLUTIONS)) """ # For an 8 x 8 board we can just compute all solutions # using knight_walk_distance(src, dest, board_size = 8) # and just return the saved values each time. SOLUTIONS = [[0, 3, 2, 3, 2, 3, 4, 5, 3, 4, 1, 2, 3, 4, 3, 4, 2, 1, 4, 3, 2, 3, 4, 5, 3, 2, 3, 2, 3, 4, 3, 4, 2, 3, 2, 3, 4, 3, 4, 5, 3, 4, 3, 4, 3, 4, 5, 4, 4, 3, 4, 3, 4, 5, 4, 5, 5, 4, 5, 4, 5, 4, 5, 6], [3, 0, 3, 2, 3, 2, 3, 4, 2, 3, 2, 1, 2, 3, 4, 3, 1, 2, 1, 4, 3, 2, 3, 4, 2, 3, 2, 3, 2, 3, 4, 3, 3, 2, 3, 2, 3, 4, 3, 4, 4, 3, 4, 3, 4, 3, 4, 5, 3, 4, 3, 4, 3, 4, 5, 4, 4, 5, 4, 5, 4, 5, 4, 5], [2, 3, 0, 3, 2, 3, 2, 3, 1, 2, 3, 2, 1, 2, 3, 4, 4, 1, 2, 1, 4, 3, 2, 3, 3, 2, 3, 2, 3, 2, 3, 4, 2, 3, 2, 3, 2, 3, 4, 3, 3, 4, 3, 4, 3, 4, 3, 4, 4, 3, 4, 3, 4, 3, 4, 5, 5, 4, 5, 4, 5, 4, 5, 4], [3, 2, 3, 0, 3, 2, 3, 2, 2, 1, 2, 3, 2, 1, 2, 3, 3, 4, 1, 2, 1, 4, 3, 2, 2, 3, 2, 3, 2, 3, 2, 3, 3, 2, 3, 2, 3, 2, 3, 4, 4, 3, 4, 3, 4, 3, 4, 3, 3, 4, 3, 4, 3, 4, 3, 4, 4, 5, 4, 5, 4, 5, 4, 5], [2, 3, 2, 3, 0, 3, 2, 3, 3, 2, 1, 2, 3, 2, 1, 2, 2, 3, 4, 1, 2, 1, 4, 3, 3, 2, 3, 2, 3, 2, 3, 2, 4, 3, 2, 3, 2, 3, 2, 3, 3, 4, 3, 4, 3, 4, 3, 4, 4, 3, 4, 3, 4, 3, 4, 3, 5, 4, 5, 4, 5, 4, 5, 4], [3, 2, 3, 2, 3, 0, 3, 2, 4, 3, 2, 1, 2, 3, 2, 1, 3, 2, 3, 4, 1, 2, 1, 4, 4, 3, 2, 3, 2, 3, 2, 3, 3, 4, 3, 2, 3, 2, 3, 2, 4, 3, 4, 3, 4, 3, 4, 3, 5, 4, 3, 4, 3, 4, 3, 4, 4, 5, 4, 5, 4, 5, 4, 5], [4, 3, 2, 3, 2, 3, 0, 3, 3, 4, 3, 2, 1, 2, 3, 2, 4, 3, 2, 3, 4, 1, 2, 1, 3, 4, 3, 2, 3, 2, 3, 2, 4, 3, 4, 3, 2, 3, 2, 3, 5, 4, 3, 4, 3, 4, 3, 4, 4, 5, 4, 3, 4, 3, 4, 3, 5, 4, 5, 4, 5, 4, 5, 4], [5, 4, 3, 2, 3, 2, 3, 0, 4, 3, 4, 3, 2, 1, 4, 3, 5, 4, 3, 2, 3, 4, 1, 2, 4, 3, 4, 3, 2, 3, 2, 3, 5, 4, 3, 4, 3, 2, 3, 2, 4, 5, 4, 3, 4, 3, 4, 3, 5, 4, 5, 4, 3, 4, 3, 4, 6, 5, 4, 5, 4, 5, 4, 5], [3, 2, 1, 2, 3, 4, 3, 4, 0, 3, 2, 3, 2, 3, 4, 5, 3, 2, 1, 2, 3, 4, 3, 4, 2, 1, 4, 3, 2, 3, 4, 5, 3, 2, 3, 2, 3, 4, 3, 4, 2, 3, 2, 3, 4, 3, 4, 5, 3, 4, 3, 4, 3, 4, 5, 4, 4, 3, 4, 3, 4, 5, 4, 5], [4, 3, 2, 1, 2, 3, 4, 3, 3, 0, 3, 2, 3, 2, 3, 4, 2, 3, 2, 1, 2, 3, 4, 3, 1, 2, 1, 4, 3, 2, 3, 4, 2, 3, 2, 3, 2, 3, 4, 3, 3, 2, 3, 2, 3, 4, 3, 4, 4, 3, 4, 3, 4, 3, 4, 5, 3, 4, 3, 4, 3, 4, 5, 4], [1, 2, 3, 2, 1, 2, 3, 4, 2, 3, 0, 3, 2, 3, 2, 3, 1, 2, 3, 2, 1, 2, 3, 4, 4, 1, 2, 1, 4, 3, 2, 3, 3, 2, 3, 2, 3, 2, 3, 4, 2, 3, 2, 3, 2, 3, 4, 3, 3, 4, 3, 4, 3, 4, 3, 4, 4, 3, 4, 3, 4, 3, 4, 5], [2, 1, 2, 3, 2, 1, 2, 3, 3, 2, 3, 0, 3, 2, 3, 2, 2, 1, 2, 3, 2, 1, 2, 3, 3, 4, 1, 2, 1, 4, 3, 2, 2, 3, 2, 3, 2, 3, 2, 3, 3, 2, 3, 2, 3, 2, 3, 4, 4, 3, 4, 3, 4, 3, 4, 3, 3, 4, 3, 4, 3, 4, 3, 4], [3, 2, 1, 2, 3, 2, 1, 2, 2, 3, 2, 3, 0, 3, 2, 3, 3, 2, 1, 2, 3, 2, 1,
import numpy as np import numpy.ma as ma from numpy import linalg as LA import tsstats #from numba import jit from wormtracker import Logger class WormTrajectoryPostProcessor: ## static properties! # bad frame settings filterByWidth = True filterByLength = True widthThreshold = (0.7, 1.3) lengthThreshold = (0.9, 1.1) filterBySpeed = True maxSpeed = 1000 # segment settings max_n_missing = 3 max_d_um = 10. max_segment_frames = 10000 min_segment_size = 150 # head assignment settings (centoid only method) headMinSpeed = 40. # Min <s> for head assignment by leading end headMinLeading = 1.3 # Min relative time leading for head headMinRelSpeed = 1.1 # Min relative end speed for head headMinRelBrightness = 0.2 # Min relative brightness for head # head assignment settings (posture method) headVarianceMinRatio = 1.2 # Min ratio of head to tail posture variation # head assignment settings (posture dynamics method) headDeltaCorrelation = 0.05 bodyWaveDelay = 0.08 # smoothing useSmoothingFilterDerivatives = True filterWindow = 1. # smoothing filter window size def __init__(self, h5obj, strain, name): self.h5obj = h5obj self.strain = strain self.name = name self.h5ref = h5obj['worms'][strain][name] self.lengths = self.h5ref['length'][...] self.widths = self.h5ref['width'][...] self.frameRate = h5obj['/video/frameRate'][0] self.pixelsPerMicron = h5obj['/video/pixelsPerMicron'][0] self.maxFrameNumber = self.h5ref['time'].shape[0] self.nAngles = self.h5ref['posture'].shape[1] self.badFrames = np.zeros((self.maxFrameNumber,), dtype='bool') self.haveSkeleton = np.zeros((self.maxFrameNumber,), dtype='bool') self.skeleton = None self.posture = None self.length = None self.width = None self.t = self.h5ref['time'][...] self.X = ma.array(self.h5ref['centroid'][...] / self.pixelsPerMicron) self.Xhead = ma.zeros(self.X.shape) self.Xtail = ma.zeros(self.X.shape) self.v = ma.zeros(self.X.shape) self.s = ma.zeros((self.maxFrameNumber,)) self.phi = ma.zeros((self.maxFrameNumber,)) self.psi = ma.zeros((self.maxFrameNumber,)) self.dpsi = ma.zeros((self.maxFrameNumber,)) self.Ctheta = None self.ltheta = None self.vtheta = None self.usePosturalHeadAssignment = True def postProcess(self): Logger.logPrint('Identifying bad frames...') self.identifyBadFrames() Logger.logPrint('Extracting postural data...') self.extractPosturalData() Logger.logPrint('Fixing order of postural data...') self.fixPosturalOrdering() Logger.logPrint('Segmenting trajectory...') self.segment() Logger.logPrint('Assigning head...') if self.usePosturalHeadAssignment: self.assignHeadTail() else: self.assignHeadTailCentroidOnly() Logger.logPrint('Ordering postural data head to tail...') self.orderHeadTail() Logger.logPrint('Calculating centroid motion variables...') self.calculateCentroidMeasurements() Logger.logPrint('Calculating postural measurements...') self.calculatePosturalMeasurements() def identifyBadFrames(self): badFrames = np.logical_or(self.lengths == 0, self.widths == 0) self.length = np.median(self.lengths[np.logical_not(badFrames)]) self.width = np.median(self.widths[np.logical_not(badFrames)]) if self.filterByWidth: badFrames = np.logical_or(badFrames, np.logical_or(self.widths < self.widthThreshold[0]*self.width, self.widths > self.widthThreshold[1]*self.width)) if self.filterByLength: badFrames = np.logical_or(badFrames, np.logical_or(self.lengths < self.lengthThreshold[0]*self.length, self.lengths > self.lengthThreshold[1]*self.length)) if self.filterBySpeed: v = ma.zeros(self.X.shape) v[1:-1] = (self.X[2:, :] - self.X[0:-2])/(2.0/self.frameRate) instSpeed = np.sqrt(np.sum(np.power(v, 2), axis=1)) badFrames = np.logical_or(badFrames, instSpeed > self.maxSpeed) self.badFrames = badFrames def extractPosturalData(self): # import skeleton splines self.skeleton = self.h5ref['skeletonSpline'][...] self.posture = self.h5ref['posture'][...] self.haveSkeleton = np.array([np.any(skeleton > 0) and ~badFrame for skeleton, badFrame in zip(self.skeleton, self.badFrames)]) # @jit @staticmethod def skeletonDist(skeleton1, skeleton2): distEachPoint = np.sqrt(np.sum(np.power(skeleton1 - skeleton2, 2), axis=1)) # return average distance per spline point return np.sum(distEachPoint)/skeleton1.shape[0] def fixPosturalOrdering(self): # compare possible skeleton orientations interframe_d = np.empty((self.maxFrameNumber, 2)) * np.NaN flipped = np.zeros((self.maxFrameNumber,), dtype=bool) nFromLastGood = np.empty((self.maxFrameNumber,)) * np.NaN for i in xrange(1, self.maxFrameNumber): # check whether there is a previous skeleton to compare if not self.haveSkeleton[i] or not np.any(self.haveSkeleton[:i]): continue ip = np.where(self.haveSkeleton[:i])[0][-1] # last skeleton nFromLastGood[i] = i - ip interframe_d[i, 0] = self.skeletonDist( np.squeeze(self.skeleton[i, :, :]), np.squeeze(self.skeleton[ip, :, :])) # flipped orientation interframe_d[i, 1] = self.skeletonDist( np.flipud(np.squeeze(self.skeleton[i, :, :])), np.squeeze(self.skeleton[ip])) if interframe_d[i, 1] < interframe_d[i, 0]: # if the flipped orientation is better, flip the data flipped[i] = not flipped[ip] else: flipped[i] = flipped[ip] self.interframe_d = interframe_d # flip data appropriately sel = flipped self.skeleton[sel, :, :] = self.skeleton[sel, ::-1, :] self.posture[sel, :] = self.posture[sel, ::-1] def segment(self): # break video into segments with matched skeletons max_d = self.max_d_um/self.pixelsPerMicron ii = 0 segments = [] while ii < self.maxFrameNumber: begin = ii ii += 1 # Continue segment until >max_n_missing consecutive bad frames # are found, or >max_segment_frames are collected n_missing = 0 last_missing = False while (ii < self.maxFrameNumber and ii - begin < self.max_segment_frames and (np.isnan(self.interframe_d[ii, 0]) or np.min(self.interframe_d[ii, :]) < max_d)): if not self.haveSkeleton[ii]: n_missing += 1 last_missing = True if n_missing > self.max_n_missing: ii += 1 break else: n_missing = 0 last_missing = False ii += 1 segments.append([begin, ii]) self.segments = [segment for segment in segments if segment[1] - segment[0] > self.min_segment_size] def assignHeadTail(self): flipSegment = np.zeros((len(self.segments),), dtype='bool') segmentAssignMethod = -np.ones((len(self.segments),), dtype='int8') npoints = round(self.posture.shape[1]*0.1) A = ma.array(self.posture) A[self.badFrames] = ma.masked A[~self.haveSkeleton] = ma.masked for i, segment in enumerate(self.segments): b = segment[0] e = segment[1] # posture variance method v = A.std(axis=0) npoints=5 vh = v[:npoints].sum() vt = v[-npoints:].sum() # calculate dynamics measures hm = _headMoveMeasure(A[b:e,:]) bw = _bodyWaveMeasure(A[b:e,:]) # head has more variance # head has oscillatory head movement unlike tail (negative delta correlation measure) # body wave delay is positive if vh/vt > self.headVarianceMinRatio: # not flipped segmentAssignMethod[i] = 1 elif vt/vh > self.headVarianceMinRatio: # flipped flipSegment[i] = True segmentAssignMethod[i] = 1 elif np.abs(bw) > self.bodyWaveDelay: segmentAssignMethod[i] = 3 if bw < -self.bodyWaveDelay: flipSegment[i] = True elif np.abs(hm) > self.headDeltaCorrelation: segmentAssignMethod[i] = 2 if hm < -self.headDeltaCorrelation: flipSegment[i] = True else: segmentAssignMethod[i] = 0 # can't assign self.flipSegment = flipSegment self.segmentAssignMethod = segmentAssignMethod def assignHeadTailPostureVariance(self): flipSegment = np.zeros((len(self.segments),), dtype='bool') segmentAssignMethod = -np.ones((len(self.segments),), dtype='int8') npoints = round(self.posture.shape[1]*0.1) for i, segment in enumerate(self.segments): b = segment[0] e = segment[1] # calculate std at each posture position over segment v = self.posture[b:e, :].std(axis=0) # calculate total std for 10% from each end vh = v[:npoints].sum() vt = v[-npoints:].sum() # head has higher variance if vh/vt > self.headVarianceMinRatio: # not flipped segmentAssignMethod[i] = 3 elif vt/vh > self.headVarianceMinRatio: # flipped flipSegment[i] = True segmentAssignMethod[i] = 3 else: segmentAssignMethod[i] = 0 # can't assign self.flipSegment = flipSegment self.segmentAssignMethod = segmentAssignMethod def assignHeadTailCentroidOnly(self): flipSegment = np.zeros((len(self.segments),), dtype='bool') segmentAssignMethod = -np.ones((len(self.segments),), dtype='int8') X = ma.array(self.h5ref['centroid'][...] / self.pixelsPerMicron) X[self.badFrames, :] = ma.masked dt = 1/self.frameRate (v, s, phi) = _getMotionVariables(X, dt) Xhead = np.squeeze(self.skeleton[:, 0, :] - self.h5ref['midpoint'][...]) Xhead[self.badFrames, :] = ma.masked Xtail = np.squeeze(self.skeleton[:, -1, :] - self.h5ref['midpoint'][...]) Xtail[self.badFrames, :] = ma.masked for i, segment in enumerate(self.segments): # method 1: head leads during movement # first check worm is actually moving significantly b = segment[0] e = segment[1] if (np.median(s[b:e].compressed()) > self.headMinSpeed): # then calculate relative time moving in each direction phi_ends = np.zeros((e-b, 2)) phi_ends[:, 0] = np.arctan2((Xhead[b:e, 1] - X[b:e, 1]), (Xhead[b:e, 0] - X[b:e, 0])) phi_ends[:, 1] = np.arctan2((Xtail[b:e, 1] - X[b:e, 1]), (Xtail[b:e, 0] - X[b:e, 0])) rphi_ends = np.cos(phi_ends.T - phi[b:e]).T first_leading = np.sum((rphi_ends[:, 0] > rphi_ends[:, 1]).compressed()) last_leading = np.sum((rphi_ends[:, 1] > rphi_ends[:, 0]).compressed()) if (max(first_leading, last_leading) / min(first_leading, last_leading) > self.headMinLeading): segmentAssignMethod[i] = 1 if last_leading > first_leading: flipSegment[i] = True continue # method 2: head moves more than tail (vh, sh, phih) = _getMotionVariables(Xhead[b:e, :], dt) (vt, st, phit) = _getMotionVariables(Xtail[b:e, :], dt) mu_sh = np.mean(sh.compressed()) mu_st = np.mean(st.compressed()) if (max(mu_sh, mu_st) / min(mu_sh, mu_st) > self.headMinRelSpeed): segmentAssignMethod[i] = 2 if mu_st > mu_sh: flipSegment[i] = True continue # method 3: head is brighter # this method isn't very reliable and isn't being used self.flipSegment = flipSegment self.segmentAssignMethod = segmentAssignMethod def orderHeadTail(self): orientationFixed = np.zeros((self.maxFrameNumber,), dtype='bool') for i, segment in enumerate(self.segments): if self.segmentAssignMethod[i] > 0: b = segment[0] e = segment[1] orientationFixed[b:e] = True if self.flipSegment[i]: self.skeleton[b:e, :, :] = \ np.fliplr(self.skeleton[b:e, :, :]) self.posture[b:e, :] = \ np.fliplr(self.posture[b:e, :]) self.orientationFixed = orientationFixed def calculateCentroidMeasurements(self): self.X[self.badFrames, :] = ma.masked if not self.useSmoothingFilterDerivatives: self.v[1:-1] = (self.X[2:, :] - self.X[0:-2])/(2.0/self.frameRate) else: # use a cubic polynomial filter to estimate the velocity self.v = ma.zeros(self.X.shape) halfWindow = int(np.round(self.filterWindow/2.*self.frameRate)) for i in xrange(halfWindow, self.v.shape[0]-halfWindow): start = i-halfWindow mid = i finish = i+halfWindow+1 if not np.any(self.X.mask[start:finish,:]): px = np.polyder(np.polyfit(self.t[start:finish]-self.t[mid], self.X[start:finish, 0], 3)) py = np.polyder(np.polyfit(self.t[start:finish]-self.t[mid], self.X[start:finish, 1], 3)) self.v[i,:] = [np.polyval(px, 0), np.polyval(py, 0)] else: self.v[i,:] = ma.masked self.s = ma.sqrt(ma.sum(ma.power(self.v, 2), axis=1)) self.phi = ma.arctan2(self.v[:, 1], self.v[:, 0]) self.t[self.badFrames] = ma.masked self.X[self.badFrames, :] = ma.masked self.v[self.badFrames, :] = ma.masked self.s[self.badFrames] = ma.masked self.phi[self.badFrames] = ma.masked def calculatePosturalMeasurements(self): self.Xhead = ma.array(ma.squeeze(self.skeleton[:, 0, :])) self.Xhead = ((self.Xhead + self.h5ref['boundingBox'][:, :2]) / self.pixelsPerMicron) self.Xhead[np.logical_not(self.orientationFixed), :] = ma.masked self.Xtail = ma.array(np.squeeze(self.skeleton[:, -1, :])) self.Xtail = ((self.Xtail + self.h5ref['boundingBox'][:, :2]) / self.pixelsPerMicron) self.Xtail[np.logical_not(self.orientationFixed), :] = ma.masked self.psi = ma.arctan2(self.Xhead[:, 0]-self.X[:, 0], self.Xhead[:,
the extraction process so we don't end up with a corrupted cache. tmp_extraction_dir = tempfile.mkdtemp(dir=os.path.split(extraction_path)[0]) try: if is_zipfile(file_path): with ZipFile(file_path, "r") as zip_file: zip_file.extractall(tmp_extraction_dir) zip_file.close() else: tar_file = tarfile.open(file_path) check_tarfile(tar_file) tar_file.extractall(tmp_extraction_dir) tar_file.close() # Extraction was successful, rename temp directory to final # cache directory and dump the meta data. os.replace(tmp_extraction_dir, extraction_path) meta = _Meta( resource=url_or_filename, cached_path=extraction_path, creation_time=time.time(), extraction_dir=True, size=_get_resource_size(extraction_path), ) meta.to_file() finally: shutil.rmtree(tmp_extraction_dir, ignore_errors=True) return extraction_path return file_path def is_url_or_existing_file(url_or_filename: PathOrStr) -> bool: """ Given something that might be a URL (or might be a local path), determine check if it's url or an existing file path. """ if url_or_filename is None: return False url_or_filename = os.path.expanduser(str(url_or_filename)) parsed = urlparse(url_or_filename) return parsed.scheme in ("http", "https", "s3", "gs") or os.path.exists(url_or_filename) def _split_s3_path(url: str) -> Tuple[str, str]: return _split_cloud_path(url, "s3") def _split_gcs_path(url: str) -> Tuple[str, str]: return _split_cloud_path(url, "gs") def _split_cloud_path(url: str, provider: str) -> Tuple[str, str]: """Split a full s3 path into the bucket name and path.""" parsed = urlparse(url) if not parsed.netloc or not parsed.path: raise ValueError("bad {} path {}".format(provider, url)) bucket_name = parsed.netloc provider_path = parsed.path # Remove '/' at beginning of path. if provider_path.startswith("/"): provider_path = provider_path[1:] return bucket_name, provider_path def _s3_request(func: Callable): """ Wrapper function for s3 requests in order to create more helpful error messages. """ @wraps(func) def wrapper(url: str, *args, **kwargs): try: return func(url, *args, **kwargs) except botocore.exceptions.ClientError as exc: if int(exc.response["Error"]["Code"]) == 404: raise FileNotFoundError("file {} not found".format(url)) else: raise return wrapper def _get_s3_resource(): session = boto3.session.Session() if session.get_credentials() is None: # Use unsigned requests. s3_resource = session.resource( "s3", config=botocore.client.Config(signature_version=botocore.UNSIGNED) ) else: s3_resource = session.resource("s3") return s3_resource @_s3_request def _s3_etag(url: str) -> Optional[str]: """Check ETag on S3 object.""" s3_resource = _get_s3_resource() bucket_name, s3_path = _split_s3_path(url) s3_object = s3_resource.Object(bucket_name, s3_path) return s3_object.e_tag @_s3_request def _s3_get(url: str, temp_file: IO) -> None: """Pull a file directly from S3.""" s3_resource = _get_s3_resource() bucket_name, s3_path = _split_s3_path(url) s3_resource.Bucket(bucket_name).download_fileobj(s3_path, temp_file) def _gcs_request(func: Callable): """ Wrapper function for gcs requests in order to create more helpful error messages. """ @wraps(func) def wrapper(url: str, *args, **kwargs): try: return func(url, *args, **kwargs) except NotFound: raise FileNotFoundError("file {} not found".format(url)) return wrapper def _get_gcs_client(): storage_client = storage.Client() return storage_client def _get_gcs_blob(url: str) -> storage.blob.Blob: gcs_resource = _get_gcs_client() bucket_name, gcs_path = _split_gcs_path(url) bucket = gcs_resource.bucket(bucket_name) blob = bucket.blob(gcs_path) return blob @_gcs_request def _gcs_md5(url: str) -> Optional[str]: """Get GCS object's md5.""" blob = _get_gcs_blob(url) return blob.md5_hash @_gcs_request def _gcs_get(url: str, temp_filename: str) -> None: """Pull a file directly from GCS.""" blob = _get_gcs_blob(url) blob.download_to_filename(temp_filename) def _session_with_backoff() -> requests.Session: """ We ran into an issue where http requests to s3 were timing out, possibly because we were making too many requests too quickly. This helper function returns a requests session that has retry-with-backoff built in. See <https://stackoverflow.com/questions/23267409/how-to-implement-retry-mechanism-into-python-requests-library>. """ session = requests.Session() retries = Retry(total=5, backoff_factor=1, status_forcelist=[502, 503, 504]) session.mount("http://", HTTPAdapter(max_retries=retries)) session.mount("https://", HTTPAdapter(max_retries=retries)) return session def _http_etag(url: str) -> Optional[str]: with _session_with_backoff() as session: response = session.head(url, allow_redirects=True) if response.status_code != 200: raise OSError( "HEAD request failed for url {} with status code {}".format(url, response.status_code) ) return response.headers.get("ETag") def _http_get(url: str, temp_file: IO) -> None: with _session_with_backoff() as session: req = session.get(url, stream=True) req.raise_for_status() content_length = req.headers.get("Content-Length") total = int(content_length) if content_length is not None else None progress = Tqdm.tqdm(unit="B", unit_scale=True, total=total, desc="downloading") for chunk in req.iter_content(chunk_size=1024): if chunk: # filter out keep-alive new chunks progress.update(len(chunk)) temp_file.write(chunk) progress.close() def _find_latest_cached(url: str, cache_dir: PathOrStr) -> Optional[str]: filename = _resource_to_filename(url) cache_path = os.path.join(cache_dir, filename) candidates: List[Tuple[str, float]] = [] for path in glob.glob(cache_path + "*"): if path.endswith(".json") or path.endswith("-extracted") or path.endswith(".lock"): continue mtime = os.path.getmtime(path) candidates.append((path, mtime)) # Sort candidates by modification time, newest first. candidates.sort(key=lambda x: x[1], reverse=True) if candidates: return candidates[0][0] return None class CacheFile: """ This is a context manager that makes robust caching easier. On `__enter__`, an IO handle to a temporarily file is returned, which can be treated as if it's the actual cache file. On `__exit__`, the temporarily file is renamed to the cache file. If anything goes wrong while writing to the temporary file, it will be removed. """ def __init__(self, cache_filename: PathOrStr, mode: str = "w+b", suffix: str = ".tmp") -> None: self.cache_filename = ( cache_filename if isinstance(cache_filename, Path) else Path(cache_filename) ) self.cache_directory = os.path.dirname(self.cache_filename) self.mode = mode self.temp_file = tempfile.NamedTemporaryFile( self.mode, dir=self.cache_directory, delete=False, suffix=suffix ) def __enter__(self): return self.temp_file def __exit__(self, exc_type, exc_value, traceback): self.temp_file.close() if exc_value is None: # Success. logger.debug( "Renaming temp file %s to cache at %s", self.temp_file.name, self.cache_filename ) # Rename the temp file to the actual cache filename. os.replace(self.temp_file.name, self.cache_filename) return True # Something went wrong, remove the temp file. logger.debug("removing temp file %s", self.temp_file.name) os.remove(self.temp_file.name) return False @dataclass class _Meta: """ Any resource that is downloaded to - or extracted in - the cache directory will have a meta JSON file written next to it, which corresponds to an instance of this class. In older versions of AllenNLP, this meta document just had two fields: 'url' and 'etag'. The 'url' field is now the more general 'resource' field, but these old meta files are still compatible when a `_Meta` is instantiated with the `.from_path()` class method. """ resource: str """ URL or normalized path to the resource. """ cached_path: str """ Path to the corresponding cached version of the resource. """ creation_time: float """ The unix timestamp of when the corresponding resource was cached or extracted. """ size: int = 0 """ The size of the corresponding resource, in bytes. """ etag: Optional[str] = None """ Optional ETag associated with the current cached version of the resource. """ extraction_dir: bool = False """ Does this meta corresponded to an extraction directory? """ def to_file(self) -> None: with open(self.cached_path + ".json", "w") as meta_file: json.dump(asdict(self), meta_file) @classmethod def from_path(cls, path: PathOrStr) -> "_Meta": path = str(path) with open(path) as meta_file: data = json.load(meta_file) # For backwards compat: if "resource" not in data: data["resource"] = data.pop("url") if "creation_time" not in data: data["creation_time"] = os.path.getmtime(path[:-5]) if "extraction_dir" not in data and path.endswith("-extracted.json"): data["extraction_dir"] = True if "cached_path" not in data: data["cached_path"] = path[:-5] if "size" not in data: data["size"] = _get_resource_size(data["cached_path"]) return cls(**data) def _hf_hub_download( url, model_identifier: str, filename: Optional[str], cache_dir: PathOrStr = CACHE_DIRECTORY ) -> str: revision: Optional[str] if "@" in model_identifier: repo_id = model_identifier.split("@")[0] revision = model_identifier.split("@")[1] else: repo_id = model_identifier revision = None if filename is not None: hub_url = hf_hub.hf_hub_url(repo_id=repo_id, filename=filename, revision=revision) cache_path = str( hf_hub.cached_download( url=hub_url, library_name="cached_path", library_version=VERSION, cache_dir=cache_dir, ) ) # HF writes it's own meta '.json' file which uses the same format we used to use and still # support, but is missing some fields that we like to have. # So we overwrite it when it we can. with FileLock(cache_path + ".lock", read_only_ok=True): meta = _Meta.from_path(cache_path + ".json") # The file HF writes will have 'resource' set to the 'http' URL corresponding to the 'hf://' URL, # but we want 'resource' to be the original 'hf://' URL. if meta.resource != url: meta.resource = url meta.to_file() else: cache_path = str(hf_hub.snapshot_download(repo_id, revision=revision, cache_dir=cache_dir)) # Need to write the meta file for snapshot downloads if it doesn't exist. with FileLock(cache_path + ".lock", read_only_ok=True): if not os.path.exists(cache_path + ".json"): meta = _Meta( resource=url, cached_path=cache_path, creation_time=time.time(), extraction_dir=True, size=_get_resource_size(cache_path), ) meta.to_file() return cache_path # TODO(joelgrus): do we want to do checksums or anything like that? def get_from_cache(url: str, cache_dir: PathOrStr = CACHE_DIRECTORY) -> str: """ Given a URL, look for the corresponding dataset in the local cache. If it's not there, download it. Then return the path to the cached file. """ if url.startswith("hf://"): # Remove the 'hf://' prefix identifier = url[5:] if identifier.count("/") > 1: filename = "/".join(identifier.split("/")[2:]) model_identifier = "/".join(identifier.split("/")[:2]) return _hf_hub_download(url, model_identifier, filename, cache_dir) elif identifier.count("/") == 1: # 'hf://' URLs like 'hf://xxxx/yyyy' are potentially ambiguous, # because this could refer to either: # 1. the file 'yyyy' in the 'xxxx' repository, or # 2. the repo 'yyyy' under the user/org name 'xxxx'. # We default to (1), but if we
str upload_id: 分片上传ID :param headers: HTTP头部 :type headers: 可以是dict,建议是oss2.CaseInsensitiveDict :return: :class:`RequestResult <oss2.models.RequestResult>` """ logger.debug("Start to abort multipart upload, bucket: {0}, key: {1}, upload_id: {2}".format( self.bucket_name, to_string(key), upload_id)) headers = http.CaseInsensitiveDict(headers) resp = self.__do_object('DELETE', key, params={'uploadId': upload_id}, headers=headers) logger.debug("Abort multipart done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return RequestResult(resp) def list_multipart_uploads(self, prefix='', delimiter='', key_marker='', upload_id_marker='', max_uploads=1000, headers=None): """罗列正在进行中的分片上传。支持分页。 :param str prefix: 只罗列匹配该前缀的文件的分片上传 :param str delimiter: 目录分割符 :param str key_marker: 文件名分页符。第一次调用可以不传,后续设为返回值中的 `next_key_marker` :param str upload_id_marker: 分片ID分页符。第一次调用可以不传,后续设为返回值中的 `next_upload_id_marker` :param int max_uploads: 一次罗列最多能够返回的条目数 :param headers: HTTP头部 :type headers: 可以是dict,建议是oss2.CaseInsensitiveDict :return: :class:`ListMultipartUploadsResult <oss2.models.ListMultipartUploadsResult>` """ logger.debug("Start to list multipart uploads, bucket: {0}, prefix: {1}, delimiter: {2}, key_marker: {3}, " "upload_id_marker: {4}, max_uploads: {5}".format(self.bucket_name, to_string(prefix), delimiter, to_string(key_marker), upload_id_marker, max_uploads)) headers = http.CaseInsensitiveDict(headers) resp = self.__do_object('GET', '', params={'uploads': '', 'prefix': prefix, 'delimiter': delimiter, 'key-marker': key_marker, 'upload-id-marker': upload_id_marker, 'max-uploads': str(max_uploads), 'encoding-type': 'url'}, headers=headers) logger.debug("List multipart uploads done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return self._parse_result(resp, xml_utils.parse_list_multipart_uploads, ListMultipartUploadsResult) def upload_part_copy(self, source_bucket_name, source_key, byte_range, target_key, target_upload_id, target_part_number, headers=None, params=None): """分片拷贝。把一个已有文件的一部分或整体拷贝成目标文件的一个分片。 :source_bucket_name: 源文件所在bucket的名称 :source_key:源文件名称 :param byte_range: 指定待拷贝内容在源文件里的范围。参见 :ref:`byte_range` :target_key: 目的文件的名称 :target_upload_id: 目的文件的uploadid :target_part_number: 目的文件的分片号 :param params: 请求参数 :param headers: HTTP头部 :type headers: 可以是dict,建议是oss2.CaseInsensitiveDict :return: :class:`PutObjectResult <oss2.models.PutObjectResult>` """ headers = http.CaseInsensitiveDict(headers) if params and Bucket.VERSIONID in params: headers[OSS_COPY_OBJECT_SOURCE] = '/' + source_bucket_name + \ '/' + urlquote(source_key, '') + '?versionId=' + params[Bucket.VERSIONID] else: headers[OSS_COPY_OBJECT_SOURCE] = '/' + source_bucket_name + '/' + urlquote(source_key, '') range_string = _make_range_string(byte_range) if range_string: headers[OSS_COPY_OBJECT_SOURCE_RANGE] = range_string logger.debug("Start to upload part copy, source bucket: {0}, source key: {1}, bucket: {2}, key: {3}, range" ": {4}, upload id: {5}, part_number: {6}, headers: {7}".format(source_bucket_name, to_string(source_key),self.bucket_name,to_string(target_key), byte_range, target_upload_id,target_part_number, headers)) if params is None: params = dict() params['uploadId'] = target_upload_id params['partNumber'] = str(target_part_number) resp = self.__do_object('PUT', target_key, params=params,headers=headers) logger.debug("Upload part copy done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return PutObjectResult(resp) def list_parts(self, key, upload_id, marker='', max_parts=1000, headers=None): """列举已经上传的分片。支持分页。 :param headers: HTTP头部 :param str key: 文件名 :param str upload_id: 分片上传ID :param str marker: 分页符 :param int max_parts: 一次最多罗列多少分片 :param headers: HTTP头部 :type headers: 可以是dict,建议是oss2.CaseInsensitiveDict :return: :class:`ListPartsResult <oss2.models.ListPartsResult>` """ logger.debug("Start to list parts, bucket: {0}, key: {1}, upload_id: {2}, marker: {3}, max_parts: {4}".format( self.bucket_name, to_string(key), upload_id, marker, max_parts)) headers = http.CaseInsensitiveDict(headers) resp = self.__do_object('GET', key, params={'uploadId': upload_id, 'part-number-marker': marker, 'max-parts': str(max_parts)}, headers=headers) logger.debug("List parts done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return self._parse_result(resp, xml_utils.parse_list_parts, ListPartsResult) def put_symlink(self, target_key, symlink_key, headers=None): """创建Symlink。 :param str target_key: 目标文件,目标文件不能为符号连接 :param str symlink_key: 符号连接类文件,其实质是一个特殊的文件,数据指向目标文件 :param headers: HTTP头部 :type headers: 可以是dict,建议是oss2.CaseInsensitiveDict :return: :class:`RequestResult <oss2.models.RequestResult>` """ headers = http.CaseInsensitiveDict(headers) headers[OSS_SYMLINK_TARGET] = urlquote(target_key, '') logger.debug("Start to put symlink, bucket: {0}, target_key: {1}, symlink_key: {2}, headers: {3}".format( self.bucket_name, to_string(target_key), to_string(symlink_key), headers)) resp = self.__do_object('PUT', symlink_key, headers=headers, params={Bucket.SYMLINK: ''}) logger.debug("Put symlink done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return RequestResult(resp) def get_symlink(self, symlink_key, params=None, headers=None): """获取符号连接文件的目标文件。 :param str symlink_key: 符号连接类文件 :param dict params: 请求参数 :param headers: HTTP头部 :type headers: 可以是dict,建议是oss2.CaseInsensitiveDict :return: :class:`GetSymlinkResult <oss2.models.GetSymlinkResult>` :raises: 如果文件的符号链接不存在,则抛出 :class:`NoSuchKey <oss2.exceptions.NoSuchKey>` ;还可能抛出其他异常 """ logger.debug( "Start to get symlink, bucket: {0}, symlink_key: {1}".format(self.bucket_name, to_string(symlink_key))) headers = http.CaseInsensitiveDict(headers) if params is None: params = dict() if Bucket.SYMLINK not in params: params[Bucket.SYMLINK] = '' resp = self.__do_object('GET', symlink_key, params=params, headers=headers) logger.debug("Get symlink done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return GetSymlinkResult(resp) def create_bucket(self, permission=None, input=None): """创建新的Bucket。 :param str permission: 指定Bucket的ACL。可以是oss2.BUCKET_ACL_PRIVATE(推荐、缺省)、oss2.BUCKET_ACL_PUBLIC_READ或是 oss2.BUCKET_ACL_PUBLIC_READ_WRITE。 :param input: :class:`BucketCreateConfig <oss2.models.BucketCreateConfig>` object """ if permission: headers = {OSS_CANNED_ACL: permission} else: headers = None data = self.__convert_data(BucketCreateConfig, xml_utils.to_put_bucket_config, input) logger.debug("Start to create bucket, bucket: {0}, permission: {1}, config: {2}".format(self.bucket_name, permission, data)) resp = self.__do_bucket('PUT', headers=headers, data=data) logger.debug("Create bucket done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return RequestResult(resp) def delete_bucket(self): """删除一个Bucket。只有没有任何文件,也没有任何未完成的分片上传的Bucket才能被删除。 :return: :class:`RequestResult <oss2.models.RequestResult>` ":raises: 如果试图删除一个非空Bucket,则抛出 :class:`BucketNotEmpty <oss2.exceptions.BucketNotEmpty>` """ logger.info("Start to delete bucket, bucket: {0}".format(self.bucket_name)) resp = self.__do_bucket('DELETE') logger.debug("Delete bucket done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return RequestResult(resp) def put_bucket_acl(self, permission): """设置Bucket的ACL。 :param str permission: 新的ACL,可以是oss2.BUCKET_ACL_PRIVATE、oss2.BUCKET_ACL_PUBLIC_READ或 oss2.BUCKET_ACL_PUBLIC_READ_WRITE """ logger.debug("Start to put bucket acl, bucket: {0}, acl: {1}".format(self.bucket_name, permission)) resp = self.__do_bucket('PUT', headers={OSS_CANNED_ACL: permission}, params={Bucket.ACL: ''}) logger.debug("Put bucket acl done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return RequestResult(resp) def get_bucket_acl(self): """获取Bucket的ACL。 :return: :class:`GetBucketAclResult <oss2.models.GetBucketAclResult>` """ logger.debug("Start to get bucket acl, bucket: {0}".format(self.bucket_name)) resp = self.__do_bucket('GET', params={Bucket.ACL: ''}) logger.debug("Get bucket acl done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return self._parse_result(resp, xml_utils.parse_get_bucket_acl, GetBucketAclResult) def put_bucket_cors(self, input): """设置Bucket的CORS。 :param input: :class:`BucketCors <oss2.models.BucketCors>` 对象或其他 """ data = self.__convert_data(BucketCors, xml_utils.to_put_bucket_cors, input) logger.debug("Start to put bucket cors, bucket: {0}, cors: {1}".format(self.bucket_name, data)) resp = self.__do_bucket('PUT', data=data, params={Bucket.CORS: ''}) logger.debug("Put bucket cors done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return RequestResult(resp) def get_bucket_cors(self): """获取Bucket的CORS配置。 :return: :class:`GetBucketCorsResult <oss2.models.GetBucketCorsResult>` """ logger.debug("Start to get bucket CORS, bucket: {0}".format(self.bucket_name)) resp = self.__do_bucket('GET', params={Bucket.CORS: ''}) logger.debug("Get bucket CORS done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return self._parse_result(resp, xml_utils.parse_get_bucket_cors, GetBucketCorsResult) def delete_bucket_cors(self): """删除Bucket的CORS配置。""" logger.debug("Start to delete bucket CORS, bucket: {0}".format(self.bucket_name)) resp = self.__do_bucket('DELETE', params={Bucket.CORS: ''}) logger.debug("Delete bucket CORS done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return RequestResult(resp) def put_bucket_lifecycle(self, input): """设置生命周期管理的配置。 :param input: :class:`BucketLifecycle <oss2.models.BucketLifecycle>` 对象或其他 """ data = self.__convert_data(BucketLifecycle, xml_utils.to_put_bucket_lifecycle, input) logger.debug("Start to put bucket lifecycle, bucket: {0}, lifecycle: {1}".format(self.bucket_name, data)) resp = self.__do_bucket('PUT', data=data, params={Bucket.LIFECYCLE: ''}) logger.debug("Put bucket lifecycle done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return RequestResult(resp) def get_bucket_lifecycle(self): """获取生命周期管理配置。 :return: :class:`GetBucketLifecycleResult <oss2.models.GetBucketLifecycleResult>` :raises: 如果没有设置Lifecycle,则抛出 :class:`NoSuchLifecycle <oss2.exceptions.NoSuchLifecycle>` """ logger.debug("Start to get bucket lifecycle, bucket: {0}".format(self.bucket_name)) resp = self.__do_bucket('GET', params={Bucket.LIFECYCLE: ''}) logger.debug("Get bucket lifecycle done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return self._parse_result(resp, xml_utils.parse_get_bucket_lifecycle, GetBucketLifecycleResult) def delete_bucket_lifecycle(self): """删除生命周期管理配置。如果Lifecycle没有设置,也返回成功。""" logger.debug("Start to delete bucket lifecycle, bucket: {0}".format(self.bucket_name)) resp = self.__do_bucket('DELETE', params={Bucket.LIFECYCLE: ''}) logger.debug("Delete bucket lifecycle done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return RequestResult(resp) def get_bucket_location(self): """获取Bucket的数据中心。 :return: :class:`GetBucketLocationResult <oss2.models.GetBucketLocationResult>` """ logger.debug("Start to get bucket location, bucket: {0}".format(self.bucket_name)) resp = self.__do_bucket('GET', params={Bucket.LOCATION: ''}) logger.debug("Get bucket location done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return self._parse_result(resp, xml_utils.parse_get_bucket_location, GetBucketLocationResult) def put_bucket_logging(self, input): """设置Bucket的访问日志功能。 :param input: :class:`BucketLogging <oss2.models.BucketLogging>` 对象或其他 """ data = self.__convert_data(BucketLogging, xml_utils.to_put_bucket_logging, input) logger.debug("Start to put bucket logging, bucket: {0}, logging: {1}".format(self.bucket_name, data)) resp = self.__do_bucket('PUT', data=data, params={Bucket.LOGGING: ''}) logger.debug("Put bucket logging done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return RequestResult(resp) def get_bucket_logging(self): """获取Bucket的访问日志功能配置。 :return: :class:`GetBucketLoggingResult <oss2.models.GetBucketLoggingResult>` """ logger.debug("Start to get bucket logging, bucket: {0}".format(self.bucket_name)) resp = self.__do_bucket('GET', params={Bucket.LOGGING: ''}) logger.debug("Get bucket logging done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return self._parse_result(resp, xml_utils.parse_get_bucket_logging, GetBucketLoggingResult) def delete_bucket_logging(self): """关闭Bucket的访问日志功能。""" logger.debug("Start to delete bucket loggging, bucket: {0}".format(self.bucket_name)) resp = self.__do_bucket('DELETE', params={Bucket.LOGGING: ''}) logger.debug("Put bucket lifecycle done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return RequestResult(resp) def put_bucket_referer(self, input): """为Bucket设置防盗链。 :param input: :class:`BucketReferer <oss2.models.BucketReferer>` 对象或其他 """ data = self.__convert_data(BucketReferer, xml_utils.to_put_bucket_referer, input) logger.debug("Start to put bucket referer, bucket: {0}, referer: {1}".format(self.bucket_name, to_string(data))) resp = self.__do_bucket('PUT', data=data, params={Bucket.REFERER: ''}) logger.debug("Put bucket referer done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return RequestResult(resp) def get_bucket_referer(self): """获取Bucket的防盗链配置。 :return: :class:`GetBucketRefererResult <oss2.models.GetBucketRefererResult>` """ logger.debug("Start to get bucket referer, bucket: {0}".format(self.bucket_name)) resp = self.__do_bucket('GET', params={Bucket.REFERER: ''}) logger.debug("Get bucket referer done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return self._parse_result(resp, xml_utils.parse_get_bucket_referer, GetBucketRefererResult) def get_bucket_stat(self): """查看Bucket的状态,目前包括bucket大小,bucket的object数量,bucket正在上传的Multipart Upload事件个数等。 :return: :class:`GetBucketStatResult <oss2.models.GetBucketStatResult>` """ logger.debug("Start to get bucket stat, bucket: {0}".format(self.bucket_name)) resp = self.__do_bucket('GET', params={Bucket.STAT: ''}) logger.debug("Get bucket stat done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return self._parse_result(resp, xml_utils.parse_get_bucket_stat, GetBucketStatResult) def get_bucket_info(self): """获取bucket相关信息,如创建时间,访问Endpoint,Owner与ACL等。 :return: :class:`GetBucketInfoResult <oss2.models.GetBucketInfoResult>` """ logger.debug("Start to get bucket info, bucket: {0}".format(self.bucket_name)) resp = self.__do_bucket('GET', params={Bucket.BUCKET_INFO: ''}) logger.debug("Get bucket info done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return self._parse_result(resp, xml_utils.parse_get_bucket_info, GetBucketInfoResult) def put_bucket_website(self, input): """为Bucket配置静态网站托管功能。 :param input: :class:`BucketWebsite <oss2.models.BucketWebsite>` """ data = self.__convert_data(BucketWebsite, xml_utils.to_put_bucket_website, input) headers = http.CaseInsensitiveDict() headers['Content-MD5'] = utils.content_md5(data) logger.debug("Start to put bucket website, bucket: {0}, website: {1}".format(self.bucket_name, to_string(data))) resp = self.__do_bucket('PUT', data=data, params={Bucket.WEBSITE: ''}, headers=headers) logger.debug("Put bucket website done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return RequestResult(resp) def get_bucket_website(self): """获取Bucket的静态网站托管配置。 :return: :class:`GetBucketWebsiteResult <oss2.models.GetBucketWebsiteResult>` :raises: 如果没有设置静态网站托管,那么就抛出 :class:`NoSuchWebsite <oss2.exceptions.NoSuchWebsite>` """ logger.debug("Start to get bucket website, bucket: {0}".format(self.bucket_name)) resp = self.__do_bucket('GET', params={Bucket.WEBSITE: ''}) logger.debug("Get bucket website done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return self._parse_result(resp, xml_utils.parse_get_bucket_website, GetBucketWebsiteResult) def delete_bucket_website(self): """关闭Bucket的静态网站托管功能。""" logger.debug("Start to delete bucket website, bucket: {0}".format(self.bucket_name)) resp = self.__do_bucket('DELETE', params={Bucket.WEBSITE: ''}) logger.debug("Delete bucket website done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status)) return RequestResult(resp) def create_live_channel(self, channel_name, input): """创建推流直播频道 :param str channel_name: 要创建的live channel的名称 :param input: LiveChannelInfo类型,包含了live channel中的描述信息 :return: :class:`CreateLiveChannelResult <oss2.models.CreateLiveChannelResult>` """ data = self.__convert_data(LiveChannelInfo, xml_utils.to_create_live_channel, input) logger.debug("Start to create live-channel, bucket: {0}, channel_name: {1}, info:
def Tx_Dia(self): """ Tx_Dia(Pointing_Errors_ff_sptr self) -> float Return current pointing errors transmitter aperture diameter. """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_Tx_Dia(self) def set_Tx_Theta(self, Tx_Theta): """ set_Tx_Theta(Pointing_Errors_ff_sptr self, float Tx_Theta) Set poinintg errors transmitter beam divergence. """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_set_Tx_Theta(self, Tx_Theta) def Tx_Theta(self): """ Tx_Theta(Pointing_Errors_ff_sptr self) -> float Return current poinintg errors transmitter beam divergence. """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_Tx_Theta(self) def set_Rx_Dia(self, Rx_Dia): """ set_Rx_Dia(Pointing_Errors_ff_sptr self, float Rx_Dia) Set pointing errors receiver aperture diameter. """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_set_Rx_Dia(self, Rx_Dia) def Rx_Dia(self): """ Rx_Dia(Pointing_Errors_ff_sptr self) -> float Return current pointing errors receiver aperture diameter. """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_Rx_Dia(self) def set_TempCorr(self, TempCorr): """ set_TempCorr(Pointing_Errors_ff_sptr self, float TempCorr) Set pointing errors temporal correlation. """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_set_TempCorr(self, TempCorr) def TempCorr(self): """ TempCorr(Pointing_Errors_ff_sptr self) -> float Return current pointing errors temporal correlation. """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_TempCorr(self) def set_SampRate(self, SampRate): """ set_SampRate(Pointing_Errors_ff_sptr self, float SampRate) Set poinintg errors sampling rate. """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_set_SampRate(self, SampRate) def SampRate(self): """ SampRate(Pointing_Errors_ff_sptr self) -> float Return current poinintg errors sampling rate. """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_SampRate(self) def history(self): """history(Pointing_Errors_ff_sptr self) -> unsigned int""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_history(self) def declare_sample_delay(self, *args): """ declare_sample_delay(Pointing_Errors_ff_sptr self, int which, int delay) declare_sample_delay(Pointing_Errors_ff_sptr self, unsigned int delay) """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_declare_sample_delay(self, *args) def sample_delay(self, which): """sample_delay(Pointing_Errors_ff_sptr self, int which) -> unsigned int""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_sample_delay(self, which) def output_multiple(self): """output_multiple(Pointing_Errors_ff_sptr self) -> int""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_output_multiple(self) def relative_rate(self): """relative_rate(Pointing_Errors_ff_sptr self) -> double""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_relative_rate(self) def start(self): """start(Pointing_Errors_ff_sptr self) -> bool""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_start(self) def stop(self): """stop(Pointing_Errors_ff_sptr self) -> bool""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_stop(self) def nitems_read(self, which_input): """nitems_read(Pointing_Errors_ff_sptr self, unsigned int which_input) -> uint64_t""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_nitems_read(self, which_input) def nitems_written(self, which_output): """nitems_written(Pointing_Errors_ff_sptr self, unsigned int which_output) -> uint64_t""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_nitems_written(self, which_output) def max_noutput_items(self): """max_noutput_items(Pointing_Errors_ff_sptr self) -> int""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_max_noutput_items(self) def set_max_noutput_items(self, m): """set_max_noutput_items(Pointing_Errors_ff_sptr self, int m)""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_set_max_noutput_items(self, m) def unset_max_noutput_items(self): """unset_max_noutput_items(Pointing_Errors_ff_sptr self)""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_unset_max_noutput_items(self) def is_set_max_noutput_items(self): """is_set_max_noutput_items(Pointing_Errors_ff_sptr self) -> bool""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_is_set_max_noutput_items(self) def set_min_noutput_items(self, m): """set_min_noutput_items(Pointing_Errors_ff_sptr self, int m)""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_set_min_noutput_items(self, m) def min_noutput_items(self): """min_noutput_items(Pointing_Errors_ff_sptr self) -> int""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_min_noutput_items(self) def max_output_buffer(self, i): """max_output_buffer(Pointing_Errors_ff_sptr self, int i) -> long""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_max_output_buffer(self, i) def set_max_output_buffer(self, *args): """ set_max_output_buffer(Pointing_Errors_ff_sptr self, long max_output_buffer) set_max_output_buffer(Pointing_Errors_ff_sptr self, int port, long max_output_buffer) """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_set_max_output_buffer(self, *args) def min_output_buffer(self, i): """min_output_buffer(Pointing_Errors_ff_sptr self, int i) -> long""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_min_output_buffer(self, i) def set_min_output_buffer(self, *args): """ set_min_output_buffer(Pointing_Errors_ff_sptr self, long min_output_buffer) set_min_output_buffer(Pointing_Errors_ff_sptr self, int port, long min_output_buffer) """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_set_min_output_buffer(self, *args) def pc_noutput_items(self): """pc_noutput_items(Pointing_Errors_ff_sptr self) -> float""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_noutput_items(self) def pc_noutput_items_avg(self): """pc_noutput_items_avg(Pointing_Errors_ff_sptr self) -> float""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_noutput_items_avg(self) def pc_noutput_items_var(self): """pc_noutput_items_var(Pointing_Errors_ff_sptr self) -> float""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_noutput_items_var(self) def pc_nproduced(self): """pc_nproduced(Pointing_Errors_ff_sptr self) -> float""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_nproduced(self) def pc_nproduced_avg(self): """pc_nproduced_avg(Pointing_Errors_ff_sptr self) -> float""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_nproduced_avg(self) def pc_nproduced_var(self): """pc_nproduced_var(Pointing_Errors_ff_sptr self) -> float""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_nproduced_var(self) def pc_input_buffers_full(self, *args): """ pc_input_buffers_full(Pointing_Errors_ff_sptr self, int which) -> float pc_input_buffers_full(Pointing_Errors_ff_sptr self) -> pmt_vector_float """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_input_buffers_full(self, *args) def pc_input_buffers_full_avg(self, *args): """ pc_input_buffers_full_avg(Pointing_Errors_ff_sptr self, int which) -> float pc_input_buffers_full_avg(Pointing_Errors_ff_sptr self) -> pmt_vector_float """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_input_buffers_full_avg(self, *args) def pc_input_buffers_full_var(self, *args): """ pc_input_buffers_full_var(Pointing_Errors_ff_sptr self, int which) -> float pc_input_buffers_full_var(Pointing_Errors_ff_sptr self) -> pmt_vector_float """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_input_buffers_full_var(self, *args) def pc_output_buffers_full(self, *args): """ pc_output_buffers_full(Pointing_Errors_ff_sptr self, int which) -> float pc_output_buffers_full(Pointing_Errors_ff_sptr self) -> pmt_vector_float """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_output_buffers_full(self, *args) def pc_output_buffers_full_avg(self, *args): """ pc_output_buffers_full_avg(Pointing_Errors_ff_sptr self, int which) -> float pc_output_buffers_full_avg(Pointing_Errors_ff_sptr self) -> pmt_vector_float """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_output_buffers_full_avg(self, *args) def pc_output_buffers_full_var(self, *args): """ pc_output_buffers_full_var(Pointing_Errors_ff_sptr self, int which) -> float pc_output_buffers_full_var(Pointing_Errors_ff_sptr self) -> pmt_vector_float """ return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_output_buffers_full_var(self, *args) def pc_work_time(self): """pc_work_time(Pointing_Errors_ff_sptr self) -> float""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_work_time(self) def pc_work_time_avg(self): """pc_work_time_avg(Pointing_Errors_ff_sptr self) -> float""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_work_time_avg(self) def pc_work_time_var(self): """pc_work_time_var(Pointing_Errors_ff_sptr self) -> float""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_work_time_var(self) def pc_work_time_total(self): """pc_work_time_total(Pointing_Errors_ff_sptr self) -> float""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_work_time_total(self) def pc_throughput_avg(self): """pc_throughput_avg(Pointing_Errors_ff_sptr self) -> float""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_pc_throughput_avg(self) def set_processor_affinity(self, mask): """set_processor_affinity(Pointing_Errors_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_set_processor_affinity(self, mask) def unset_processor_affinity(self): """unset_processor_affinity(Pointing_Errors_ff_sptr self)""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_unset_processor_affinity(self) def processor_affinity(self): """processor_affinity(Pointing_Errors_ff_sptr self) -> std::vector< int,std::allocator< int > >""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_processor_affinity(self) def active_thread_priority(self): """active_thread_priority(Pointing_Errors_ff_sptr self) -> int""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_active_thread_priority(self) def thread_priority(self): """thread_priority(Pointing_Errors_ff_sptr self) -> int""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_thread_priority(self) def set_thread_priority(self, priority): """set_thread_priority(Pointing_Errors_ff_sptr self, int priority) -> int""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_set_thread_priority(self, priority) def name(self): """name(Pointing_Errors_ff_sptr self) -> std::string""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_name(self) def symbol_name(self): """symbol_name(Pointing_Errors_ff_sptr self) -> std::string""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_symbol_name(self) def input_signature(self): """input_signature(Pointing_Errors_ff_sptr self) -> io_signature_sptr""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_input_signature(self) def output_signature(self): """output_signature(Pointing_Errors_ff_sptr self) -> io_signature_sptr""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_output_signature(self) def unique_id(self): """unique_id(Pointing_Errors_ff_sptr self) -> long""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_unique_id(self) def to_basic_block(self): """to_basic_block(Pointing_Errors_ff_sptr self) -> basic_block_sptr""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_to_basic_block(self) def check_topology(self, ninputs, noutputs): """check_topology(Pointing_Errors_ff_sptr self, int ninputs, int noutputs) -> bool""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_check_topology(self, ninputs, noutputs) def alias(self): """alias(Pointing_Errors_ff_sptr self) -> std::string""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_alias(self) def set_block_alias(self, name): """set_block_alias(Pointing_Errors_ff_sptr self, std::string name)""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_set_block_alias(self, name) def _post(self, which_port, msg): """_post(Pointing_Errors_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr__post(self, which_port, msg) def message_ports_in(self): """message_ports_in(Pointing_Errors_ff_sptr self) -> swig_int_ptr""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_message_ports_in(self) def message_ports_out(self): """message_ports_out(Pointing_Errors_ff_sptr self) -> swig_int_ptr""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_message_ports_out(self) def message_subscribers(self, which_port): """message_subscribers(Pointing_Errors_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr""" return _FSO_Comm_swig.Pointing_Errors_ff_sptr_message_subscribers(self, which_port) Pointing_Errors_ff_sptr_swigregister = _FSO_Comm_swig.Pointing_Errors_ff_sptr_swigregister Pointing_Errors_ff_sptr_swigregister(Pointing_Errors_ff_sptr) Pointing_Errors_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id()) Pointing_Errors_ff = Pointing_Errors_ff.make; class Turbulence_ff(object): """ FSO Turbulence Channel. This block simulates the effect of turbulence (scintillation) in FSO channel. Constructor Specific Documentation: Make a turbulence block. Args: Cn2 : refractive index structure constant (m^(-2/3)) Wavelen : optical beam wavelength (m) LinkLen : FSO channel link length (m) Rx_Dia : receiver aperture diameter (m) TempCorr : temppral correlation of turbulence channel (s) SampRate : sampling rate of signal (samples per second) """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr def make(Cn2, Wavelen, LinkLen, Rx_Dia, TempCorr, SampRate): """ make(float Cn2, float Wavelen, float LinkLen, float Rx_Dia, float TempCorr, float SampRate) -> Turbulence_ff_sptr FSO Turbulence Channel. This block simulates the effect of turbulence (scintillation) in FSO channel. Constructor Specific Documentation: Make a turbulence block. Args: Cn2 : refractive index structure constant (m^(-2/3)) Wavelen : optical beam wavelength (m) LinkLen : FSO channel link length (m) Rx_Dia : receiver aperture diameter (m) TempCorr : temppral correlation of turbulence channel (s) SampRate : sampling rate of signal (samples per second) """ return _FSO_Comm_swig.Turbulence_ff_make(Cn2, Wavelen, LinkLen, Rx_Dia, TempCorr, SampRate) make = staticmethod(make) def set_Cn2(self, Cn2): """ set_Cn2(Turbulence_ff self, float Cn2) Set turbulence Cn2. """ return _FSO_Comm_swig.Turbulence_ff_set_Cn2(self, Cn2) def Cn2(self): """ Cn2(Turbulence_ff self) -> float Return current turbulence Cn2. """ return _FSO_Comm_swig.Turbulence_ff_Cn2(self) def set_Wavelen(self, Wavelen): """ set_Wavelen(Turbulence_ff self, float Wavelen) Set turbulence wavelength. """ return _FSO_Comm_swig.Turbulence_ff_set_Wavelen(self, Wavelen) def Wavelen(self): """ Wavelen(Turbulence_ff self) -> float Return current turbulence wavelength. """ return _FSO_Comm_swig.Turbulence_ff_Wavelen(self) def set_LinkLen(self, LinkLen): """ set_LinkLen(Turbulence_ff self, float LinkLen) Set turbulence link length. """ return _FSO_Comm_swig.Turbulence_ff_set_LinkLen(self, LinkLen) def LinkLen(self): """ LinkLen(Turbulence_ff self) -> float Return current turbulence link length. """ return _FSO_Comm_swig.Turbulence_ff_LinkLen(self) def set_Rx_Dia(self, Rx_Dia): """ set_Rx_Dia(Turbulence_ff self, float Rx_Dia) Set turbulence receiver apertture diameter. """ return _FSO_Comm_swig.Turbulence_ff_set_Rx_Dia(self, Rx_Dia) def Rx_Dia(self): """ Rx_Dia(Turbulence_ff self) -> float Return current turbulence receiver aperture diameter. """ return _FSO_Comm_swig.Turbulence_ff_Rx_Dia(self) def set_TempCorr(self, TempCorr): """ set_TempCorr(Turbulence_ff self, float TempCorr) Set turbulence temporal correlation. """ return _FSO_Comm_swig.Turbulence_ff_set_TempCorr(self, TempCorr) def TempCorr(self): """ TempCorr(Turbulence_ff self) -> float Return current turbulence temporal correlation. """ return _FSO_Comm_swig.Turbulence_ff_TempCorr(self) def set_SampRate(self, SampRate): """ set_SampRate(Turbulence_ff self, float SampRate) Set turbulence sampling rate. """ return _FSO_Comm_swig.Turbulence_ff_set_SampRate(self, SampRate) def SampRate(self): """ SampRate(Turbulence_ff self) -> float Return current turbulence sampling rate. """ return _FSO_Comm_swig.Turbulence_ff_SampRate(self) __swig_destroy__ = _FSO_Comm_swig.delete_Turbulence_ff __del__ = lambda self: None Turbulence_ff_swigregister = _FSO_Comm_swig.Turbulence_ff_swigregister Turbulence_ff_swigregister(Turbulence_ff) def Turbulence_ff_make(Cn2, Wavelen, LinkLen, Rx_Dia, TempCorr, SampRate): """ Turbulence_ff_make(float Cn2, float Wavelen, float LinkLen, float Rx_Dia, float TempCorr, float SampRate) -> Turbulence_ff_sptr FSO Turbulence Channel. This block simulates the effect of turbulence (scintillation) in FSO channel. Constructor Specific Documentation: Make a turbulence block. Args: Cn2 : refractive index structure constant (m^(-2/3)) Wavelen : optical beam wavelength (m) LinkLen : FSO channel link length (m) Rx_Dia : receiver aperture diameter (m) TempCorr : temppral correlation of turbulence channel (s) SampRate : sampling rate of signal (samples per second) """ return _FSO_Comm_swig.Turbulence_ff_make(Cn2, Wavelen, LinkLen, Rx_Dia, TempCorr, SampRate) class Turbulence_ff_sptr(object): """Proxy of C++ boost::shared_ptr<(gr::FSO_Comm::Turbulence_ff)> class.""" thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args): """ __init__(boost::shared_ptr<(gr::FSO_Comm::Turbulence_ff)> self) -> Turbulence_ff_sptr __init__(boost::shared_ptr<(gr::FSO_Comm::Turbulence_ff)> self, Turbulence_ff p) -> Turbulence_ff_sptr """ this = _FSO_Comm_swig.new_Turbulence_ff_sptr(*args) try: self.this.append(this) except
munsell_value_Saunderson1944(Y: FloatingOrArrayLike) -> FloatingOrNDArray: """ Return the *Munsell* value :math:`V` of given *luminance* :math:`Y` using *Saunderson and Milner (1944)* method. Parameters ---------- Y *luminance* :math:`Y`. Returns ------- :class:`np.floating` or :class:`numpy.ndarray` *Munsell* value :math:`V`. Notes ----- +------------+-----------------------+---------------+ | **Domain** | **Scale - Reference** | **Scale - 1** | +============+=======================+===============+ | ``Y`` | [0, 100] | [0, 1] | +------------+-----------------------+---------------+ +------------+-----------------------+---------------+ | **Range** | **Scale - Reference** | **Scale - 1** | +============+=======================+===============+ | ``V`` | [0, 10] | [0, 1] | +------------+-----------------------+---------------+ References ---------- :cite:`Wikipedia2007c` Examples -------- >>> munsell_value_Saunderson1944(12.23634268) # doctest: +ELLIPSIS 4.0444736... """ Y = to_domain_100(Y) V = 2.357 * spow(Y, 0.343) - 1.52 return as_float(from_range_10(V)) def munsell_value_Ladd1955(Y: FloatingOrArrayLike) -> FloatingOrNDArray: """ Return the *Munsell* value :math:`V` of given *luminance* :math:`Y` using *Ladd and Pinney (1955)* method. Parameters ---------- Y *luminance* :math:`Y`. Returns ------- :class:`np.floating` or :class:`numpy.ndarray` *Munsell* value :math:`V`. Notes ----- +------------+-----------------------+---------------+ | **Domain** | **Scale - Reference** | **Scale - 1** | +============+=======================+===============+ | ``Y`` | [0, 100] | [0, 1] | +------------+-----------------------+---------------+ +------------+-----------------------+---------------+ | **Range** | **Scale - Reference** | **Scale - 1** | +============+=======================+===============+ | ``V`` | [0, 10] | [0, 1] | +------------+-----------------------+---------------+ References ---------- :cite:`Wikipedia2007c` Examples -------- >>> munsell_value_Ladd1955(12.23634268) # doctest: +ELLIPSIS 4.0511633... """ Y = to_domain_100(Y) V = 2.468 * spow(Y, 1 / 3) - 1.636 return as_float(from_range_10(V)) def munsell_value_McCamy1987(Y: FloatingOrArrayLike) -> FloatingOrNDArray: """ Return the *Munsell* value :math:`V` of given *luminance* :math:`Y` using *McCamy (1987)* method. Parameters ---------- Y *luminance* :math:`Y`. Returns ------- :class:`np.floating` or :class:`numpy.ndarray` *Munsell* value :math:`V`. Notes ----- +------------+-----------------------+---------------+ | **Domain** | **Scale - Reference** | **Scale - 1** | +============+=======================+===============+ | ``Y`` | [0, 100] | [0, 1] | +------------+-----------------------+---------------+ +------------+-----------------------+---------------+ | **Range** | **Scale - Reference** | **Scale - 1** | +============+=======================+===============+ | ``V`` | [0, 10] | [0, 1] | +------------+-----------------------+---------------+ References ---------- :cite:`ASTMInternational1989a` Examples -------- >>> munsell_value_McCamy1987(12.23634268) # doctest: +ELLIPSIS 4.0814348... """ Y = to_domain_100(Y) V = np.where( Y <= 0.9, 0.87445 * spow(Y, 0.9967), 2.49268 * spow(Y, 1 / 3) - 1.5614 - (0.985 / (((0.1073 * Y - 3.084) ** 2) + 7.54)) + (0.0133 / spow(Y, 2.3)) + 0.0084 * np.sin(4.1 * spow(Y, 1 / 3) + 1) + (0.0221 / Y) * np.sin(0.39 * (Y - 2)) - (0.0037 / (0.44 * Y)) * np.sin(1.28 * (Y - 0.53)), ) return as_float(from_range_10(V)) def munsell_value_ASTMD1535(Y: FloatingOrArrayLike) -> FloatingOrNDArray: """ Return the *Munsell* value :math:`V` of given *luminance* :math:`Y` using an inverse lookup table from *ASTM D1535-08e1* method. Parameters ---------- Y *luminance* :math:`Y` Returns ------- :class:`np.floating` or :class:`numpy.ndarray` *Munsell* value :math:`V`. Notes ----- +------------+-----------------------+---------------+ | **Domain** | **Scale - Reference** | **Scale - 1** | +============+=======================+===============+ | ``Y`` | [0, 100] | [0, 1] | +------------+-----------------------+---------------+ +------------+-----------------------+---------------+ | **Range** | **Scale - Reference** | **Scale - 1** | +============+=======================+===============+ | ``V`` | [0, 10] | [0, 1] | +------------+-----------------------+---------------+ - The *Munsell* value* computation with *ASTM D1535-08e1* method is only defined for domain [0, 100]. References ---------- :cite:`ASTMInternational1989a` Examples -------- >>> munsell_value_ASTMD1535(12.23634268) # doctest: +ELLIPSIS 4.0824437... """ Y = to_domain_100(Y) V = _munsell_value_ASTMD1535_interpolator()(Y) return as_float(from_range_10(V)) MUNSELL_VALUE_METHODS: CaseInsensitiveMapping = CaseInsensitiveMapping( { "Priest 1920": munsell_value_Priest1920, "Munsell 1933": munsell_value_Munsell1933, "Moon 1943": munsell_value_Moon1943, "Saunderson 1944": munsell_value_Saunderson1944, "Ladd 1955": munsell_value_Ladd1955, "McCamy 1987": munsell_value_McCamy1987, "ASTM D1535": munsell_value_ASTMD1535, } ) MUNSELL_VALUE_METHODS.__doc__ = """ Supported *Munsell* value computation methods. References ---------- :cite:`ASTMInternational1989a`, :cite:`Wikipedia2007c` Aliases: - 'astm2008': 'ASTM D1535' """ MUNSELL_VALUE_METHODS["astm2008"] = MUNSELL_VALUE_METHODS["ASTM D1535"] def munsell_value( Y: FloatingOrArrayLike, method: Union[ Literal[ "ASTM D1535", "Ladd 1955", "McCamy 1987", "Moon 1943", "Munsell 1933", "Priest 1920", "Saunderson 1944", ], str, ] = "ASTM D1535", ) -> FloatingOrNDArray: """ Return the *Munsell* value :math:`V` of given *luminance* :math:`Y` using given method. Parameters ---------- Y *luminance* :math:`Y`. method Computation method. Returns ------- :class:`np.floating` or :class:`numpy.ndarray` *Munsell* value :math:`V`. Notes ----- +------------+-----------------------+---------------+ | **Domain** | **Scale - Reference** | **Scale - 1** | +============+=======================+===============+ | ``Y`` | [0, 100] | [0, 1] | +------------+-----------------------+---------------+ +------------+-----------------------+---------------+ | **Range** | **Scale - Reference** | **Scale - 1** | +============+=======================+===============+ | ``V`` | [0, 10] | [0, 1] | +------------+-----------------------+---------------+ References ---------- :cite:`ASTMInternational1989a`, :cite:`Wikipedia2007c` Examples -------- >>> munsell_value(12.23634268) # doctest: +ELLIPSIS 4.0824437... >>> munsell_value(12.23634268, method='Priest 1920') # doctest: +ELLIPSIS 3.4980484... >>> munsell_value(12.23634268, method='Munsell 1933') # doctest: +ELLIPSIS 4.1627702... >>> munsell_value(12.23634268, method='Moon 1943') # doctest: +ELLIPSIS 4.0688120... >>> munsell_value(12.23634268, method='Saunderson 1944') ... # doctest: +ELLIPSIS 4.0444736... >>> munsell_value(12.23634268, method='Ladd 1955') # doctest: +ELLIPSIS 4.0511633... >>> munsell_value(12.23634268, method='McCamy 1987') # doctest: +ELLIPSIS 4.0814348... """ method = validate_method(method, MUNSELL_VALUE_METHODS) return MUNSELL_VALUE_METHODS[method](Y) def _munsell_scale_factor() -> NDArray: """ Return the domain-range scale factor for *Munsell Renotation System*. Returns ------- :class:`numpy.ndarray` Domain-range scale factor for *Munsell Renotation System*. """ return np.array([10, 10, 50 if get_domain_range_scale() == "1" else 2, 10]) def _munsell_specification_to_xyY(specification: ArrayLike) -> NDArray: """ Convert given *Munsell* *Colorlab* specification to *CIE xyY* colourspace. Parameters ---------- specification *Munsell* *Colorlab* specification. Returns ------- :class:`numpy.ndarray` *CIE xyY* colourspace array. """ specification = normalise_munsell_specification(specification) if is_grey_munsell_colour(specification): specification = as_float_array(to_domain_10(specification)) hue, value, chroma, code = specification else: specification = to_domain_10(specification, _munsell_scale_factor()) hue, value, chroma, code = specification code = as_int_scalar(code) attest( 0 <= hue <= 10, f'"{specification}" specification hue must be normalised to ' f"domain [0, 10]!", ) attest( 0 <= value <= 10, f'"{specification}" specification value must be normalised to ' f"domain [0, 10]!", ) with domain_range_scale("ignore"): Y = luminance_ASTMD1535(value) if is_integer(value): value_minus = value_plus = round(value) else: value_minus = np.floor(value) value_plus = value_minus + 1 specification_minus = as_float_array( value_minus if is_grey_munsell_colour(specification) else [hue, value_minus, chroma, code] ) x_minus, y_minus = tsplit(munsell_specification_to_xy(specification_minus)) specification_plus = as_float_array( value_plus if (is_grey_munsell_colour(specification) or value_plus == 10) else [hue, value_plus, chroma, code] ) x_plus, y_plus = tsplit(munsell_specification_to_xy(specification_plus)) if value_minus == value_plus: x = x_minus y = y_minus else: with domain_range_scale("ignore"): Y_minus = as_float_array(luminance_ASTMD1535(value_minus)) Y_plus = as_float_array(luminance_ASTMD1535(value_plus)) Y_minus_plus = np.squeeze([Y_minus, Y_plus]) x_minus_plus = np.squeeze([x_minus, x_plus]) y_minus_plus = np.squeeze([y_minus, y_plus]) x = LinearInterpolator(Y_minus_plus, x_minus_plus)(Y) y = LinearInterpolator(Y_minus_plus, y_minus_plus)(Y) return tstack([x, y, from_range_1(Y / 100)]) def munsell_specification_to_xyY(specification: ArrayLike) -> NDArray: """ Convert given *Munsell* *Colorlab* specification to *CIE xyY* colourspace. Parameters ---------- specification *Munsell* *Colorlab* specification. Returns ------- :class:`numpy.ndarray` *CIE xyY* colourspace array. Notes ----- +-------------------+-----------------------+---------------+ | **Domain** | **Scale - Reference** | **Scale - 1** | +===================+=======================+===============+ | ``specification`` | ``hue`` : [0, 10] | [0, 1] | | | | | | | ``value`` : [0, 10] | [0, 1] | | | | | | | ``chroma`` : [0, 50] | [0, 1] | | | | | | | ``code`` : [0, 10] | [0, 1] | +-------------------+-----------------------+---------------+ +-------------------+-----------------------+---------------+ | **Range** | **Scale - Reference** | **Scale - 1** | +===================+=======================+===============+ | ``xyY`` | [0, 1] | [0, 1] | +-------------------+-----------------------+---------------+ References ---------- :cite:`Centore2014m` Examples -------- >>> munsell_specification_to_xyY(np.array([2.1, 8.0, 17.9, 4])) ... # doctest: +ELLIPSIS array([ 0.4400632..., 0.5522428..., 0.5761962...]) >>> munsell_specification_to_xyY(np.array([np.nan, 8.9, np.nan, np.nan])) ... # doctest: +ELLIPSIS array([ 0.31006 , 0.31616 , 0.7461345...]) """ specification = as_float_array(specification) shape = list(specification.shape) xyY = [ _munsell_specification_to_xyY(a) for a in specification.reshape([-1, 4]) ] shape[-1] = 3 return np.reshape(as_float_array(xyY), shape) def munsell_colour_to_xyY(munsell_colour: StrOrArrayLike) -> NDArray: """ Convert given *Munsell* colour to *CIE xyY* colourspace. Parameters ---------- munsell_colour *Munsell* colour. Returns ------- :class:`numpy.ndarray` *CIE xyY* colourspace array. Notes ----- +-----------+-----------------------+---------------+ | **Range** | **Scale - Reference** | **Scale - 1** | +===========+=======================+===============+ | ``xyY`` | [0, 1] | [0, 1] | +-----------+-----------------------+---------------+ References ---------- :cite:`Centorea`, :cite:`Centore2012a` Examples -------- >>> munsell_colour_to_xyY('4.2YR 8.1/5.3') # doctest: +ELLIPSIS array([ 0.3873694..., 0.3575165..., 0.59362 ]) >>> munsell_colour_to_xyY('N8.9') # doctest: +ELLIPSIS array([ 0.31006 , 0.31616 , 0.7461345...]) """ munsell_colour = np.array(munsell_colour) shape = list(munsell_colour.shape) specification = np.array( [ munsell_colour_to_munsell_specification(a) for a in np.ravel(munsell_colour) ] ) return munsell_specification_to_xyY( from_range_10( specification.reshape(shape + [4]), _munsell_scale_factor() ) ) def _xyY_to_munsell_specification(xyY: ArrayLike) -> NDArray: """ Convert from *CIE xyY* colourspace to *Munsell* *Colorlab* specification. Parameters ---------- xyY *CIE xyY* colourspace array. Returns ------- :class:`numpy.ndarray` *Munsell* *Colorlab* specification. Raises ------ ValueError If the given *CIE xyY* colourspace array is not within MacAdam limits. RuntimeError If the maximum iterations count has been reached without converging to a result. """ x, y, Y
content, requires, attachments, name, version_name, document_type, document_format, target_type, tags, ): ssm_document = Document( name=name, version_name=version_name, content=content, document_type=document_type, document_format=document_format, requires=requires, attachments=attachments, target_type=target_type, tags=tags, ) _validate_document_info( content=content, name=name, document_type=document_type, document_format=document_format, ) if self._documents.get(ssm_document.name): raise DocumentAlreadyExists("The specified document already exists.") self._documents[ssm_document.name] = { "documents": {ssm_document.document_version: ssm_document}, "default_version": ssm_document.document_version, "latest_version": ssm_document.document_version, } return self._generate_document_description(ssm_document) def delete_document(self, name, document_version, version_name, force): documents = self._documents.get(name, {}).get("documents", {}) keys_to_delete = set() if documents: default_version = self._documents[name]["default_version"] if ( documents[default_version].document_type == "ApplicationConfigurationSchema" and not force ): raise InvalidDocumentOperation( "You attempted to delete a document while it is still shared. " "You must stop sharing the document before you can delete it." ) if document_version and document_version == default_version: raise InvalidDocumentOperation( "Default version of the document can't be deleted." ) if document_version or version_name: # We delete only a specific version delete_doc = self._find_document(name, document_version, version_name) # we can't delete only the default version if ( delete_doc and delete_doc.document_version == default_version and len(documents) != 1 ): raise InvalidDocumentOperation( "Default version of the document can't be deleted." ) if delete_doc: keys_to_delete.add(delete_doc.document_version) else: raise InvalidDocument("The specified document does not exist.") else: # We are deleting all versions keys_to_delete = set(documents.keys()) for key in keys_to_delete: del self._documents[name]["documents"][key] if len(self._documents[name]["documents"].keys()) == 0: del self._documents[name] else: old_latest = self._documents[name]["latest_version"] if old_latest not in self._documents[name]["documents"].keys(): leftover_keys = self._documents[name]["documents"].keys() int_keys = [] for key in leftover_keys: int_keys.append(int(key)) self._documents[name]["latest_version"] = str(sorted(int_keys)[-1]) else: raise InvalidDocument("The specified document does not exist.") def _find_document( self, name, document_version=None, version_name=None, strict=True ): if not self._documents.get(name): raise InvalidDocument("The specified document does not exist.") documents = self._documents[name]["documents"] ssm_document = None if not version_name and not document_version: # Retrieve default version default_version = self._documents[name]["default_version"] ssm_document = documents.get(default_version) elif version_name and document_version: for doc_version, document in documents.items(): if ( doc_version == document_version and document.version_name == version_name ): ssm_document = document break else: for doc_version, document in documents.items(): if document_version and doc_version == document_version: ssm_document = document break if version_name and document.version_name == version_name: ssm_document = document break if strict and not ssm_document: raise InvalidDocument("The specified document does not exist.") return ssm_document def get_document(self, name, document_version, version_name, document_format): ssm_document = self._find_document(name, document_version, version_name) if not document_format: document_format = ssm_document.document_format else: _validate_document_format(document_format=document_format) return self._generate_document_information(ssm_document, document_format) def update_document_default_version(self, name, document_version): ssm_document = self._find_document(name, document_version=document_version) self._documents[name]["default_version"] = document_version base = { "Name": ssm_document.name, "DefaultVersion": document_version, } if ssm_document.version_name: base["DefaultVersionName"] = ssm_document.version_name return base def update_document( self, content, attachments, name, version_name, document_version, document_format, target_type, ): _validate_document_info( content=content, name=name, document_type=None, document_format=document_format, strict=False, ) if not self._documents.get(name): raise InvalidDocument("The specified document does not exist.") if ( self._documents[name]["latest_version"] != document_version and document_version != "$LATEST" ): raise InvalidDocumentVersion( "The document version is not valid or does not exist." ) if version_name and self._find_document( name, version_name=version_name, strict=False ): raise DuplicateDocumentVersionName( "The specified version name is a duplicate." ) old_ssm_document = self._find_document(name) new_ssm_document = Document( name=name, version_name=version_name, content=content, document_type=old_ssm_document.document_type, document_format=document_format, requires=old_ssm_document.requires, attachments=attachments, target_type=target_type, tags=old_ssm_document.tags, document_version=str(int(self._documents[name]["latest_version"]) + 1), ) for doc_version, document in self._documents[name]["documents"].items(): if document.content == new_ssm_document.content: raise DuplicateDocumentContent( "The content of the association document matches another document. " "Change the content of the document and try again." ) self._documents[name]["latest_version"] = str( int(self._documents[name]["latest_version"]) + 1 ) self._documents[name]["documents"][ new_ssm_document.document_version ] = new_ssm_document return self._generate_document_description(new_ssm_document) def describe_document(self, name, document_version, version_name): ssm_document = self._find_document(name, document_version, version_name) return self._generate_document_description(ssm_document) def list_documents( self, document_filter_list, filters, max_results=10, next_token="0" ): if document_filter_list: raise ValidationException( "DocumentFilterList is deprecated. Instead use Filters." ) next_token = int(next_token) results = [] dummy_token_tracker = 0 # Sort to maintain next token adjacency for document_name, document_bundle in sorted(self._documents.items()): if len(results) == max_results: # There's still more to go so we need a next token return results, str(next_token + len(results)) if dummy_token_tracker < next_token: dummy_token_tracker = dummy_token_tracker + 1 continue default_version = document_bundle["default_version"] ssm_doc = self._documents[document_name]["documents"][default_version] if filters and not _document_filter_match(filters, ssm_doc): # If we have filters enabled, and we don't match them, continue else: results.append(self._generate_document_list_information(ssm_doc)) # If we've fallen out of the loop, theres no more documents. No next token. return results, "" def delete_parameter(self, name): return self._parameters.pop(name, None) def delete_parameters(self, names): result = [] for name in names: try: del self._parameters[name] result.append(name) except KeyError: pass return result def describe_parameters(self, filters, parameter_filters): if filters and parameter_filters: raise ValidationException( "You can use either Filters or ParameterFilters in a single request." ) self._validate_parameter_filters(parameter_filters, by_path=False) result = [] for param_name in self._parameters: ssm_parameter = self.get_parameter(param_name, False) if not self._match_filters(ssm_parameter, parameter_filters): continue if filters: for filter in filters: if filter["Key"] == "Name": k = ssm_parameter.name for v in filter["Values"]: if k.startswith(v): result.append(ssm_parameter) break elif filter["Key"] == "Type": k = ssm_parameter.type for v in filter["Values"]: if k == v: result.append(ssm_parameter) break elif filter["Key"] == "KeyId": k = ssm_parameter.keyid if k: for v in filter["Values"]: if k == v: result.append(ssm_parameter) break continue result.append(ssm_parameter) return result def _validate_parameter_filters(self, parameter_filters, by_path): for index, filter_obj in enumerate(parameter_filters or []): key = filter_obj["Key"] values = filter_obj.get("Values", []) if key == "Path": option = filter_obj.get("Option", "OneLevel") else: option = filter_obj.get("Option", "Equals") if not re.match(r"^tag:.+|Name|Type|KeyId|Path|Label|Tier$", key): self._errors.append( self._format_error( key="parameterFilters.{index}.member.key".format( index=(index + 1) ), value=key, constraint="Member must satisfy regular expression pattern: tag:.+|Name|Type|KeyId|Path|Label|Tier", ) ) if len(key) > 132: self._errors.append( self._format_error( key="parameterFilters.{index}.member.key".format( index=(index + 1) ), value=key, constraint="Member must have length less than or equal to 132", ) ) if len(option) > 10: self._errors.append( self._format_error( key="parameterFilters.{index}.member.option".format( index=(index + 1) ), value="over 10 chars", constraint="Member must have length less than or equal to 10", ) ) if len(values) > 50: self._errors.append( self._format_error( key="parameterFilters.{index}.member.values".format( index=(index + 1) ), value=values, constraint="Member must have length less than or equal to 50", ) ) if any(len(value) > 1024 for value in values): self._errors.append( self._format_error( key="parameterFilters.{index}.member.values".format( index=(index + 1) ), value=values, constraint="[Member must have length less than or equal to 1024, Member must have length greater than or equal to 1]", ) ) self._raise_errors() filter_keys = [] for filter_obj in parameter_filters or []: key = filter_obj["Key"] values = filter_obj.get("Values") if key == "Path": option = filter_obj.get("Option", "OneLevel") else: option = filter_obj.get("Option", "Equals") if not by_path and key == "Label": raise InvalidFilterKey( "The following filter key is not valid: Label. Valid filter keys include: [Path, Name, Type, KeyId, Tier]." ) if by_path and key in ["Name", "Path", "Tier"]: raise InvalidFilterKey( "The following filter key is not valid: {key}. Valid filter keys include: [Type, KeyId].".format( key=key ) ) if not values: raise InvalidFilterValue( "The following filter values are missing : null for filter key Name." ) if key in filter_keys: raise InvalidFilterKey( "The following filter is duplicated in the request: Name. A request can contain only one occurrence of a specific filter." ) if key == "Path": if option not in ["Recursive", "OneLevel"]: raise InvalidFilterOption( "The following filter option is not valid: {option}. Valid options include: [Recursive, OneLevel].".format( option=option ) ) if any(value.lower().startswith(("/aws", "/ssm")) for value in values): raise ValidationException( 'Filters for common parameters can\'t be prefixed with "aws" or "ssm" (case-insensitive). ' "When using global parameters, please specify within a global namespace." ) for value in values: if value.lower().startswith(("/aws", "/ssm")): raise ValidationException( 'Filters for common parameters can\'t be prefixed with "aws" or "ssm" (case-insensitive). ' "When using global parameters, please specify within a global namespace." ) if ( "//" in value or not value.startswith("/") or not re.match("^[a-zA-Z0-9_.-/]*$", value) ): raise ValidationException( 'The parameter doesn\'t meet the parameter name requirements. The parameter name must begin with a forward slash "/". ' 'It can\'t be prefixed with "aws" or "ssm" (case-insensitive). ' "It must use only letters, numbers, or the following symbols: . (period), - (hyphen), _ (underscore). " 'Special characters are not allowed. All sub-paths, if specified, must use the forward slash symbol "/". ' "Valid example: /get/parameters2-/by1./path0_." ) if key == "Tier": for value in values: if value not in ["Standard", "Advanced", "Intelligent-Tiering"]: raise InvalidFilterOption( "The following filter value is not valid: {value}. Valid values include: [Standard, Advanced, Intelligent-Tiering].".format( value=value ) ) if key == "Type": for value in values: if
<filename>acstools/acs_destripe_plus.py #!/usr/bin/env python """ Fully calibrate post-SM4 ACS/WFC exposures using the standalone :ref:`acsdestripe` tool to remove stripes between ACSCCD and ACSCTE steps in CALACS. This script runs CALACS (8.3.1 or higher only) and ``acs_destripe`` on ACS/WFC images. Input files must be RAW full-frame or supported subarray ACS/WFC exposures taken after SM4. Resultant outputs are science-ready FLT and FLC (if applicable) files. This script is useful for when built-in CALACS destriping algorithm using overscans is insufficient or unavailable. For more information, see `Removal of Bias Striping Noise from Post-SM4 ACS WFC Images <http://www.stsci.edu/hst/acs/software/destripe/>`_. Examples -------- In Python: >>> from acstools import acs_destripe_plus >>> acs_destripe_plus.destripe_plus( ... 'j12345678_raw.fits', suffix='strp', maxiter=15, sigrej=2.0, ... scimask1='mymask_sci1.fits', scimask2='mymask_sci2.fits', ... clobber=False, cte_correct=True) From command line:: % acs_destripe_plus [-h] [--suffix SUFFIX] [--stat STAT] [--maxiter MAXITER] [--sigrej SIGREJ] [--lower [LOWER]] [--upper [UPPER]] [--binwidth BINWIDTH] [--sci1_mask SCI1_MASK] [--sci2_mask SCI2_MASK] [--dqbits [DQBITS]] [--rpt_clean RPT_CLEAN] [--atol [ATOL]] [--nocte] [--clobber] [-q] [--version] input """ # # HISTORY: # 16APR2014 Leonardo version 1.0 # Based on instructions from <NAME> # 11SEP2014 Ogaz added capabilities for full frame processing # and stripe masking # 29OCT2014 Ogaz clean up for posting final script for users # 18NOV2014 Ogaz changed options/switches # 12DEC2014 Lim incorporated script into ACSTOOLS # 11MAR2015 Lim added parameters to be passed into acs_destripe # 12MAR2015 (v0.3.0) Cara added capability to use DQ mask; # added support for multiple input files and wildcards in the file # names. Cara added weighted (by NPix) background computations # (especially important for vigneted filters). # See Tickets #1178 & #1180. # 31MAR2015 (v0.4.0) Cara added repeated de-stripe iterations (to improve # corrections in the "RAW" space) and support for various # statistics modes. See Ticket #1183. # 12JAN2016 (v0.4.1) Lim added new subarray modes that are allowed CTE corr. # STDLIB import logging import os import subprocess # nosec # ASTROPY from astropy.time import Time # THIRD-PARTY import numpy as np try: # This supports PIXVALUE from stsci.tools import stpyfits as fits except ImportError: # Falls back to Astropy from astropy.io import fits # LOCAL from . import acs_destripe from . import acs2d from . import acsccd from . import acscte __taskname__ = 'acs_destripe_plus' __version__ = '0.4.2' __vdate__ = '31-May-2018' __author__ = '<NAME>, <NAME> (ACS Team), STScI' __all__ = ['destripe_plus'] SM4_DATE = Time('2008-01-01') SUBARRAY_LIST = [ 'WFC1-2K', 'WFC1-POL0UV', 'WFC1-POL0V', 'WFC1-POL60V', 'WFC1-POL60UV', 'WFC1-POL120V', 'WFC1-POL120UV', 'WFC1-SMFL', 'WFC1-IRAMPQ', 'WFC1-MRAMPQ', 'WFC2-2K', 'WFC2-ORAMPQ', 'WFC2-SMFL', 'WFC2-POL0UV', 'WFC2-POL0V', 'WFC2-MRAMPQ', 'WFC1A-512', 'WFC1A-1K', 'WFC1A-2K', 'WFC1B-512', 'WFC1B-1K', 'WFC1B-2K', 'WFC2C-512', 'WFC2C-1K', 'WFC2C-2K', 'WFC2D-512', 'WFC2D-1K', 'WFC2D-2K'] logging.basicConfig() LOG = logging.getLogger(__taskname__) LOG.setLevel(logging.INFO) def destripe_plus(inputfile, suffix='strp', stat='pmode1', maxiter=15, sigrej=2.0, lower=None, upper=None, binwidth=0.3, scimask1=None, scimask2=None, dqbits=None, rpt_clean=0, atol=0.01, cte_correct=True, clobber=False, verbose=True): r"""Calibrate post-SM4 ACS/WFC exposure(s) and use standalone :ref:`acsdestripe`. This takes a RAW image and generates a FLT file containing its calibrated and destriped counterpart. If CTE correction is performed, FLC will also be present. Parameters ---------- inputfile : str or list of str Input filenames in one of these formats: * a Python list of filenames * a partial filename with wildcards ('\*raw.fits') * filename of an ASN table ('j12345670_asn.fits') * an at-file (``@input``) suffix : str The string to use to add to each input file name to indicate an output product of ``acs_destripe``. This only affects the intermediate output file that will be automatically renamed to ``*blv_tmp.fits`` during the processing. stat : { 'pmode1', 'pmode2', 'mean', 'mode', 'median', 'midpt' } (Default = 'pmode1') Specifies the statistics to be used for computation of the background in image rows: * 'pmode1' - SEXTRACTOR-like mode estimate based on a modified `Pearson's rule <https://en.wikipedia.org/wiki/Nonparametric_skew#Pearson.27s_rule>`_: ``2.5*median-1.5*mean``; * 'pmode2' - mode estimate based on `Pearson's rule <https://en.wikipedia.org/wiki/Nonparametric_skew#Pearson.27s_rule>`_: ``3*median-2*mean``; * 'mean' - the mean of the distribution of the "good" pixels (after clipping, masking, etc.); * 'mode' - the mode of the distribution of the "good" pixels; * 'median' - the median of the distribution of the "good" pixels; * 'midpt' - estimate of the median of the distribution of the "good" pixels based on an algorithm similar to IRAF's `imagestats` task (``CDF(midpt)=1/2``). .. note:: The midpoint and mode are computed in two passes through the image. In the first pass the standard deviation of the pixels is calculated and used with the *binwidth* parameter to compute the resolution of the data histogram. The midpoint is estimated by integrating the histogram and computing by interpolation the data value at which exactly half the pixels are below that data value and half are above it. The mode is computed by locating the maximum of the data histogram and fitting the peak by parabolic interpolation. maxiter : int This parameter controls the maximum number of iterations to perform when computing the statistics used to compute the row-by-row corrections. sigrej : float This parameters sets the sigma level for the rejection applied during each iteration of statistics computations for the row-by-row corrections. lower : float, None (Default = None) Lower limit of usable pixel values for computing the background. This value should be specified in the units of the input image(s). upper : float, None (Default = None) Upper limit of usable pixel values for computing the background. This value should be specified in the units of the input image(s). binwidth : float (Default = 0.1) Histogram's bin width, in sigma units, used to sample the distribution of pixel brightness values in order to compute the background statistics. This parameter is aplicable *only* to *stat* parameter values of `'mode'` or `'midpt'`. clobber : bool Specify whether or not to 'clobber' (delete then replace) previously generated products with the same names. scimask1 : str or list of str Mask images for *calibrated* ``SCI,1``, one for each input file. Pixels with zero values will be masked out, in addition to clipping. scimask2 : str or list of str Mask images for *calibrated* ``SCI,2``, one for each input file. Pixels with zero values will be masked out, in addition to clipping. This is not used for subarrays. dqbits : int, str, None (Default = None) Integer sum of all the DQ bit values from the input image's DQ array that should be considered "good" when building masks for de-striping computations. For example, if pixels in the DQ array can be combinations of 1, 2, 4, and 8 flags and one wants to consider DQ "defects" having flags 2 and 4 as being acceptable for de-striping computations, then `dqbits` should be set to 2+4=6. Then a DQ pixel having values 2,4, or 6 will be considered a good pixel, while a DQ pixel with a value, e.g., 1+2=3, 4+8=12, etc. will be flagged as a "bad" pixel. Alternatively, one can enter a comma- or '+'-separated list of integer bit flags that should be added to obtain the final "good" bits. For example, both ``4,8`` and ``4+8`` are equivalent to setting `dqbits` to 12. | Set `dqbits` to 0 to make *all* non-zero pixels in the DQ mask to be considered "bad" pixels, and the corresponding image pixels not to be used for de-striping computations. | Default value (`None`) will turn off the use of image's DQ array for de-striping computations. | In order to reverse the meaning of the `dqbits` parameter from indicating values of the "good" DQ flags to indicating the "bad" DQ flags, prepend '~' to the string value. For example, in order not to use pixels with DQ flags 4 and 8 for sky computations and to consider as "good" all other pixels (regardless of their DQ flag), set `dqbits` to ``~4+8``, or ``~4,8``. To obtain the same effect with an `int` input value (except for 0), enter -(4+8+1)=-9. Following this convention, a `dqbits` string value of ``'~0'`` would be equivalent to setting ``dqbits=None``. .. note:: DQ masks (if used), *will be* combined with user masks specified in the `scimask1` and `scimask2` parameters (if any). rpt_clean : int An integer indicating how many *additional* times stripe cleaning should be performed on the input image. Default = 0. atol : float, None The threshold for maximum absolute value of bias stripe correction below which repeated cleanings can stop. When `atol` is `None` cleaning will be repeated `rpt_clean` number of times. Default = 0.01 [e]. cte_correct : bool Perform CTE
given netcdf files considering the units and the calendar type used. This is a wrapper to the netCDF4.date2num function to account for calendar strangeness in ROMS Parameters ---------- dates : array of datetime.datetime Values to convert nc : netCDF4.Dataset, netcdf input file tvar : string, optional time variable to load. If not specified, it will find the time variable from predefined Returns ------- ndarray, Array of values in the correct units/calendar of the netCDF file """ tvar = tvar if tvar else get_timevar(nc) calendar, _ = _get_calendar(nc.variables[tvar]) # Convert the times return netCDF4.date2num(dates, nc.variables[tvar].units, calendar=calendar) def num2date(nc, tvar=None, records=None, as_datetime=True, epoch=None): """ Load the time vector from a netCDF file as a datetime array, accounting for units and the calendar type used. This is a wrapper to the netCDF4.num2date function to account for calendar strangeness in ROMS Parameters ---------- nc : netCDF4.Dataset, netcdf input file tvar : string, optional time variable to load. If not specified, it will find the time variable from predefined records : array or slice, optional the indices of records to load as_datetime : boolean, optional convert the result to an array of datetimes [default] epoch : datetime.datetime, optional if you would like the values relative to an epoch, then specify the epoch to remove. Returns ------- ndarray, Array of datetimes if no epoch is supplied. If epoch, array is in days since epoch """ import datetime records = records if records is not None else np.s_[:] tvar = tvar if tvar else get_timevar(nc) if tvar not in nc.variables: warn(f"{nc.filepath()} does not have a recognizable time dimension.") return list() calendar, convert = _get_calendar(nc.variables[tvar]) # Load the times times = np.atleast_1d(netCDF4.num2date(nc.variables[tvar][records], nc.variables[tvar].units, calendar=calendar)) # If we don't have datetime instances, convert to datetime if we can if (as_datetime or convert) and \ (not isinstance(times[0], datetime.datetime) and times[0].datetime_compatible): times = np.array([datetime.datetime.strptime( t.strftime('%Y-%m-%d %H:%M:%S'), '%Y-%m-%d %H:%M:%S') for t in times]) if not epoch: return times else: return np.asarray([(t - epoch).total_seconds() * secs2day for t in times]) def get_timevar(nc): """ Find the appropriate time variable (bry_time, ocean_time, etc.) from a given netcdf file Parameters ---------- nc : netCDF4.Dataset netcdf input file Returns ------- time: string """ for time in ("ocean_time", "time", "bry_time", "wind_time", "clim_time", "frc_time", "zeta_time"): if time in nc.variables: return time return None def get_reftime(nc, epoch=default_epoch): """ Given a ROMS netCDF4 file, return the reference time for the file. This is the timebase of the record dimension in the format: "<units> since <reftime>" Parameters ---------- nc : netCDF4 dataset Input ROMS file epoch_str : string, optional If lacking units, use this string as the units Returns ------- timebase : datetime datetime of the origin for the file time : string name of variable used to generate the base (None if default) """ try: tvar=get_timevar(nc) calendar, _=_get_calendar(nc.variables[tvar]) return netCDF4.num2date(0, nc.variables[tvar].units, calendar=calendar), tvar except AttributeError: return epoch, None def omega(grid, u, v, zeta=0, scale=True, work=False): """ Compute the vertical velocity on s-grid. Parameters ---------- grid : seapy.model.grid, The grid to use for the calculations u : ndarray, The u-field in time v : ndarray, The v-field in time zeta : ndarray, optional, The zeta-field in time scale : bool, optional, If [True], return omega in [m s**-1]; If False, return omega in [m**3 s**-1] work : bool, optional, If True, return the work arrays: z_r : ndarray, Depth on rho-grid (time-varying if zeta != 0) z_w : ndarray, Depth on w-grid (time-varying if zeta != 0) thick_u : ndarray Thickness of the u-grid thick_v : ndarray Thickness of the v-grid If False, return only omega Returns ------- omega : ndarray, Vertical Velocity on s-grid """ grid=seapy.model.asgrid(grid) u=np.ma.array(u) v=np.ma.array(v) zeta=np.ma.array(zeta) # Check the sizes while u.ndim < 4: u=u[np.newaxis, ...] while v.ndim < 4: v=v[np.newaxis, ...] while zeta.ndim < 3: zeta=zeta[np.newaxis, ...] # Get the model grid parameters for the given thickness thick_u=u * 0 thick_v=v * 0 z_r=np.ma.zeros((u.shape[0], u.shape[1], zeta.shape[1], zeta.shape[2])) z_w=np.ma.zeros((u.shape[0], u.shape[1] + 1, zeta.shape[1], zeta.shape[2])) for i in range(zeta.shape[0]): s_w, cs_w=seapy.roms.stretching( grid.vstretching, grid.theta_s, grid.theta_b, grid.hc, grid.n, w_grid=True) z_r[i, ...]=seapy.roms.depth(grid.vtransform, grid.h, grid.hc, s_w, cs_w, zeta=zeta[i, ...], w_grid=False) z_w[i, ...]=seapy.roms.depth(grid.vtransform, grid.h, grid.hc, s_w, cs_w, zeta=zeta[i, ...], w_grid=True) thick_rho=np.squeeze(z_w[i, 1:, :, :] - z_w[i, :-1, :, :]) thick_u[i, ...]=seapy.model.rho2u(thick_rho) thick_v[i, ...]=seapy.model.rho2v(thick_rho) z_r[z_r > 50000]=np.ma.masked z_w[z_w > 50000]=np.ma.masked # Compute W (omega) Huon=u * thick_u * seapy.model.rho2u(grid.dn) Hvom=v * thick_v * seapy.model.rho2v(grid.dm) W=z_w * 0 for k in range(grid.n): W[:, k + 1, :-2, :-2]=W[:, k, :-2, :-2] - \ (Huon[:, k, 1:-1, 1:] - Huon[:, k, 1:-1, :-1] + Hvom[:, k, 1:, 1:-1] - Hvom[:, k, :-1, 1:-1]) wrk=W[:, -1:, :, :] / (z_w[:, -1:, :, :] - z_w[:, 0:1, :, :]) W[:, :-1, :, :]=W[:, :-1, :, :] - wrk * \ (z_w[:, :-1, :, :] - z_w[:, 0:1, :, :]) W[:, -1, :, :]=0 if scale: W *= grid.pn * grid.pm if work: return W, z_r, z_w, thick_u, thick_v else: return W def wvelocity(grid, u, v, zeta=0): """ Compute "true" vertical velocity Parameters ---------- grid : seapy.model.grid, The grid to use for the calculations u : ndarray, The u-field in time v : ndarray, The v-field in time zeta : ndarray, optional, The zeta-field in time Returns ------- w : ndarray, Vertical Velocity """ grid=seapy.model.asgrid(grid) u=np.ma.array(u) v=np.ma.array(v) zeta=np.ma.array(zeta) # Check the sizes while u.ndim < 4: u=u[np.newaxis, ...] while v.ndim < 4: v=v[np.newaxis, ...] while zeta.ndim < 3: zeta=zeta[np.newaxis, ...] # Get omega W, z_r, z_w, thick_u, thick_v=omega(grid, u, v, zeta, scale=True, work=True) # Compute quasi-horizontal motions (Ui + Vj)*GRAD s(z) vert=z_r * 0 # U-contribution wrk=u * (z_r[:, :, :, 1:] - z_r[:, :, :, :-1]) * \ (grid.pm[:, 1:] - grid.pm[:, :-1]) vert[:, :, :, 1:-1]=0.25 * (wrk[:, :, :, :-1] + wrk[:, :, :, 1:]) # V-contribution wrk = v * (z_r[:, :, 1:, :] - z_r[:, :, :-1, :]) * \ (grid.pn[1:, :] - grid.pn[:-1, :]) vert[:, :, 1:-1, :] += 0.25 * (wrk[:, :, :-1, :] + wrk[:, :, 1:, :]) # Compute barotropic velocity [ERROR IN FORMULATION RIGHT NOW] wrk = np.zeros((vert.shape[0], vert.shape[2], vert.shape[3])) ubar = np.sum(u * thick_u, axis=1) / np.sum(thick_u, axis=1) vbar = np.sum(v * thick_v, axis=1) / np.sum(thick_v, axis=1) # wrk[:, 1:-1, 1:-1] = (ubar[:, 1:-1, :-1] - ubar[:, 1:-1, 1:] + # vbar[:, :-1, 1:-1] - vbar[:, 1:, 1:-1]) # Shift vert from rho to w wvel = z_w * 0 # First two layers slope = (z_r[:, 0, :, :] - z_w[:, 0, :, :]) / \ (z_r[:, 1, :, :] - z_r[:, 0, :, :]) wvel[:, 0, :, :] = 0.375 * (vert[:, 0, :, :] - slope * (vert[:, 1, :, :] - vert[:, 0, :, :])) + \ 0.75 * vert[:, 0, :, :] - \ 0.125 * vert[:, 1, :, :] wvel[:, 1, :, :] = W[:, 1, :, :] + wrk + \ 0.375 * vert[:, 0, :, :] + \ 0.75 * vert[:, 1, :, :] - 0.125 * vert[:, 2, :, :] # Middle of the grid wvel[:, 2:-2, :, :] = W[:, 2:-2, :, :] + \ wrk[:, np.newaxis, :, :] + \ 0.5625 * (vert[:, 1:-2, :, :] + vert[:, 2:-1, :, :]) - \ 0.0625 * (vert[:, :-3, :, :] + vert[:, 3:, :, :]) # Upper two layers slope = (z_w[:, -1, :, :] - z_r[:, -1, :, :]) / \ (z_r[:, -1, :, :] - z_r[:, -2, :, :]) wvel[:, -1, :, :] = wrk + 0.375 * (vert[:, -1, :, :] + slope * (vert[:, -1, :, :] - vert[:, -2, :, :])) + \ 0.75 * vert[:, -1, :, :] - \ 0.0625 * vert[:, -2, :, :] wvel[:, -2, :, :] = W[:, -2, :, :] + 0.375 * vert[:, -1, :, :] + \ wrk + 0.75 * vert[:, -2, :, :] - \ 0.125 * vert[:, -3,
expected = [ mock.call.getVolume('osv-0DM4qZEVSKON-DXN-NwVpw'), mock.call.getCPG(HP3PAR_CPG), mock.call.getHost(self.FAKE_HOST), mock.call.findHost(wwn='123456789012345'), mock.call.findHost(wwn='123456789054321'), mock.call.createHost( self.FAKE_HOST, FCWwns=['123456789012345', '123456789054321'], optional={'domain': None, 'persona': 1}), mock.call.getHost(self.FAKE_HOST)] mock_client.assert_has_calls(expected) self.assertEqual(host['name'], self.FAKE_HOST) def test_create_invalid_host(self): # setup_mock_client drive with default configuration # and return the mock HTTP 3PAR client mock_client = self.setup_driver() mock_client.getVolume.return_value = {'userCPG': HP3PAR_CPG} mock_client.getCPG.return_value = {} mock_client.getHost.side_effect = [ hpexceptions.HTTPNotFound('Host not found.'), { 'name': 'fakehost.foo', 'FCPaths': [{'wwn': '123456789012345'}, { 'wwn': '123456789054321'}]}] mock_client.findHost.return_value = 'fakehost.foo' host = self.driver._create_host(self.volume, self.connector) expected = [ mock.call.getVolume('osv-0DM4qZEVSKON-DXN-NwVpw'), mock.call.getCPG(HP3PAR_CPG), mock.call.getHost('fakehost'), mock.call.findHost(wwn='123456789012345'), mock.call.getHost('fakehost.foo')] mock_client.assert_has_calls(expected) self.assertEqual(host['name'], 'fakehost.foo') def test_create_modify_host(self): # setup_mock_client drive with default configuration # and return the mock HTTP 3PAR client mock_client = self.setup_driver() mock_client.getVolume.return_value = {'userCPG': HP3PAR_CPG} mock_client.getCPG.return_value = {} mock_client.getHost.side_effect = [{ 'name': self.FAKE_HOST, 'FCPaths': []}, {'name': self.FAKE_HOST, 'FCPaths': [{'wwn': '123456789012345'}, { 'wwn': '123456789054321'}]}] host = self.driver._create_host(self.volume, self.connector) expected = [ mock.call.getVolume('osv-0DM4qZEVSKON-DXN-NwVpw'), mock.call.getCPG(HP3PAR_CPG), mock.call.getHost('fakehost'), mock.call.modifyHost( 'fakehost', { 'FCWWNs': ['123456789012345', '123456789054321'], 'pathOperation': 1}), mock.call.getHost('fakehost')] mock_client.assert_has_calls(expected) self.assertEqual(host['name'], self.FAKE_HOST) self.assertEqual(len(host['FCPaths']), 2) def test_modify_host_with_new_wwn(self): # setup_mock_client drive with default configuration # and return the mock HTTP 3PAR client mock_client = self.setup_driver() mock_client.getVolume.return_value = {'userCPG': HP3PAR_CPG} mock_client.getCPG.return_value = {} getHost_ret1 = { 'name': self.FAKE_HOST, 'FCPaths': [{'wwn': '123456789054321'}]} getHost_ret2 = { 'name': self.FAKE_HOST, 'FCPaths': [{'wwn': '123456789012345'}, {'wwn': '123456789054321'}]} mock_client.getHost.side_effect = [getHost_ret1, getHost_ret2] host = self.driver._create_host(self.volume, self.connector) expected = [ mock.call.getVolume('osv-0DM4qZEVSKON-DXN-NwVpw'), mock.call.getCPG(HP3PAR_CPG), mock.call.getHost('fakehost'), mock.call.modifyHost( 'fakehost', { 'FCWWNs': ['123456789012345'], 'pathOperation': 1}), mock.call.getHost('fakehost')] mock_client.assert_has_calls(expected) self.assertEqual(host['name'], self.FAKE_HOST) self.assertEqual(len(host['FCPaths']), 2) def test_modify_host_with_unknown_wwn_and_new_wwn(self): # setup_mock_client drive with default configuration # and return the mock HTTP 3PAR client mock_client = self.setup_driver() mock_client.getVolume.return_value = {'userCPG': HP3PAR_CPG} mock_client.getCPG.return_value = {} getHost_ret1 = { 'name': self.FAKE_HOST, 'FCPaths': [{'wwn': '123456789054321'}, {'wwn': 'xxxxxxxxxxxxxxx'}]} getHost_ret2 = { 'name': self.FAKE_HOST, 'FCPaths': [{'wwn': '123456789012345'}, {'wwn': '123456789054321'}, {'wwn': 'xxxxxxxxxxxxxxx'}]} mock_client.getHost.side_effect = [getHost_ret1, getHost_ret2] host = self.driver._create_host(self.volume, self.connector) expected = [ mock.call.getVolume('osv-0DM4qZEVSKON-DXN-NwVpw'), mock.call.getCPG(HP3PAR_CPG), mock.call.getHost('fakehost'), mock.call.modifyHost( 'fakehost', { 'FCWWNs': ['123456789012345'], 'pathOperation': 1}), mock.call.getHost('fakehost')] mock_client.assert_has_calls(expected) self.assertEqual(host['name'], self.FAKE_HOST) self.assertEqual(len(host['FCPaths']), 3) class TestHP3PARISCSIDriver(HP3PARBaseDriver, test.TestCase): TARGET_IQN = 'iqn.2000-05.com.3pardata:21810002ac00383d' TARGET_LUN = 186 properties = { 'driver_volume_type': 'iscsi', 'data': {'target_discovered': True, 'target_iqn': TARGET_IQN, 'target_lun': TARGET_LUN, 'target_portal': '1.1.1.2:1234'}} def setup_driver(self, config=None, mock_conf=None): self.ctxt = context.get_admin_context() mock_client = self.setup_mock_client( conf=config, m_conf=mock_conf, driver=hpdriver.HP3PARISCSIDriver) expected = [ mock.call.setSSHOptions( HP3PAR_SAN_IP, HP3PAR_USER_NAME, HP3PAR_USER_PASS, privatekey=HP3PAR_SAN_SSH_PRIVATE, port=HP3PAR_SAN_SSH_PORT, conn_timeout=HP3PAR_SAN_SSH_CON_TIMEOUT), mock.call.login(HP3PAR_USER_NAME, HP3PAR_USER_PASS), mock.call.getCPG(HP3PAR_CPG), mock.call.logout(), mock.call.login(HP3PAR_USER_NAME, HP3PAR_USER_PASS), mock.call.getPorts(), mock.call.logout()] mock_client.assert_has_calls(expected) mock_client.reset_mock() return mock_client def test_initialize_connection(self): # setup_mock_client drive with default configuration # and return the mock HTTP 3PAR client mock_client = self.setup_driver() mock_client.getVolume.return_value = {'userCPG': HP3PAR_CPG} mock_client.getCPG.return_value = {} mock_client.getHost.side_effect = [ hpexceptions.HTTPNotFound('fake'), {'name': self.FAKE_HOST}] mock_client.findHost.return_value = self.FAKE_HOST mock_client.getHostVLUNs.return_value = [ {'active': True, 'volumeName': self.VOLUME_3PAR_NAME, 'lun': self.TARGET_LUN, 'type': 0}] location = ("%(volume_name)s,%(lun_id)s,%(host)s,%(nsp)s" % {'volume_name': self.VOLUME_3PAR_NAME, 'lun_id': self.TARGET_LUN, 'host': self.FAKE_HOST, 'nsp': 'something'}) mock_client.createVLUN.return_value = location result = self.driver.initialize_connection(self.volume, self.connector) expected = [ mock.call.login(HP3PAR_USER_NAME, HP3PAR_USER_PASS), mock.call.getVolume(self.VOLUME_3PAR_NAME), mock.call.getCPG(HP3PAR_CPG), mock.call.getHost(self.FAKE_HOST), mock.call.findHost(iqn='iqn.1993-08.org.debian:01:222'), mock.call.getHost(self.FAKE_HOST), mock.call.createVLUN( self.VOLUME_3PAR_NAME, auto=True, hostname='fakehost', portPos={'node': 8, 'slot': 1, 'cardPort': 1}), mock.call.getHostVLUNs(self.FAKE_HOST), mock.call.logout()] mock_client.assert_has_calls(expected) self.assertDictMatch(result, self.properties) def test_get_volume_stats(self): # setup_mock_client drive with default configuration # and return the mock HTTP 3PAR client mock_client = self.setup_driver() mock_client.getCPG.return_value = self.cpgs[0] mock_client.getStorageSystemInfo.return_value = {'serialNumber': '1234'} stats = self.driver.get_volume_stats(True) self.assertEqual(stats['storage_protocol'], 'iSCSI') self.assertEqual(stats['total_capacity_gb'], 'infinite') self.assertEqual(stats['free_capacity_gb'], 'infinite') expected = [ mock.call.login(HP3PAR_USER_NAME, HP3PAR_USER_PASS), mock.call.getCPG(HP3PAR_CPG), mock.call.getStorageSystemInfo(), mock.call.logout()] mock_client.assert_has_calls(expected) self.assertEqual(stats['storage_protocol'], 'iSCSI') self.assertEqual(stats['total_capacity_gb'], 'infinite') self.assertEqual(stats['free_capacity_gb'], 'infinite') cpg2 = self.cpgs[0].copy() cpg2.update({'SDGrowth': {'limitMiB': 8192}}) mock_client.getCPG.return_value = cpg2 const = 0.0009765625 stats = self.driver.get_volume_stats(True) self.assertEqual(stats['storage_protocol'], 'iSCSI') total_capacity_gb = 8192 * const self.assertEqual(stats['total_capacity_gb'], total_capacity_gb) free_capacity_gb = int( (8192 - self.cpgs[0]['UsrUsage']['usedMiB']) * const) self.assertEqual(stats['free_capacity_gb'], free_capacity_gb) def test_create_host(self): # setup_mock_client drive with default configuration # and return the mock HTTP 3PAR client mock_client = self.setup_driver() mock_client.getVolume.return_value = {'userCPG': HP3PAR_CPG} mock_client.getCPG.return_value = {} mock_client.getHost.side_effect = [ hpexceptions.HTTPNotFound('fake'), {'name': self.FAKE_HOST}] mock_client.findHost.return_value = None mock_client.getVLUN.return_value = {'lun': self.TARGET_LUN} host = self.driver._create_host(self.volume, self.connector) expected = [ mock.call.getVolume('osv-0DM4qZEVSKON-DXN-NwVpw'), mock.call.getCPG(HP3PAR_CPG), mock.call.getHost(self.FAKE_HOST), mock.call.findHost(iqn='iqn.1993-08.org.debian:01:222'), mock.call.createHost( self.FAKE_HOST, optional={'domain': None, 'persona': 1}, iscsiNames=['iqn.1993-08.org.debian:01:222']), mock.call.getHost(self.FAKE_HOST)] mock_client.assert_has_calls(expected) self.assertEqual(host['name'], self.FAKE_HOST) def test_create_invalid_host(self): # setup_mock_client drive with default configuration # and return the mock HTTP 3PAR client mock_client = self.setup_driver() mock_client.getVolume.return_value = {'userCPG': HP3PAR_CPG} mock_client.getCPG.return_value = {} mock_client.getHost.side_effect = [ hpexceptions.HTTPNotFound('Host not found.'), {'name': 'fakehost.foo'}] mock_client.findHost.return_value = 'fakehost.foo' host = self.driver._create_host(self.volume, self.connector) expected = [ mock.call.getVolume('osv-0DM4qZEVSKON-DXN-NwVpw'), mock.call.getCPG(HP3PAR_CPG), mock.call.getHost(self.FAKE_HOST), mock.call.findHost(iqn='iqn.1993-08.org.debian:01:222'), mock.call.getHost('fakehost.foo')] mock_client.assert_has_calls(expected) self.assertEqual(host['name'], 'fakehost.foo') def test_create_modify_host(self): # setup_mock_client drive with default configuration # and return the mock HTTP 3PAR client mock_client = self.setup_driver() mock_client.getVolume.return_value = {'userCPG': HP3PAR_CPG} mock_client.getCPG.return_value = {} mock_client.getHost.side_effect = [ {'name': self.FAKE_HOST, 'FCPaths': []}, {'name': self.FAKE_HOST, 'FCPaths': [{'wwn': '123456789012345'}, {'wwn': '123456789054321'}]}] host = self.driver._create_host(self.volume, self.connector) expected = [ mock.call.getVolume('osv-0DM4qZEVSKON-DXN-NwVpw'), mock.call.getCPG(HP3PAR_CPG), mock.call.getHost(self.FAKE_HOST), mock.call.modifyHost( self.FAKE_HOST, {'pathOperation': 1, 'iSCSINames': ['iqn.1993-08.org.debian:01:222']}), mock.call.getHost(self.FAKE_HOST)] mock_client.assert_has_calls(expected) self.assertEqual(host['name'], self.FAKE_HOST) self.assertEqual(len(host['FCPaths']), 2) def test_get_least_used_nsp_for_host_single(self): # setup_mock_client drive with default configuration # and return the mock HTTP 3PAR client mock_client = self.setup_driver() mock_client.getPorts.return_value = PORTS_RET mock_client.getVLUNs.return_value = VLUNS1_RET #Setup a single ISCSI IP iscsi_ips = ["10.10.220.253"] self.driver.configuration.hp3par_iscsi_ips = iscsi_ips self.driver.initialize_iscsi_ports() nsp = self.driver._get_least_used_nsp_for_host('newhost') self.assertEqual(nsp, "1:8:1") def test_get_least_used_nsp_for_host_new(self): # setup_mock_client drive with default configuration # and return the mock HTTP 3PAR client mock_client = self.setup_driver() mock_client.getPorts.return_value = PORTS_RET mock_client.getVLUNs.return_value = VLUNS1_RET #Setup two ISCSI IPs iscsi_ips = ["10.10.220.252", "10.10.220.253"] self.driver.configuration.hp3par_iscsi_ips = iscsi_ips self.driver.initialize_iscsi_ports() # Host 'newhost' does not yet have any iscsi paths, # so the 'least used' is returned nsp = self.driver._get_least_used_nsp_for_host('newhost') self.assertEqual(nsp, "1:8:2") def test_get_least_used_nsp_for_host_reuse(self): # setup_mock_client drive with default configuration # and return the mock HTTP 3PAR client mock_client = self.setup_driver() mock_client.getPorts.return_value = PORTS_RET mock_client.getVLUNs.return_value = VLUNS1_RET #Setup two ISCSI IPs iscsi_ips = ["10.10.220.252", "10.10.220.253"] self.driver.configuration.hp3par_iscsi_ips = iscsi_ips self.driver.initialize_iscsi_ports() # hosts 'foo' and 'bar' already have active iscsi paths # the same one should be used nsp = self.driver._get_least_used_nsp_for_host('foo') self.assertEqual(nsp, "1:8:2") nsp = self.driver._get_least_used_nsp_for_host('bar') self.assertEqual(nsp, "1:8:1") def test_get_least_used_nps_for_host_fc(self): # setup_mock_client drive with default configuration # and return the mock HTTP 3PAR client mock_client = self.setup_driver() mock_client.getPorts.return_value = PORTS1_RET mock_client.getVLUNs.return_value = VLUNS5_RET #Setup two ISCSI IPs iscsi_ips = ["10.10.220.252", "10.10.220.253"] self.driver.configuration.hp3par_iscsi_ips = iscsi_ips self.driver.initialize_iscsi_ports() nsp = self.driver._get_least_used_nsp_for_host('newhost') self.assertNotEqual(nsp, "0:6:3") self.assertEqual(nsp, "1:8:1") def test_invalid_iscsi_ip(self): config = self.setup_configuration() config.hp3par_iscsi_ips = ['10.10.220.250', '10.10.220.251'] config.iscsi_ip_address = '10.10.10.10' mock_conf = { 'getPorts.return_value': { 'members': [ {'portPos': {'node': 1, 'slot': 8, 'cardPort': 2}, 'protocol': 2, 'IPAddr': '10.10.220.252', 'linkState': 4, 'device': [], 'iSCSIName': self.TARGET_IQN, 'mode': 2, 'HWAddr': '2C27D75375D2', 'type': 8}, {'portPos': {'node': 1, 'slot': 8, 'cardPort': 1}, 'protocol': 2, 'IPAddr': '10.10.220.253', 'linkState': 4, 'device': [], 'iSCSIName': self.TARGET_IQN, 'mode': 2, 'HWAddr': '2C27D75375D6', 'type': 8}]}} # no valid ip addr should be configured. self.assertRaises(exception.InvalidInput, self.setup_driver, config=config, mock_conf=mock_conf) def test_get_least_used_nsp(self): # setup_mock_client drive with default configuration # and return the mock HTTP 3PAR client mock_client = self.setup_driver() ports = [ {'portPos': {'node': 1, 'slot': 8, 'cardPort': 2}, 'active': True}, {'portPos': {'node': 1, 'slot': 8, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 1, 'slot': 8, 'cardPort': 2}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 2}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 1}, 'active': True}] mock_client.getVLUNs.return_value = {'members': ports} # in use count vluns = self.driver.common.client.getVLUNs() nsp = self.driver._get_least_used_nsp(vluns['members'], ['0:2:1', '1:8:1']) self.assertEqual(nsp, '1:8:1') ports = [ {'portPos': {'node': 1, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 1, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 1, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 1, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 1}, 'active': True}] mock_client.getVLUNs.return_value = {'members': ports} # in use count vluns = self.driver.common.client.getVLUNs() nsp = self.driver._get_least_used_nsp(vluns['members'], ['0:2:1', '1:2:1']) self.assertEqual(nsp, '1:2:1') ports = [ {'portPos': {'node': 1, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 1, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 1, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 1, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 1}, 'active': True}, {'portPos': {'node': 0, 'slot': 2, 'cardPort': 1}, 'active': True}]
import numpy as np import math import time from scipy.spatial.transform import Rotation from ..common import Vec, equal_angle from .realtime.constants import * class Joints(Vec): ''' A vector of 6 elements representing joint properties. The order is: base, shoulder, elbow, wrist1, wrist2, wrist3. ''' BASE = 0 SHOULDER = 1 ELBOW = 2 WRIST1 = 3 WRIST2 = 4 WRIST3 = 5 def __init__(self, base=0, shoulder=0, elbow=0, wrist1=0, wrist2=0, wrist3=0): super().__init__(6) self.array[:] = [base, shoulder, elbow, wrist1, wrist2, wrist3] def allclose(self, array, tolerance = UR_JOINTS_POSITION_TOLERANCE): if isinstance(array, Tool): raise TypeError("Cannot compare joint positions with tool pose.") if np.allclose(self.array, array, rtol=0, atol=tolerance): return True for i in range(len(array)): if not equal_angle(self.array[i], array[i], tolerance): return False return True class JointSpeeds(Joints): pass class Tool(Vec): ''' A vector of 6 elements representing tool position and orientation. Orientation is stored as axis angles. The order is: x, y, z, rx, ry, rz. ''' X = 0 Y = 1 Z = 2 RX = 3 RY = 4 RZ = 5 def __init__(self, x=0, y=0, z=0, rx=0, ry=0, rz=0): super().__init__(6) self.array[:] = [x, y, z, rx, ry, rz] def allclose(self, array, position_tolerance = UR_TOOL_POSITION_TOLERANCE, rotation_tolerance = UR_TOOL_ROTATION_TOLERANCE): if isinstance(array, Joints): raise TypeError("Cannot compare tool pose with joint positions.") if not np.allclose(self.array[:3], array[:3], rtol=0, atol=position_tolerance): return False # normalize the two rotation vectors first a = Rotation.from_rotvec(self.array[3:6]).as_euler("xyz") b = Rotation.from_rotvec(array[3:6]).as_euler("xyz") return equal_angle(a[0], b[0], rotation_tolerance) \ and equal_angle(a[1], b[1], rotation_tolerance) \ and equal_angle(a[2], b[2], rotation_tolerance) @staticmethod def from_xyzrpy(xyzrpy): r = Rotation.from_euler("xyz", xyzrpy[3:]).as_rotvec() return Tool.fromarray(np.concatenate((xyzrpy[:3], r))) def to_xyzrpy(self): r = Rotation.from_rotvec(self.array[3:]).as_euler("xyz") return np.concatenate((self.array[:3], r)) def position(self): return self.array[:3] def orientation(self): return Rotation.from_rotvec(self.array[3:]).as_quat() class ToolSpeed(Tool): pass ################################################################ ## Arm state. ################################################################ class State(Vec): ''' The state of a 6-dof arm, encoded as a 72-valued vector. ''' _BUFFER_SIZE = UR_STATE_ENTRIES_COUNT _TIME = UR_STATE_TIME _CMD_ID = UR_STATE_CMD_ID _STATUS = UR_STATE_STATUS _JOINT_POSITIONS = slice(*UR_STATE_JOINT_POSITIONS) _JOINT_SPEEDS = slice(*UR_STATE_JOINT_SPEEDS) _TOOL_POSE = slice(*UR_STATE_TOOL_POSE) _TOOL_SPEED = slice(*UR_STATE_TOOL_SPEED) _TARGET_JOINT_POSITIONS = slice(*UR_STATE_TARGET_JOINT_POSITIONS) _TARGET_JOINT_SPEEDS = slice(*UR_STATE_TARGET_JOINT_SPEEDS) _TARGET_TOOL_POSE = slice(*UR_STATE_TARGET_TOOL_POSE) _TARGET_TOOL_SPEED = slice(*UR_STATE_TARGET_TOOL_SPEED) _TOOL_FORCE = slice(*UR_STATE_TOOL_FORCE) _JOINT_TORQUES = slice(*UR_STATE_JOINT_TORQUES) _TOOL_ACCELERATION = slice(*UR_STATE_TOOL_ACCELERATION) _SENSOR_FORCE = slice(*UR_STATE_SENSOR_FORCE) _STATUS_FLAG_MOVING = UR_STATUS_FLAG_MOVING _STATUS_FLAG_CONTACT = UR_STATUS_FLAG_CONTACT _STATUS_FLAG_DEADMAN = UR_STATUS_FLAG_DEADMAN _STATUS_FLAG_DONE = UR_STATUS_FLAG_DONE _STATUS_FLAG_GOAL_REACHED = UR_STATUS_FLAG_GOAL_REACHED def __init__(self): super().__init__(State._BUFFER_SIZE) def time(self): '''The time when the response was generated, in robot time''' return self[State._TIME] def cmd_id(self): '''The id of the last drive command, set to client time when command was submitted.''' return self[State._CMD_ID] def is_moving(self): '''True if the arm is stopped, false if the arm is moving.''' return int(self[State._STATUS]) & State._STATUS_FLAG_MOVING != 0 def is_contact(self): ''' True if the arm is experiencing a force greater than threshold specified with the last move command.''' return int(self[State._STATUS]) & State._STATUS_FLAG_CONTACT != 0 def is_deadman_switch_triggered(self): '''True if the arm stopped because of a deadman switch, false otherwise.''' return int(self[State._STATUS]) & State._STATUS_FLAG_DEADMAN != 0 def is_goal_reached(self): ''' True if the arm reached the goal established by the last move command, False otherwise. The flag is meaningful only when is_done() is also True''' return int(self[State._STATUS]) & State._STATUS_FLAG_GOAL_REACHED != 0 def is_done(self): ''' True if the arm completed the last move command.''' return int(self[State._STATUS]) & State._STATUS_FLAG_DONE != 0 def joint_positions(self): '''The current actual joint angular position vector in rad : [Base, Shoulder, Elbow, Wrist1, Wrist2, Wrist3]''' return Joints.fromarray(self[State._JOINT_POSITIONS], False) def joint_speeds(self): '''The current actual joint angular velocity vector in rad/s: [Base, Shoulder, Elbow, Wrist1, Wrist2, Wrist3]''' return JointSpeeds.fromarray(self[State._JOINT_SPEEDS], False) def tool_pose(self): '''The current actual TCP vector : ([X, Y, Z, Rx, Ry, Rz])''' return Tool.fromarray(self[State._TOOL_POSE], False) def tool_speed(self): '''The current actual TCP velocity vector; ([X, Y, Z, Rx, Ry, Rz])''' return ToolSpeed.fromarray(self[State._TOOL_SPEED], False) def target_joint_positions(self): '''The current target joint angular position vector in rad: [Base, Shoulder, Elbow, Wrist1, Wrist2, Wrist3]''' return Joints.fromarray(self[State._TARGET_JOINT_POSITIONS], False) def target_joint_speeds(self): '''The current target joint angular velocity vector in rad/s: [Base, Shoulder, Elbow, Wrist1, Wrist2, Wrist3]''' return JointSpeeds.fromarray(self[State._TARGET_JOINT_SPEEDS], False) def target_tool_pose(self): '''The current target TCP vector; ([X, Y, Z, Rx, Ry, Rz])''' return Tool.fromarray(self[State._TARGET_TOOL_POSE], False) def target_tool_speed(self): '''The TCP speed. The first three values are the cartesian speeds along x,y,z, and the last three define the current rotation axis, rx,ry,rz, and the length|rz,ry,rz|defines the angular velocity in radians/s''' return ToolSpeed.fromarray(self[State._TARGET_TOOL_SPEED], False) def tool_force(self): '''Returns the wrench (Force/Torque vector) at the TCP. The external wrench is computed based on the error between the joint torques required to stay on the trajectory and the expected joint torques. The function returns ”p[Fx (N), Fy(N), Fz(N), TRx (Nm), TRy (Nm), TRz (Nm)]”, where Fx, Fy, and Fx are the forces in the axes of the robot base coordinate system measured in Newtons, and TRx, TRy, and TRz are the torques around these axes measyred in Newton times Meters. ''' return Tool.fromarray(self[State._TOOL_FORCE], False) def joint_torques(self): '''The torque on the joints, corrected by the torque needed to move the robot itself (gravity, friction, etc.), returned as a vector of length 6.''' return Joints.fromarray(self[State._JOINT_TORQUES], False) def tool_acceleration(self): '''The accelerometer reading, in the robot base coordinate system''' return self[State._TOOL_ACCELERATION] def sensor_force(self): '''The forces and moments reported by the Force/Torque sensor mounted on the wrist, in the axes of the robot base coordinate system''' return Tool.fromarray(self[State._SENSOR_FORCE], False) def _set_state_flag(self, flag, value): if value: self[State._STATUS] = int(self[State._STATUS]) | flag else: self[State._STATUS] = int(self[State._STATUS]) & (0xFFFFFFFF ^ flag) ################################################################ ## Arm commands ################################################################ class Command(Vec): ''' Represents a command that can be sent to the arm. The move target can be joint speeds, or an absolute position, specified either as a tool pose or as joint angles. In either case, the arm stops when contact is detected, that is, if fabs(actual_force - expected_force) > max_force. The type of reaction to contact is determined by the contact_handling parameter. An optional motion controller choice can be specified using the controller parameter. Other commands (read and config) can be initialized using the as_xxx methods. ''' _BUFFER_SIZE = UR_CMD_ENTRIES_COUNT _ID = UR_CMD_ID _KIND = UR_CMD_KIND _CONFIG_MASS = UR_CMD_CONFIG_MASS _CONFIG_TOOL_COG = slice(*UR_CMD_CONFIG_TOOL_COG) _CONFIG_TOOL_TIP = slice(*UR_CMD_CONFIG_TOOL_TIP) _MOVE_TARGET = slice(*UR_CMD_MOVE_TARGET) _MOVE_MAX_SPEED = UR_CMD_MOVE_MAX_SPEED _MOVE_MAX_ACCELERATION = UR_CMD_MOVE_MAX_ACCELERATION _MOVE_FORCE_LOW_BOUND = slice(*UR_CMD_MOVE_FORCE_LOW_BOUND) _MOVE_FORCE_HIGH_BOUND = slice(*UR_CMD_MOVE_FORCE_HIGH_BOUND) _MOVE_CONTACT_HANDLING = UR_CMD_MOVE_CONTACT_HANDLING _MOVE_CONTROLLER = UR_CMD_MOVE_CONTROLLER def __init__(self): super().__init__(Command._BUFFER_SIZE) self[Command._KIND] = UR_CMD_KIND_ESTOP def make(self, kind = UR_CMD_KIND_READ, target=UR_ZERO, max_speed=UR_DEFAULT_MAX_SPEED, max_acc=UR_DEFAULT_ACCELERATION, force_low_bound:Tool=UR_DEFAULT_FORCE_LOW_BOUND, force_high_bound:Tool=UR_DEFAULT_FORCE_HIGH_BOUND, contact_handling=0, controller_flags=0): self[Command._KIND] = kind self[Command._MOVE_TARGET] = target self[Command._MOVE_MAX_SPEED] = max_speed self[Command._MOVE_MAX_ACCELERATION] =max_acc self[Command._MOVE_FORCE_LOW_BOUND] = force_low_bound if force_low_bound is not None else UR_FORCE_IGNORE_LOW self[Command._MOVE_FORCE_HIGH_BOUND] = force_high_bound if force_high_bound is not None else UR_FORCE_IGNORE_HIGH self[Command._MOVE_CONTACT_HANDLING] = contact_handling self[Command._MOVE_CONTROLLER] = controller_flags return self def id(self): return self[Command._ID] def kind(self): return self[Command._KIND] def target(self): if self[Command._KIND] == UR_CMD_KIND_MOVE_TOOL_POSE or self[Command._KIND] == UR_CMD_KIND_MOVE_TOOL_LINEAR: return Tool.fromarray(self[Command._MOVE_TARGET], False) elif self[Command._KIND] == UR_CMD_KIND_MOVE_JOINT_POSITIONS: return Joints.fromarray(self[Command._MOVE_TARGET], False) return JointSpeeds.fromarray(self[Command._MOVE_TARGET], False) def max_speed(self): return self[Command._MOVE_MAX_SPEED] def max_acceleration(self): return self[Command._MOVE_MAX_ACCELERATION] def force_low_bound(self): return Tool.fromarray(self[Command._MOVE_FORCE_LOW_BOUND], False) def force_high_bound(self): return Tool.fromarray(self[Command._MOVE_FORCE_HIGH_BOUND], False) def contact_handling(self): return self[Command._MOVE_CONTACT_HANDLING] def controller_flags(self): return self[Command._MOVE_CONTROLLER] def is_move_command(self): return self[Command._KIND] > UR_CMD_KIND_ESTOP and self[Command._KIND] < UR_CMD_KIND_READ def _goal_reached(self, state): if self[Command._KIND] == UR_CMD_KIND_MOVE_JOINT_SPEEDS: return self.target().allclose(state.joint_speeds(), UR_SPEED_TOLERANCE) elif self[Command._KIND] == UR_CMD_KIND_MOVE_JOINT_POSITIONS: return self.target().allclose(state.joint_positions()) and not state.is_moving() elif self[Command._KIND] == UR_CMD_KIND_MOVE_TOOL_POSE or self[Command._KIND] == UR_CMD_KIND_MOVE_TOOL_LINEAR: return self.target().allclose(state.tool_pose()) and not state.is_moving() else: raise Exception("Invalid command type") class Arm: _READ_CMD = Command() def __init__(self, controller): self.controller = controller self.command = Command() self.state = State() def __execute(self, blocking): self.command[Command._ID] = time.time() self.controller.execute(self.command, self.state) while blocking and not self.state.is_done(): self.controller.execute(self.command, self.state) def execute(self, command, blocking): self.command[:] = command self.__execute(blocking) def step(self): self.controller.execute(self.command, self.state) def read(self): self.execute(Arm._READ_CMD, False) def get_inverse_kinematics(self, target_position): if type(target_position) is not Tool: raise TypeError('Argument target_position must be of type Tool.') self.command.make( kind = UR_CMD_KIND_IK_QUERY, target = target_position) self.__execute(blocking=False) return self.state.target_joint_positions().clone() def move(self, target_position, max_speed=UR_DEFAULT_MAX_SPEED, max_acc=UR_DEFAULT_ACCELERATION, force_low_bound=UR_DEFAULT_FORCE_LOW_BOUND, force_high_bound=UR_DEFAULT_FORCE_HIGH_BOUND, contact_handling=0, controller_flags=0, blocking=True): if type(target_position) is Joints: cmd_type = UR_CMD_KIND_MOVE_JOINT_POSITIONS elif type(target_position) is Tool: cmd_type = UR_CMD_KIND_MOVE_TOOL_POSE elif type(target_position) is JointSpeeds: cmd_type = UR_CMD_KIND_MOVE_JOINT_SPEEDS else: raise TypeError('Argument target_position must be of type Tool, Joints or JointSpeeds. ' 'Use [Tool|Joints|JointSpeeds].fromarray() to wrap an existing array.') self.command.make( kind = cmd_type, target = target_position, max_speed=max_speed, max_acc=max_acc, force_low_bound=force_low_bound, force_high_bound=force_high_bound, contact_handling=contact_handling, controller_flags=controller_flags) self.__execute(blocking) def speed(self, target_speed, acc=UR_DEFAULT_ACCELERATION, force_low_bound=UR_DEFAULT_FORCE_LOW_BOUND, force_high_bound=UR_DEFAULT_FORCE_HIGH_BOUND, contact_handling=0, controller_flags=0, blocking=True): if type(target_speed) is not JointSpeeds: raise TypeError("Speed can only be specified
= self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['Basic Authentication', 'Token Authentication'] # noqa: E501 response_type = 'Nic' if 'response_type' in kwargs: response_type = kwargs['response_type'] return self.api_client.call_api( '/datacenters/{datacenterId}/lans/{lanId}/nics/{nicId}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=response_type, # noqa: E501 auth_settings=auth_settings, async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), collection_formats=collection_formats, _request_auth=local_var_params.get('_request_auth')) def datacenters_lans_nics_get(self, datacenter_id, lan_id, **kwargs): # noqa: E501 """List Lan Members # noqa: E501 You can retrieve a list of nics attached to a lan # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.datacenters_lans_nics_get(datacenter_id, lan_id, async_req=True) >>> result = thread.get() :param datacenter_id: The unique ID of the datacenter (required) :type datacenter_id: str :param lan_id: The unique ID of the LAN (required) :type lan_id: str :param pretty: Controls whether response is pretty-printed (with indentation and new lines) :type pretty: bool :param depth: Controls the details depth of response objects. Eg. GET /datacenters/[ID] - depth=0: only direct properties are included. Children (servers etc.) are not included - depth=1: direct properties and children references are included - depth=2: direct properties and children properties are included - depth=3: direct properties and children properties and children's children are included - depth=... and so on :type depth: int :param x_contract_number: Users having more than 1 contract need to provide contract number, against which all API requests should be executed :type x_contract_number: int :param offset: the first element (of the total list of elements) to include in the response (use together with <code>limit</code> for pagination) :type offset: int :param limit: the maximum number of elements to return (use together with <code>offset</code> for pagination) :type limit: int :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: LanNics """ kwargs['_return_http_data_only'] = True return self.datacenters_lans_nics_get_with_http_info(datacenter_id, lan_id, **kwargs) # noqa: E501 def datacenters_lans_nics_get_with_http_info(self, datacenter_id, lan_id, **kwargs): # noqa: E501 """List Lan Members # noqa: E501 You can retrieve a list of nics attached to a lan # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.datacenters_lans_nics_get_with_http_info(datacenter_id, lan_id, async_req=True) >>> result = thread.get() :param datacenter_id: The unique ID of the datacenter (required) :type datacenter_id: str :param lan_id: The unique ID of the LAN (required) :type lan_id: str :param pretty: Controls whether response is pretty-printed (with indentation and new lines) :type pretty: bool :param depth: Controls the details depth of response objects. Eg. GET /datacenters/[ID] - depth=0: only direct properties are included. Children (servers etc.) are not included - depth=1: direct properties and children references are included - depth=2: direct properties and children properties are included - depth=3: direct properties and children properties and children's children are included - depth=... and so on :type depth: int :param x_contract_number: Users having more than 1 contract need to provide contract number, against which all API requests should be executed :type x_contract_number: int :param offset: the first element (of the total list of elements) to include in the response (use together with <code>limit</code> for pagination) :type offset: int :param limit: the maximum number of elements to return (use together with <code>offset</code> for pagination) :type limit: int :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(LanNics, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() all_params = [ 'datacenter_id', 'lan_id', 'pretty', 'depth', 'x_contract_number', 'offset', 'limit' ] all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', 'response_type' ] ) for local_var_params_key, local_var_params_val in six.iteritems(local_var_params['kwargs']): if local_var_params_key not in all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method datacenters_lans_nics_get" % local_var_params_key ) local_var_params[local_var_params_key] = local_var_params_val del local_var_params['kwargs'] # verify the required parameter 'datacenter_id' is set if self.api_client.client_side_validation and ('datacenter_id' not in local_var_params or # noqa: E501 local_var_params['datacenter_id'] is None): # noqa: E501 raise ApiValueError("Missing the required parameter `datacenter_id` when calling `datacenters_lans_nics_get`") # noqa: E501 # verify the required parameter 'lan_id' is set if self.api_client.client_side_validation and ('lan_id' not in local_var_params or # noqa: E501 local_var_params['lan_id'] is None): # noqa: E501 raise ApiValueError("Missing the required parameter `lan_id` when calling `datacenters_lans_nics_get`") # noqa: E501 if self.api_client.client_side_validation and 'depth' in local_var_params and local_var_params['depth'] > 10: # noqa: E501 raise ApiValueError("Invalid value for parameter `depth` when calling `datacenters_lans_nics_get`, must be a value less than or equal to `10`") # noqa: E501 if self.api_client.client_side_validation and 'depth' in local_var_params and local_var_params['depth'] < 0: # noqa: E501 raise ApiValueError("Invalid value for parameter `depth` when calling `datacenters_lans_nics_get`, must be a value greater than or equal to `0`") # noqa: E501 if self.api_client.client_side_validation and 'offset' in local_var_params and local_var_params['offset'] < 0: # noqa: E501 raise ApiValueError("Invalid value for parameter `offset` when calling `datacenters_lans_nics_get`, must be a value greater than or equal to `0`") # noqa: E501 if self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] > 10000: # noqa: E501 raise ApiValueError("Invalid value for parameter `limit` when calling `datacenters_lans_nics_get`, must be a value less than or equal to `10000`") # noqa: E501 if self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] < 1: # noqa: E501 raise ApiValueError("Invalid value for parameter `limit` when calling `datacenters_lans_nics_get`, must be a value greater than or equal to `1`") # noqa: E501 collection_formats = {} path_params = {} if 'datacenter_id' in local_var_params: path_params['datacenterId'] = local_var_params['datacenter_id'] # noqa: E501 if 'lan_id' in local_var_params: path_params['lanId'] = local_var_params['lan_id'] # noqa: E501 query_params = [] if 'pretty' in local_var_params and local_var_params['pretty'] is not None: # noqa: E501 query_params.append(('pretty', local_var_params['pretty'])) # noqa: E501 if 'depth' in local_var_params and local_var_params['depth'] is not None: # noqa: E501 query_params.append(('depth', local_var_params['depth'])) # noqa: E501 if 'offset' in local_var_params and local_var_params['offset'] is not None: # noqa: E501 query_params.append(('offset', local_var_params['offset'])) # noqa: E501 if 'limit' in local_var_params and local_var_params['limit'] is not None: # noqa: E501 query_params.append(('limit', local_var_params['limit'])) # noqa: E501 header_params = {} if 'x_contract_number' in local_var_params: header_params['X-Contract-Number'] = local_var_params['x_contract_number'] # noqa: E501 form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['Basic Authentication', 'Token Authentication'] # noqa: E501 response_type = 'LanNics' if 'response_type' in kwargs: response_type = kwargs['response_type'] return self.api_client.call_api( '/datacenters/{datacenterId}/lans/{lanId}/nics', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=response_type, # noqa: E501 auth_settings=auth_settings, async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), collection_formats=collection_formats, _request_auth=local_var_params.get('_request_auth')) def datacenters_lans_nics_post(self, datacenter_id, lan_id, nic, **kwargs): # noqa: E501 """Attach a nic # noqa: E501 This will attach a pre-existing nic to a lan. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.datacenters_lans_nics_post(datacenter_id, lan_id, nic, async_req=True) >>> result = thread.get() :param datacenter_id: The unique ID of the datacenter (required) :type datacenter_id: str :param lan_id: The unique ID of the LAN (required) :type lan_id: str :param nic: Nic to be
# All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import itertools from rally.common import cfg from rally.common import logging from rally import exceptions from rally.task import atomic from rally.task import service from rally_openstack.common.services.network import net_utils CONF = cfg.CONF LOG = logging.getLogger(__name__) def _args_adapter(arguments_map): def wrapper(func): def decorator(*args, **kwargs): for source, dest in arguments_map.items(): if source in kwargs: if dest in kwargs: raise TypeError( f"{func.__name__}() accepts either {dest} keyword " f"argument or {source} but both were specified.") kwargs[dest] = kwargs.pop(source) return func(*args, **kwargs) return decorator return wrapper _NETWORK_ARGS_MAP = { "provider:network_type": "provider_network_type", "provider:physical_network": "provider_physical_network", "provider:segmentation_id": "provider_segmentation_id", "router:external": "router_external" } def _create_network_arg_adapter(): """A decorator for converting neutron's create kwargs to look pythonic.""" return _args_adapter(_NETWORK_ARGS_MAP) class _NoneObj(object): def __len__(self): return 0 _NONE = _NoneObj() def _clean_dict(**kwargs): """Builds a dict object from keyword arguments ignoring nullable values.""" return dict((k, v) for k, v in kwargs.items() if v != _NONE) @service.service(service_name="neutron", service_type="network", version="2.0") class NeutronService(service.Service): """A helper class for Neutron API""" def __init__(self, *args, **kwargs): super(NeutronService, self).__init__(*args, **kwargs) self._cached_supported_extensions = None self._client = None @property def client(self): if self._client is None: self._client = self._clients.neutron() return self._client def create_network_topology( self, network_create_args=None, router_create_args=None, router_per_subnet=False, subnet_create_args=None, subnets_count=1, subnets_dualstack=False ): """Create net infrastructure(network, router, subnets). :param network_create_args: A dict with creation arguments for a network. The format is equal to the create_network method :param router_create_args: A dict with creation arguments for an external router that will add an interface to each created subnet. The format is equal to the create_subnet method In case of None value (default behaviour), no router is created. :param router_per_subnet: whether or not to create router per subnet or use one router for all subnets. :param subnet_create_args: A dict with creation arguments for subnets. The format is equal to the create_subnet method. :param subnets_count: Number of subnets to create per network. Defaults to 1 :param subnets_dualstack: Whether subnets should be of both IPv4 and IPv6 (i.e first subnet will be created for IPv4, the second for IPv6, the third for IPv4,..). If subnet_create_args includes one of ('cidr', 'start_cidr', 'ip_version') keys, subnets_dualstack parameter will be ignored. """ subnet_create_args = dict(subnet_create_args or {}) network = self.create_network(**(network_create_args or {})) subnet_create_args["network_id"] = network["id"] routers = [] if router_create_args is not None: for i in range(subnets_count if router_per_subnet else 1): routers.append(self.create_router(**router_create_args)) subnets = [] ip_versions = itertools.cycle([4, 6] if subnets_dualstack else [4]) use_subnets_dualstack = ( "cidr" not in subnet_create_args and "start_cidr" not in subnet_create_args and "ip_version" not in subnet_create_args ) for i in range(subnets_count): if use_subnets_dualstack: subnet_create_args["ip_version"] = next(ip_versions) if routers: if router_per_subnet: router = routers[i] else: router = routers[0] subnet_create_args["router_id"] = router["id"] subnets.append(self.create_subnet(**subnet_create_args)) network["subnets"] = [s["id"] for s in subnets] return { "network": network, "subnets": subnets, "routers": routers } def delete_network_topology(self, topo): """Delete network topology This method was developed to provide a backward compatibility with old neutron helpers. It is not recommended way and we suggest to use cleanup manager instead. :param topo: Network topology as create_network_topology returned """ for router in topo["routers"]: self.remove_gateway_from_router(router["id"]) network_id = topo["network"]["id"] for port in self.list_ports(network_id=network_id): self.delete_port(port) for subnet in self.list_subnets(network_id=network_id): self.delete_subnet(subnet["id"]) self.delete_network(network_id) for router in topo["routers"]: self.delete_router(router["id"]) @atomic.action_timer("neutron.create_network") @_create_network_arg_adapter() def create_network(self, project_id=_NONE, admin_state_up=_NONE, dns_domain=_NONE, mtu=_NONE, port_security_enabled=_NONE, provider_network_type=_NONE, provider_physical_network=_NONE, provider_segmentation_id=_NONE, qos_policy_id=_NONE, router_external=_NONE, segments=_NONE, shared=_NONE, vlan_transparent=_NONE, description=_NONE, availability_zone_hints=_NONE): """Create neutron network. :param project_id: The ID of the project that owns the resource. Only administrative and users with advsvc role can specify a project ID other than their own. You cannot change this value through authorization policies. :param admin_state_up: The administrative state of the network, which is up (true) or down (false). :param dns_domain: A valid DNS domain. :param mtu: The maximum transmission unit (MTU) value to address fragmentation. Minimum value is 68 for IPv4, and 1280 for IPv6. :param port_security_enabled: The port security status of the network. Valid values are enabled (true) and disabled (false). This value is used as the default value of port_security_enabled field of a newly created port. :param provider_network_type: The type of physical network that this network should be mapped to. For example, flat, vlan, vxlan, or gre. Valid values depend on a networking back-end. :param provider_physical_network: The physical network where this network should be implemented. The Networking API v2.0 does not provide a way to list available physical networks. For example, the Open vSwitch plug-in configuration file defines a symbolic name that maps to specific bridges on each compute host. :param provider_segmentation_id: The ID of the isolated segment on the physical network. The network_type attribute defines the segmentation model. For example, if the network_type value is vlan, this ID is a vlan identifier. If the network_type value is gre, this ID is a gre key. :param qos_policy_id: The ID of the QoS policy associated with the network. :param router_external: Indicates whether the network has an external routing facility that’s not managed by the networking service. :param segments: A list of provider segment objects. :param shared: Indicates whether this resource is shared across all projects. By default, only administrative users can change this value. :param vlan_transparent: Indicates the VLAN transparency mode of the network, which is VLAN transparent (true) or not VLAN transparent (false). :param description: A human-readable description for the resource. Default is an empty string. :param availability_zone_hints: The availability zone candidate for the network. :returns: neutron network dict """ body = _clean_dict( name=self.generate_random_name(), tenant_id=project_id, admin_state_up=admin_state_up, dns_domain=dns_domain, mtu=mtu, port_security_enabled=port_security_enabled, qos_policy_id=qos_policy_id, segments=segments, shared=shared, vlan_transparent=vlan_transparent, description=description, availability_zone_hints=availability_zone_hints, **{ "provider:network_type": provider_network_type, "provider:physical_network": provider_physical_network, "provider:segmentation_id": provider_segmentation_id, "router:external": router_external } ) resp = self.client.create_network({"network": body}) return resp["network"] @atomic.action_timer("neutron.show_network") def get_network(self, network_id, fields=_NONE): """Get network by ID :param network_id: Network ID to fetch data for :param fields: The fields that you want the server to return. If no fields list is specified, the networking API returns all attributes allowed by the policy settings. By using fields parameter, the API returns only the requested set of attributes. """ body = _clean_dict(fields=fields) resp = self.client.show_network(network_id, **body) return resp["network"] def find_network(self, network_id_or_name): """Find network by identifier (id or name) :param network_id_or_name: Network ID or name """ for net in self.list_networks(): if network_id_or_name in (net["name"], net["id"]): return net raise exceptions.GetResourceFailure( resource="network", err=f"no name or id matches {network_id_or_name}") @atomic.action_timer("neutron.update_network") @_create_network_arg_adapter() def update_network(self, network_id, name=_NONE, admin_state_up=_NONE, dns_domain=_NONE, mtu=_NONE, port_security_enabled=_NONE, provider_network_type=_NONE, provider_physical_network=_NONE, provider_segmentation_id=_NONE, qos_policy_id=_NONE, router_external=_NONE, segments=_NONE, shared=_NONE, description=_NONE, is_default=_NONE): """Update neutron network. :param network_id: ID of the network to update :param name: Human-readable name of the network. :param admin_state_up: The administrative state of the network, which is up (true) or down (false). :param dns_domain: A valid DNS domain. :param mtu: The maximum transmission unit (MTU) value to address fragmentation. Minimum value is 68 for IPv4, and 1280 for IPv6. :param port_security_enabled: The port security status of the network. Valid values are enabled (true) and disabled (false). This value is used as the default value of port_security_enabled field of a newly created port. :param provider_network_type: The type of physical network that this network should be mapped to. For example, flat, vlan, vxlan, or gre. Valid values depend on a networking back-end. :param provider_physical_network: The physical network where this network should be implemented. The Networking API v2.0 does not provide a way to list available physical networks. For example, the Open vSwitch plug-in configuration file defines a symbolic name that maps to specific bridges on each compute host. :param provider_segmentation_id: The ID of the isolated segment on the physical network. The network_type attribute defines the segmentation model. For example, if the network_type value is vlan, this ID is a vlan identifier. If the network_type value is gre, this ID is
import logging import json import os import re import time from subprocess import CalledProcessError from .system import exec_shell class CloudCliError(Exception): pass class AWSCli: def __init__(self, bin_path=None): # aws CLI supported versions interval self.min_version = (0, 0, 0) self.max_version = (1, 19, 18) # Path to look up for executable self.bin_path = None # Force aws CLI binary path if bin_path exists and contains # aws file. if bin_path is not None and os.path.exists(bin_path): if os.path.exists(os.path.join(bin_path, 'aws')): self.bin_path = bin_path pass def check_version(self): """ Verify aws CLI version, based on the interval formed by min_version and max_version. aws CLI version is fetched using the command: aws --version """ try: output = exec_shell([self.bin("aws"), "--version"]) except CalledProcessError as e: logging.error("Failed to execute the command: %s", e.cmd) logging.error("Return code is: %s", e.returncode) logging.error("Output: %s", e.output) raise Exception( "aws CLI executable seems to be missing. Please install it or " "check your PATH variable" ) version = None # Parse command output and extract the version number pattern = re.compile(r"^aws-cli\/([0-9]+)\.([0-9]+)\.([0-9]+) ") for line in output.decode("utf-8").split("\n"): m = pattern.search(line) if m: version = (int(m.group(1)), int(m.group(2)), int(m.group(3))) break if version is None: raise Exception("Unable to parse aws CLI version") logging.info("aws CLI version: %s", '.'.join(map(str, version))) # Verify if the version fetched is supported for i in range(0, 3): min = self.min_version[i] max = self.max_version[i] if version[i] < max: # If current digit is below the maximum value, no need to # check others digits, we are good break if version[i] not in list(range(min, max + 1)): raise Exception( ("aws CLI version %s not supported, must be between %s and" " %s") % ( '.'.join(map(str, version)), '.'.join(map(str, self.min_version)), '.'.join(map(str, self.max_version)), ) ) def bin(self, binary): """ Return binary's path """ if self.bin_path is not None: return os.path.join(self.bin_path, binary) else: return binary def check_instance_type_availability(self, instance_type, region): try: output = exec_shell([ self.bin("aws"), "ec2", "describe-instance-type-offerings", "--location-type availability-zone", "--filters Name=instance-type,Values=%s" % instance_type, "--region %s" % region, "--output json" ]) result = json.loads(output.decode("utf-8")) logging.debug("Command output: %s", result) if len(result["InstanceTypeOfferings"]) == 0: raise CloudCliError( "Instance type %s not available in region %s" % (instance_type, region) ) except ValueError: # JSON decoding error logging.error("Failed to decode JSON data") logging.error("Output: %s", output.decode("utf-8")) raise CloudCliError( "Failed to decode JSON data, please check the logs for details" ) except CalledProcessError as e: logging.error("Failed to execute the command: %s", e.cmd) logging.error("Return code is: %s", e.returncode) logging.error("Output: %s", e.output) raise CloudCliError( "Failed to execute the following command, please check the " "logs for details: %s" % e.cmd ) def get_image_id(self, image, region): try: output = exec_shell([ self.bin("aws"), "ec2", "describe-images", "--filters Name=name,Values=\"%s\"" % image, "--query 'sort_by(Images, &Name)[-1]'", "--region %s" % region, "--output json" ]) result = json.loads(output.decode("utf-8")) logging.debug("Command output: %s", result) if result.get('State') == 'available': return result.get('ImageId') except ValueError: # JSON decoding error logging.error("Failed to decode JSON data") logging.error("Output: %s", output.decode("utf-8")) raise CloudCliError( "Failed to decode JSON data, please check the logs for details" ) except CalledProcessError as e: logging.error("Failed to execute the command: %s", e.cmd) logging.error("Return code is: %s", e.returncode) logging.error("Output: %s", e.output) raise CloudCliError( "Failed to execute the following command, please check the " "logs for details: %s" % e.cmd ) def check_instances_availability(self, region): try: output = exec_shell([ self.bin("aws"), "ec2", "wait", "instance-status-ok", "--region %s" % region ]) logging.debug("Command output: %s", output.decode("utf-8")) except CalledProcessError as e: logging.error("Failed to execute the command: %s", e.cmd) logging.error("Return code is: %s", e.returncode) logging.error("Output: %s", e.output) raise CloudCliError( "Failed to execute the following command, please check the " "logs for details: %s" % e.cmd ) class AWSRDSCli(AWSCli): def check_instance_type_availability(self, instance_type, region): try: output = exec_shell([ self.bin("aws"), "rds", "describe-reserved-db-instances-offerings", "--product-description postgresql", "--region %s" % region, "--db-instance-class %s" % instance_type, "--output json" ]) result = json.loads(output.decode("utf-8")) logging.debug("Command output: %s", result) if len(result["ReservedDBInstancesOfferings"]) == 0: raise CloudCliError( "Instance type %s not available in region %s" % (instance_type, region) ) except ValueError: # JSON decoding error logging.error("Failed to decode JSON data") logging.error("Output: %s", output.decode("utf-8")) raise CloudCliError( "Failed to decode JSON data, please check the logs for details" ) except CalledProcessError as e: logging.error("Failed to execute the command: %s", e.cmd) logging.error("Return code is: %s", e.returncode) logging.error("Output: %s", e.output) raise CloudCliError( "Failed to execute the following command, please check the " "logs for details: %s" % e.cmd ) class AWSRDSAuroraCli(AWSRDSCli): pass class AzureCli: def __init__(self, bin_path=None): # azure CLI supported versions interval self.min_version = (0, 0, 0) self.max_version = (2, 20, 0) # Path to look up for executable self.bin_path = None # Force azure CLI binary path if bin_path exists and contains # az file. if bin_path is not None and os.path.exists(bin_path): if os.path.exists(os.path.join(bin_path, 'az')): self.bin_path = bin_path def check_version(self): """ Verify azure CLI version, based on the interval formed by min_version and max_version. azure CLI version is fetched using the command: az --version """ try: output = exec_shell([self.bin("az"), "--version"]) except CalledProcessError as e: logging.error("Failed to execute the command: %s", e.cmd) logging.error("Return code is: %s", e.returncode) logging.error("Output: %s", e.output) raise Exception( "azure CLI executable seems to be missing. Please install it or " "check your PATH variable" ) version = None # Parse command output and extract the version number pattern = re.compile(r"^azure-cli\s+([0-9]+)\.([0-9]+)\.([0-9]+)") for line in output.decode("utf-8").split("\n"): m = pattern.search(line) if m: version = (int(m.group(1)), int(m.group(2)), int(m.group(3))) break if version is None: raise Exception("Unable to parse azure CLI version") logging.info("azure CLI version: %s", '.'.join(map(str, version))) # Verify if the version fetched is supported for i in range(0, 3): min = self.min_version[i] max = self.max_version[i] if version[i] < max: # If current digit is below the maximum value, no need to # check others digits, we are good break if version[i] not in list(range(min, max + 1)): raise Exception( ("azure CLI version %s not supported, must be between %s and" " %s") % ( '.'.join(map(str, version)), '.'.join(map(str, self.min_version)), '.'.join(map(str, self.max_version)), ) ) def bin(self, binary): """ Return binary's path """ if self.bin_path is not None: return os.path.join(self.bin_path, binary) else: return binary def check_instance_type_availability(self, instance_type, region): try: output = exec_shell([ self.bin("az"), "vm", "list-sizes", "--location %s" % region, "--query \"[?name == '%s']\"" % instance_type, "--output json" ]) result = json.loads(output.decode("utf-8")) logging.debug("Command output: %s", result) if len(result) == 0: raise CloudCliError( "Instance type %s not available in region %s" % (instance_type, region) ) except ValueError: # JSON decoding error logging.error("Failed to decode JSON data") logging.error("Output: %s", output.decode("utf-8")) raise CloudCliError( "Failed to decode JSON data, please check the logs for details" ) except CalledProcessError as e: logging.error("Failed to execute the command: %s", e.cmd) logging.error("Return code is: %s", e.returncode) logging.error("Output: %s", e.output) raise CloudCliError( "Failed to execute the following command, please check the " "logs for details: %s" % e.cmd ) def check_image_availability(self, publisher, offer, sku, region): try: output = exec_shell([ self.bin("az"), "vm", "image", "list", "--all", "-p \"%s\"" % publisher, "-f \"%s\"" % offer, "-s \"%s\"" % sku, "-l %s" % region, "--query", "\"[?offer == '%s' && sku =='%s']\"" % (offer, sku), "--output json" ]) result = json.loads(output.decode("utf-8")) logging.debug("Command output: %s", result) if len(result) == 0: raise CloudCliError( "Image %s:%s:%s not available in region %s" % (publisher, offer, sku, region) ) except ValueError: # JSON decoding error logging.error("Failed to decode JSON data") logging.error("Output: %s", output.decode("utf-8")) raise CloudCliError( "Failed to decode JSON data, please check the logs for details" ) except CalledProcessError as e: logging.error("Failed to execute the command: %s", e.cmd) logging.error("Return code is: %s", e.returncode) logging.error("Output: %s", e.output) raise CloudCliError( "Failed to execute the following command, please check the " "logs for details: %s" % e.cmd ) def check_instances_availability(self, project_name): try: output = exec_shell([ self.bin("az"), "vm", "wait", "--ids", "$(%s vm list -g \"%s_edb_resource_group\" --query \"[].id\" -o tsv)" % (self.bin("az"), project_name), "--created" ]) logging.debug("Command output: %s", output.decode("utf-8")) except CalledProcessError as e: logging.error("Failed to execute the command: %s", e.cmd) logging.error("Return code is: %s", e.returncode) logging.error("Output: %s", e.output) raise CloudCliError( "Failed to execute the following command, please check the " "logs for details: %s" % e.cmd ) class GCloudCli: def __init__(self, bin_path=None): # gcloud CLI supported versions interval self.min_version = (0,
<reponame>dhill2522/HERON # Copyright 2020, Battelle Energy Alliance, LLC # ALL RIGHTS RESERVED """ pyomo-based dispatch strategy """ import os import sys import time as time_mod from functools import partial import platform import numpy as np import pyomo.environ as pyo from pyomo.opt import SolverStatus, TerminationCondition # allows pyomo to solve on threaded processes import pyutilib.subprocess.GlobalData pyutilib.subprocess.GlobalData.DEFINE_SIGNAL_HANDLERS_DEFAULT = False from .Dispatcher import Dispatcher from .DispatchState import DispatchState, NumpyState try: import _utils as hutils except (ModuleNotFoundError, ImportError): sys.path.append(os.path.join(os.path.dirname(__file__), '..')) import _utils as hutils # Choose solver; CBC is a great choice unless we're on Windows if platform.system() == 'Windows': SOLVER = 'glpk' else: SOLVER = 'cbc' class Pyomo(Dispatcher): """ Dispatches using rolling windows in Pyomo """ naming_template = {'comp prod': '{comp}|{res}|prod', 'comp transfer': '{comp}|{res}|trans', 'comp max': '{comp}|{res}|max', 'comp ramp up': '{comp}|{res}|rampup', 'comp ramp down': '{comp}|{res}|rampdown', 'conservation': '{res}|consv', } ### INITIALIZATION @classmethod def get_input_specs(cls): """ Set acceptable input specifications. @ In, None @ Out, specs, InputData, specs """ specs = InputData.parameterInputFactory('Dispatcher', ordered=False, baseNode=None) # TODO specific for pyomo dispatcher return specs def __init__(self): """ Constructor. @ In, None @ Out, None """ self.name = 'PyomoDispatcher' # identifying name self._window_len = 24 # time window length to dispatch at a time # FIXME user input def read_input(self, specs): """ Read in input specifications. @ In, specs, RAVEN InputData, specifications @ Out, None """ print('DEBUGG specs:', specs) ### API def dispatch(self, case, components, sources, meta): """ Performs dispatch. @ In, case, HERON Case, Case that this dispatch is part of @ In, components, list, HERON components available to the dispatch @ In, sources, list, HERON source (placeholders) for signals @ In, meta, dict, additional variables passed through @ Out, disp, DispatchScenario, resulting dispatch """ t_start, t_end, t_num = self.get_time_discr() time = np.linspace(t_start, t_end, t_num) # Note we don't care about segment/cluster here resources = sorted(list(hutils.get_all_resources(components))) # list of all active resources # pre-build results structure ## we can use NumpyState here so we don't need to worry about a Pyomo model object dispatch = NumpyState()# dict((comp.name, dict((res, np.zeros(len(time))) for res in comp.get_resources())) for comp in components) dispatch.initialize(components, meta['HERON']['resource_indexer'], time) # rolling window start_index = 0 final_index = len(time) # TODO window overlap! ( )[ ] -> ( [ ) ] while start_index < final_index: end_index = start_index + self._window_len if end_index > final_index: end_index = final_index # + 1? specific_time = time[start_index:end_index] print('DEBUGG starting window {} to {}'.format(start_index, end_index)) start = time_mod.time() subdisp = self.dispatch_window(specific_time, case, components, sources, resources, meta) end = time_mod.time() print('DEBUGG solve time: {} s'.format(end-start)) # store result in corresponding part of dispatch for comp in components: for res, values in subdisp[comp.name].items(): dispatch.set_activity_vector(comp, res, start_index, end_index, values) start_index = end_index return dispatch ### INTERNAL def dispatch_window(self, time, case, components, sources, resources, meta): """ Dispatches one part of a rolling window. @ In, time, np.array, value of time to evaluate @ In, case, HERON Case, Case that this dispatch is part of @ In, components, list, HERON components available to the dispatch @ In, sources, list, HERON source (placeholders) for signals @ In, resources, list, sorted list of all resources in problem @ In, meta, dict, additional variables passed through @ Out, result, dict, results of window dispatch """ # build the Pyomo model # TODO abstract this model as much as possible BEFORE, then concrete initialization per window m = pyo.ConcreteModel() # indices C = np.arange(0, len(components), dtype=int) # indexes component R = np.arange(0, len(resources), dtype=int) # indexes resources # T = np.arange(start_index, end_index, dtype=int) # indexes resources T = np.arange(0, len(time), dtype=int) # indexes resources m.C = pyo.Set(initialize=C) m.R = pyo.Set(initialize=R) m.T = pyo.Set(initialize=T) m.Times = time m.resource_index_map = meta['HERON']['resource_indexer'] # maps the resource to its index WITHIN APPLICABLE components (sparse matrix) # e.g. component: {resource: local index}, ... etc} # properties m.Case = case m.Components = components m.Activity = PyomoState() m.Activity.initialize(m.Components, m.resource_index_map, m.Times, m) # constraints and variables for comp in components: # NOTE: "fixed" components could hypothetically be treated differently ## however, in order for the "production" variable for components to be treatable as the ## same as other production variables, we create components with limitation ## lowerbound == upperbound == capacity (just for "fixed" dispatch components) prod_name = self._create_production(m, comp) # variables self._create_capacity(m, comp, prod_name) # capacity constraints self._create_transfer(m, comp, prod_name) # transfer functions (constraints) # ramp rates TODO ## INCLUDING previous-time boundary condition TODO self._create_conservation(m, resources) # conservation of resources (e.g. production == consumption) self._create_objective(meta, m) # objective # start a solution search done_and_checked = False attempts = 0 while not done_and_checked: attempts += 1 print(f'DEBUGG solve attempt {attempts} ...:') # solve soln = pyo.SolverFactory(SOLVER).solve(m) # check solve status if soln.solver.status == SolverStatus.ok and soln.solver.termination_condition == TerminationCondition.optimal: print('DEBUGG ... solve was successful!') else: print('DEBUGG ... solve was unsuccessful!') print('DEBUGG ... status:', soln.solver.status) print('DEBUGG ... termination:', soln.solver.termination_condition) raise RuntimeError # try validating print('DEBUGG ... validating ...') validation_errs = self.validate(m.Components, m.Activity, m.Times) if validation_errs: done_and_checked = False print('DEBUGG ... validation concerns raised:') for e in validation_errs: print('DEBUGG ... ... Time {t} ({time}) Component "{c}" Resource "{r}": {m}' .format(t=e['time_index'], time=e['time'], c=e['component'].name, r=e['resource'], m=e['msg'])) self._create_production_limit(m, e) # go back and solve again # raise NotImplementedError('Validation failed, but idk how to handle that yet') else: print('DEBUGG Solve successful and no validation concerns raised.') done_and_checked = True if attempts > 100: raise RuntimeError('Exceeded validation attempt limit!') #soln.write() # DEBUGG self._debug_print_soln(m) # DEBUGG # return dict of numpy arrays result = self._retrieve_solution(m) return result ### PYOMO Element Constructors def _create_production_limit(self, m, validation): """ Creates pyomo production constraint given validation errors @ In, m, pyo.ConcreteModel, associated model @ In, validation, dict, information from Validator about limit violation @ Out, None """ # TODO could validator write a symbolic expression on request? That'd be sweet. comp = validation['component'] resource = validation['resource'] r = m.resource_index_map[comp][resource] t = validation['time_index'] limit = validation['limit'] limit_type = validation['limit_type'] prod_name = f'{comp.name}_production' rule = partial(self._prod_limit_rule, prod_name, r, limit, limit_type, t) constr = pyo.Constraint(rule=rule) counter = 1 name_template = '{c}_{r}_{t}_vld_limit_constr_{{i}}'.format(c=comp.name, r=resource, t=t) # make sure we get a unique name for this constraint name = name_template.format(i=counter) while getattr(m, name, None) is not None: counter += 1 name = name_template.format(i=counter) setattr(m, name, constr) print(f'DEBUGG added validation constraint "{name}"') def _create_production(self, m, comp): """ Creates production pyomo variable object for a component @ In, m, pyo.ConcreteModel, associated model @ In, comp, HERON Component, component to make production variables for @ Out, prod_name, str, name of production variable """ name = comp.name # create pyomo indexer for this component's resources res_indexer = pyo.Set(initialize=range(len(m.resource_index_map[comp]))) setattr(m, f'{name}_res_index_map', res_indexer) # production variable depends on resource, time # # TODO if transfer function is linear, isn't this technically redundant? Maybe only need one resource ... ## Method 1: set variable bounds directly --> not working! why?? #lower, upper, domain = self._get_prod_bounds(comp) #prod = pyo.Var(res_indexer, m.T, bounds=(lower, upper)) #within=domain, ## Method 2: set capacity as a seperate constraint prod = pyo.Var(res_indexer, m.T, initialize=0) prod_name = '{c}_production'.format(c=name) setattr(m, prod_name, prod) return prod_name def _create_capacity(self, m, comp, prod_name): """ Creates pyomo capacity constraints @ In, m, pyo.ConcreteModel, associated model @ In, comp, HERON Component, component to make variables for @ In, prod_name, str, name of production variable @ Out, None """ name = comp.name cap_res = comp.get_capacity_var() # name of resource that defines capacity r = m.resource_index_map[comp][cap_res] # production index of the governing resource # production is always lower than capacity ## NOTE get_capacity returns (data, meta) and data is dict ## TODO does this work with, e.g., ARMA-based capacities? ### -> "time" is stored on "m" and could be used to correctly evaluate the capacity cap = comp.get_capacity(None, None, None, None)[0][cap_res] # value of capacity limit (units of governing resource) rule = partial(self._capacity_rule, prod_name, r, cap) constr = pyo.Constraint(m.T, rule=rule) setattr(m, '{c}_{r}_capacity_constr'.format(c=name, r=cap_res), constr) # minimum production print('DEBUGG dispatchable?', comp.name, comp.is_dispatchable()) if comp.is_dispatchable() == 'fixed': minimum = cap var = getattr(m, prod_name) values = var.get_values() for k in values: values[k] = cap var.set_values(values) else: minimum =
<gh_stars>1-10 # coding=utf-8 """ Module responsible for the definition of functions that convert Raw units (available in the acquisition files returned by OpenSignals) and sample units to physical units like mV, A, ºC, s,..., accordingly to the sensor under analysis. Available Functions ------------------- [Public] raw_to_phy Function that converts each sample value in raw units to a physical unit taking into account the respective transfer function for the sensor and device specified as an input. generate_time Considering the acquisition sampling rate and the number of samples that compose the signal, this function will return a time axis in seconds. Observations/Comments --------------------- None /\ """ import numpy from .aux_functions import _is_a_url, _generate_download_google_link from .load import load def raw_to_phy(sensor, device, raw_signal, resolution, option): """ ----- Brief ----- Function for converting raw units to physical units. ----------- Description ----------- Each sensor and device has a specific transfer function that models the inputs to outputs. This transfer function is, thus, used in order to convert the raw units that are measured to physical units that originated the data. This functions makes the conversion of raw units to physical units, using the information of sensor and device. ---------- Parameters ---------- sensor : str Sensor label: - "ECG" - "EMG" - "TEMP" - "BVP" - "SpO2.HEAD" - "SpO2.FING" - "SpO2.ARM" - "EEG" - "EDA" device : str PLUX device label: - "bioplux" - "bioplux_exp" - "biosignalsplux" - "rachimeter" - "channeller" - "swifter" - "ddme_openbanplux" raw_signal : list Raw signal samples. resolution : int Resolution selected during acquisition. option : str (optional) Output units (only available in certain sensors): - "mV" - "V" - "C" (Celsius) - "K" (Kelvin) - "Ohm" - "A" - "uA" (When is not applicable a warning message is raised). Returns ------- out : list Signal in the new scale. """ raw_signal = numpy.array(raw_signal) # Check if resolution has the correct data format. if not isinstance(resolution, int) and not isinstance(resolution, numpy.int32): raise RuntimeError("The specified resolution needs to be an integer.") out = None if sensor == "TEMP": vcc = 3.0 available_dev_1 = ["bioplux", "bioplux_exp", "biosignalsplux", "rachimeter", "channeller", "swifter", "ddme_openbanplux"] available_dev_2 = ["bitalino", "bitalino_rev", "bitalino_riot"] if option == "Ohm": if device in available_dev_1: out = (1e4 * raw_signal) / (2**resolution - raw_signal) else: raise RuntimeError("The output specified unit does not have a defined transfer " "function for the used device.") elif option == "K": a_0 = 1.12764514e-3 a_1 = 2.34282709e-4 a_2 = 8.77303013e-8 out = 1 / (a_0 + a_1 * numpy.log(raw_to_phy(sensor, device, list(raw_signal), resolution, option="Ohm")) + a_2 * ((numpy.log(raw_to_phy(sensor, device, list(raw_signal), resolution, option="Ohm"))) ** 3)) elif option == "C": if device in available_dev_1: out = numpy.array(raw_to_phy(sensor, device, list(raw_signal), resolution, option="K")) - 273.15 elif device in available_dev_2: out = ((raw_signal / (2 ** resolution)) * vcc - 0.5) * 100 else: raise RuntimeError("The output specified unit does not have a defined transfer " "function for the used device.") else: raise RuntimeError("The selected output unit is invalid for the sensor under analysis.") elif sensor == "EMG": available_dev_1 = ["bioplux", "bioplux_exp", "biosignalsplux", "rachimeter", "channeller", "swifter", "ddme_openbanplux"] available_dev_2 = ["bitalino"] available_dev_3 = ["bitalino_rev", "bitalino_riot"] if option == "mV": if device in available_dev_1: vcc = 3.0 offset = 0.5 gain = 1 elif device in available_dev_2: vcc = 3.3 offset = 0.5 gain = 1.008 elif device in available_dev_3: vcc = 3.3 offset = 0.5 gain = 1.009 else: raise RuntimeError("The output specified unit does not have a defined transfer " "function for the used device.") out = (raw_signal * vcc / (2 ** resolution) - vcc * offset) / gain elif option == "V": out = numpy.array(raw_to_phy(sensor, device, list(raw_signal), resolution, option="mV")) / 1000 else: raise RuntimeError("The selected output unit is invalid for the sensor under analysis.") elif sensor == "ECG": available_dev_1 = ["bioplux", "bioplux_exp", "biosignalsplux", "rachimeter", "channeller", "swifter", "ddme_openbanplux"] available_dev_2 = ["bitalino", "bitalino_rev", "bitalino_riot"] if option == "mV": if device in available_dev_1: vcc = 3.0 offset = 0.5 gain = 1.019 elif device in available_dev_2: vcc = 3.3 offset = 0.5 gain = 1.1 else: raise RuntimeError("The output specified unit does not have a defined transfer " "function for the used device.") out = (raw_signal * vcc / (2 ** resolution) - vcc * offset) / gain elif option == "V": out = numpy.array(raw_to_phy(sensor, device, list(raw_signal), resolution, option="mV")) / 1000 else: raise RuntimeError("The selected output unit is invalid for the sensor under analysis.") elif sensor == "BVP": available_dev_1 = ["bioplux", "bioplux_exp", "biosignalsplux", "rachimeter", "channeller", "swifter", "ddme_openbanplux"] if option == "uA": vcc = 3.0 if device in available_dev_1: offset = 0 gain = 0.190060606 else: raise RuntimeError("The output specified unit does not have a defined transfer " "function for the used device.") out = (raw_signal * vcc / (2 ** resolution) - vcc * offset) / gain elif option == "A": out = numpy.array(raw_to_phy(sensor, device, list(raw_signal), resolution, option="uA")) * 1e-6 else: raise RuntimeError("The selected output unit is invalid for the sensor under analysis.") elif sensor in ["SpO2.ARM", "SpO2.HEAD", "SpO2.FING"]: available_dev_1 = ["channeller", "biosignalsplux", "swifter"] scale_factor = None if "ARM" in sensor or "FING" in sensor: scale_factor = 1.2 elif "HEAD" in sensor: scale_factor = 0.15 if option == "uA": if device in available_dev_1: out = scale_factor * (raw_signal / (2 ** resolution)) else: raise RuntimeError("The output specified unit does not have a defined transfer " "function for the used device.") elif option == "A": out = numpy.array(raw_to_phy(sensor, device, list(raw_signal), resolution, option="uA")) * 1e-6 else: raise RuntimeError("The selected output unit is invalid for the sensor under analysis.") elif sensor == "ACC": available_dev_1 = ["bioplux", "bioplux_exp", "biosignalsplux", "rachimeter", "channeller", "swifter", "ddme_openbanplux"] if option == "g": if device in available_dev_1: Cm = 28000.0 CM = 38000.0 else: raise RuntimeError("The output specified unit does not have a defined transfer " "function for the used device.") out = 2.0*((2**(16.0 - resolution) * raw_signal - Cm) / (CM - Cm)) - 1.0 else: raise RuntimeError("The selected output unit is invalid for the sensor under analysis.") elif sensor == "EEG": available_dev_1 = ["bioplux", "bioplux_exp", "biosignalsplux", "rachimeter", "channeller", "swifter", "ddme_openbanplux"] available_dev_2 = ["bitalino_rev", "bitalino_riot"] if option == "uV": if device in available_dev_1: vcc = 3.0 offset = 0.5 gain = 0.041990 elif device in available_dev_2: vcc = 3.3 offset = 0.5 gain = 0.040000 else: raise RuntimeError("The output specified unit does not have a defined transfer " "function for the used device.") out = ((raw_signal * vcc / (2 ** resolution)) - vcc * offset) / gain elif option == "V": out = numpy.array(raw_to_phy(sensor, device, list(raw_signal), resolution, option="uV")) * 1e6 else: raise RuntimeError("The selected output unit is invalid for the sensor under analysis.") elif sensor == "EDA": available_dev_1 = ["bioplux", "bioplux_exp", "biosignalsplux", "rachimeter", "channeller", "swifter", "biosignalspluxsolo"] available_dev_2 = ["bitalino"] available_dev_3 = ["bitalino_rev", "bitalino_riot"] if option == "uS": if device in available_dev_1: vcc = 3.0 offset = 0 gain = 0.12 elif device in available_dev_2: return 1.0 / (1.0 - (raw_signal / (2 ** resolution))) elif device in available_dev_3: vcc = 3.3 offset = 0 gain = 0.132 else: raise RuntimeError("The output specified unit does not have a defined transfer " "function for the used device.") out = ((raw_signal * vcc / (2 ** resolution)) - vcc * offset) / gain elif option == "S": out = numpy.array(raw_to_phy(sensor, device, list(raw_signal), resolution, option="uS")) * 1e6 else: raise RuntimeError("The selected output unit is invalid for the sensor under analysis.") else: raise RuntimeError("The specified sensor is not valid or for now is not available for unit " "conversion.") return out def generate_time(signal, sample_rate=1000): """ ----- Brief ----- Function intended to generate a time axis of the input signal. ----------- Description ----------- The time axis generated by the acquisition process originates a set of consecutive values that represents the advancement of time, but does not have specific units. Once the acquisitions are made with specific sampling frequencies, it is possible to calculate the time instant of each sample by multiplying that value by the sampling frequency. The current function maps the values