body
stringlengths 26
98.2k
| body_hash
int64 -9,222,864,604,528,158,000
9,221,803,474B
| docstring
stringlengths 1
16.8k
| path
stringlengths 5
230
| name
stringlengths 1
96
| repository_name
stringlengths 7
89
| lang
stringclasses 1
value | body_without_docstring
stringlengths 20
98.2k
|
|---|---|---|---|---|---|---|---|
async def test_set_direction(hass):
'Test setting the direction of the device.'
assert (STATE_OFF == get_entity(hass).state)
(await common.async_set_direction(hass, FAN_ENTITY_ID, fan.DIRECTION_REVERSE))
assert (fan.DIRECTION_REVERSE == get_entity(hass).attributes.get('direction')) | 3,764,680,505,445,146,600 | Test setting the direction of the device. | tests/components/demo/test_fan.py | test_set_direction | ActuallyRuben/home-assistant | python | async def test_set_direction(hass):
assert (STATE_OFF == get_entity(hass).state)
(await common.async_set_direction(hass, FAN_ENTITY_ID, fan.DIRECTION_REVERSE))
assert (fan.DIRECTION_REVERSE == get_entity(hass).attributes.get('direction')) |
async def test_set_speed(hass):
'Test setting the speed of the device.'
assert (STATE_OFF == get_entity(hass).state)
(await common.async_set_speed(hass, FAN_ENTITY_ID, fan.SPEED_LOW))
assert (fan.SPEED_LOW == get_entity(hass).attributes.get('speed')) | -2,009,984,134,437,762,600 | Test setting the speed of the device. | tests/components/demo/test_fan.py | test_set_speed | ActuallyRuben/home-assistant | python | async def test_set_speed(hass):
assert (STATE_OFF == get_entity(hass).state)
(await common.async_set_speed(hass, FAN_ENTITY_ID, fan.SPEED_LOW))
assert (fan.SPEED_LOW == get_entity(hass).attributes.get('speed')) |
async def test_oscillate(hass):
'Test oscillating the fan.'
assert (not get_entity(hass).attributes.get('oscillating'))
(await common.async_oscillate(hass, FAN_ENTITY_ID, True))
assert get_entity(hass).attributes.get('oscillating')
(await common.async_oscillate(hass, FAN_ENTITY_ID, False))
assert (not get_entity(hass).attributes.get('oscillating')) | -8,049,271,439,002,481,000 | Test oscillating the fan. | tests/components/demo/test_fan.py | test_oscillate | ActuallyRuben/home-assistant | python | async def test_oscillate(hass):
assert (not get_entity(hass).attributes.get('oscillating'))
(await common.async_oscillate(hass, FAN_ENTITY_ID, True))
assert get_entity(hass).attributes.get('oscillating')
(await common.async_oscillate(hass, FAN_ENTITY_ID, False))
assert (not get_entity(hass).attributes.get('oscillating')) |
async def test_is_on(hass):
'Test is on service call.'
assert (not fan.is_on(hass, FAN_ENTITY_ID))
(await common.async_turn_on(hass, FAN_ENTITY_ID))
assert fan.is_on(hass, FAN_ENTITY_ID) | 3,499,190,597,735,891,500 | Test is on service call. | tests/components/demo/test_fan.py | test_is_on | ActuallyRuben/home-assistant | python | async def test_is_on(hass):
assert (not fan.is_on(hass, FAN_ENTITY_ID))
(await common.async_turn_on(hass, FAN_ENTITY_ID))
assert fan.is_on(hass, FAN_ENTITY_ID) |
def load_vgg(sess, vgg_path):
'\n Load Pretrained VGG Model into TensorFlow.\n :param sess: TensorFlow Session\n :param vgg_path: Path to vgg folder, containing "variables/" and "saved_model.pb"\n :return: Tuple of Tensors from VGG model (image_input, keep_prob, layer3_out, layer4_out, layer7_out)\n '
vgg_tag = 'vgg16'
tf.saved_model.loader.load(sess, [vgg_tag], vgg_path)
vgg_input_tensor_name = 'image_input:0'
vgg_keep_prob_tensor_name = 'keep_prob:0'
vgg_layer3_out_tensor_name = 'layer3_out:0'
vgg_layer4_out_tensor_name = 'layer4_out:0'
vgg_layer7_out_tensor_name = 'layer7_out:0'
graph = tf.get_default_graph()
input_img = graph.get_tensor_by_name(vgg_input_tensor_name)
prob = graph.get_tensor_by_name(vgg_keep_prob_tensor_name)
layer3_o = graph.get_tensor_by_name(vgg_layer3_out_tensor_name)
layer4_o = graph.get_tensor_by_name(vgg_layer4_out_tensor_name)
layer7_o = graph.get_tensor_by_name(vgg_layer7_out_tensor_name)
return (input_img, prob, layer3_o, layer4_o, layer7_o) | 2,088,851,759,729,730,000 | Load Pretrained VGG Model into TensorFlow.
:param sess: TensorFlow Session
:param vgg_path: Path to vgg folder, containing "variables/" and "saved_model.pb"
:return: Tuple of Tensors from VGG model (image_input, keep_prob, layer3_out, layer4_out, layer7_out) | main.py | load_vgg | papaispicolo/CarNDT3-SemanticSegmentation | python | def load_vgg(sess, vgg_path):
'\n Load Pretrained VGG Model into TensorFlow.\n :param sess: TensorFlow Session\n :param vgg_path: Path to vgg folder, containing "variables/" and "saved_model.pb"\n :return: Tuple of Tensors from VGG model (image_input, keep_prob, layer3_out, layer4_out, layer7_out)\n '
vgg_tag = 'vgg16'
tf.saved_model.loader.load(sess, [vgg_tag], vgg_path)
vgg_input_tensor_name = 'image_input:0'
vgg_keep_prob_tensor_name = 'keep_prob:0'
vgg_layer3_out_tensor_name = 'layer3_out:0'
vgg_layer4_out_tensor_name = 'layer4_out:0'
vgg_layer7_out_tensor_name = 'layer7_out:0'
graph = tf.get_default_graph()
input_img = graph.get_tensor_by_name(vgg_input_tensor_name)
prob = graph.get_tensor_by_name(vgg_keep_prob_tensor_name)
layer3_o = graph.get_tensor_by_name(vgg_layer3_out_tensor_name)
layer4_o = graph.get_tensor_by_name(vgg_layer4_out_tensor_name)
layer7_o = graph.get_tensor_by_name(vgg_layer7_out_tensor_name)
return (input_img, prob, layer3_o, layer4_o, layer7_o) |
def layers(vgg_layer3_out, vgg_layer4_out, vgg_layer7_out, num_classes):
'\n Create the layers for a fully convolutional network. Build skip-layers using the vgg layers.\n :param vgg_layer3_out: TF Tensor for VGG Layer 3 output\n :param vgg_layer4_out: TF Tensor for VGG Layer 4 output\n :param vgg_layer7_out: TF Tensor for VGG Layer 7 output\n :param num_classes: Number of classes to classify\n :return: The Tensor for the last layer of output\n '
conv_1by1_l7 = tf.layers.conv2d(vgg_layer7_out, num_classes, 1, padding='SAME', kernel_regularizer=tf.contrib.layers.l2_regularizer(0.001))
output = tf.layers.conv2d_transpose(conv_1by1_l7, 512, 4, strides=(2, 2), padding='SAME', kernel_regularizer=tf.contrib.layers.l2_regularizer(0.001))
output = tf.add(output, vgg_layer4_out)
output = tf.layers.conv2d_transpose(output, 256, 4, strides=(2, 2), padding='SAME', kernel_regularizer=tf.contrib.layers.l2_regularizer(0.001))
output = tf.add(output, vgg_layer3_out)
output = tf.layers.conv2d_transpose(output, num_classes, 16, strides=(8, 8), padding='SAME', kernel_regularizer=tf.contrib.layers.l2_regularizer(0.001), name='nn_final_output')
return output | -8,248,518,825,660,680,000 | Create the layers for a fully convolutional network. Build skip-layers using the vgg layers.
:param vgg_layer3_out: TF Tensor for VGG Layer 3 output
:param vgg_layer4_out: TF Tensor for VGG Layer 4 output
:param vgg_layer7_out: TF Tensor for VGG Layer 7 output
:param num_classes: Number of classes to classify
:return: The Tensor for the last layer of output | main.py | layers | papaispicolo/CarNDT3-SemanticSegmentation | python | def layers(vgg_layer3_out, vgg_layer4_out, vgg_layer7_out, num_classes):
'\n Create the layers for a fully convolutional network. Build skip-layers using the vgg layers.\n :param vgg_layer3_out: TF Tensor for VGG Layer 3 output\n :param vgg_layer4_out: TF Tensor for VGG Layer 4 output\n :param vgg_layer7_out: TF Tensor for VGG Layer 7 output\n :param num_classes: Number of classes to classify\n :return: The Tensor for the last layer of output\n '
conv_1by1_l7 = tf.layers.conv2d(vgg_layer7_out, num_classes, 1, padding='SAME', kernel_regularizer=tf.contrib.layers.l2_regularizer(0.001))
output = tf.layers.conv2d_transpose(conv_1by1_l7, 512, 4, strides=(2, 2), padding='SAME', kernel_regularizer=tf.contrib.layers.l2_regularizer(0.001))
output = tf.add(output, vgg_layer4_out)
output = tf.layers.conv2d_transpose(output, 256, 4, strides=(2, 2), padding='SAME', kernel_regularizer=tf.contrib.layers.l2_regularizer(0.001))
output = tf.add(output, vgg_layer3_out)
output = tf.layers.conv2d_transpose(output, num_classes, 16, strides=(8, 8), padding='SAME', kernel_regularizer=tf.contrib.layers.l2_regularizer(0.001), name='nn_final_output')
return output |
def optimize(nn_last_layer, correct_label, learning_rate, num_classes):
'\n Build the TensorFLow loss and optimizer operations.\n :param nn_last_layer: TF Tensor of the last layer in the neural network\n :param correct_label: TF Placeholder for the correct label image\n :param learning_rate: TF Placeholder for the learning rate\n :param num_classes: Number of classes to classify\n :return: Tuple of (logits, train_op, cross_entropy_loss)\n '
logits = tf.reshape(nn_last_layer, ((- 1), num_classes))
cross_entropy_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=correct_label))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
training_operation = optimizer.minimize(cross_entropy_loss)
return (logits, training_operation, cross_entropy_loss) | 8,150,404,043,134,320,000 | Build the TensorFLow loss and optimizer operations.
:param nn_last_layer: TF Tensor of the last layer in the neural network
:param correct_label: TF Placeholder for the correct label image
:param learning_rate: TF Placeholder for the learning rate
:param num_classes: Number of classes to classify
:return: Tuple of (logits, train_op, cross_entropy_loss) | main.py | optimize | papaispicolo/CarNDT3-SemanticSegmentation | python | def optimize(nn_last_layer, correct_label, learning_rate, num_classes):
'\n Build the TensorFLow loss and optimizer operations.\n :param nn_last_layer: TF Tensor of the last layer in the neural network\n :param correct_label: TF Placeholder for the correct label image\n :param learning_rate: TF Placeholder for the learning rate\n :param num_classes: Number of classes to classify\n :return: Tuple of (logits, train_op, cross_entropy_loss)\n '
logits = tf.reshape(nn_last_layer, ((- 1), num_classes))
cross_entropy_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=correct_label))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
training_operation = optimizer.minimize(cross_entropy_loss)
return (logits, training_operation, cross_entropy_loss) |
def train_nn(sess, epochs, batch_size, get_batches_fn, train_op, cross_entropy_loss, input_image, correct_label, keep_prob, learning_rate):
'\n Train neural network and print out the loss during training.\n :param sess: TF Session\n :param epochs: Number of epochs\n :param batch_size: Batch size\n :param get_batches_fn: Function to get batches of training data. Call using get_batches_fn(batch_size)\n :param train_op: TF Operation to train the neural network\n :param cross_entropy_loss: TF Tensor for the amount of loss\n :param input_image: TF Placeholder for input images\n :param correct_label: TF Placeholder for label images\n :param keep_prob: TF Placeholder for dropout keep probability\n :param learning_rate: TF Placeholder for learning rate\n '
sess.run(tf.global_variables_initializer())
for epoch in range(epochs):
for (input_img, gt_img) in get_batches_fn(batch_size):
(_, loss) = sess.run([train_op, cross_entropy_loss], feed_dict={input_image: input_img, correct_label: gt_img, keep_prob: 0.7, learning_rate: 0.0005})
print('Loss of {} at epoch {}/{}'.format(loss, epoch, epochs)) | 54,481,322,062,496,040 | Train neural network and print out the loss during training.
:param sess: TF Session
:param epochs: Number of epochs
:param batch_size: Batch size
:param get_batches_fn: Function to get batches of training data. Call using get_batches_fn(batch_size)
:param train_op: TF Operation to train the neural network
:param cross_entropy_loss: TF Tensor for the amount of loss
:param input_image: TF Placeholder for input images
:param correct_label: TF Placeholder for label images
:param keep_prob: TF Placeholder for dropout keep probability
:param learning_rate: TF Placeholder for learning rate | main.py | train_nn | papaispicolo/CarNDT3-SemanticSegmentation | python | def train_nn(sess, epochs, batch_size, get_batches_fn, train_op, cross_entropy_loss, input_image, correct_label, keep_prob, learning_rate):
'\n Train neural network and print out the loss during training.\n :param sess: TF Session\n :param epochs: Number of epochs\n :param batch_size: Batch size\n :param get_batches_fn: Function to get batches of training data. Call using get_batches_fn(batch_size)\n :param train_op: TF Operation to train the neural network\n :param cross_entropy_loss: TF Tensor for the amount of loss\n :param input_image: TF Placeholder for input images\n :param correct_label: TF Placeholder for label images\n :param keep_prob: TF Placeholder for dropout keep probability\n :param learning_rate: TF Placeholder for learning rate\n '
sess.run(tf.global_variables_initializer())
for epoch in range(epochs):
for (input_img, gt_img) in get_batches_fn(batch_size):
(_, loss) = sess.run([train_op, cross_entropy_loss], feed_dict={input_image: input_img, correct_label: gt_img, keep_prob: 0.7, learning_rate: 0.0005})
print('Loss of {} at epoch {}/{}'.format(loss, epoch, epochs)) |
def load_data():
'Loads CIFAR10 dataset.\n\n Returns:\n Tuple of Numpy arrays: `(x_train, y_train), (x_test, y_test)`.\n '
dirname = 'cifar-10-batches-py'
origin = 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz'
path = get_file(dirname, origin=origin, untar=True)
num_train_samples = 50000
x_train = np.empty((num_train_samples, 3, 32, 32), dtype='uint8')
y_train = np.empty((num_train_samples,), dtype='uint8')
for i in range(1, 6):
fpath = os.path.join(path, ('data_batch_' + str(i)))
(x_train[((i - 1) * 10000):(i * 10000), :, :, :], y_train[((i - 1) * 10000):(i * 10000)]) = load_batch(fpath)
fpath = os.path.join(path, 'test_batch')
(x_test, y_test) = load_batch(fpath)
y_train = np.reshape(y_train, (len(y_train), 1))
y_test = np.reshape(y_test, (len(y_test), 1))
if (K.image_data_format() == 'channels_last'):
x_train = x_train.transpose(0, 2, 3, 1)
x_test = x_test.transpose(0, 2, 3, 1)
return ((x_train, y_train), (x_test, y_test)) | -7,465,674,360,239,780,000 | Loads CIFAR10 dataset.
Returns:
Tuple of Numpy arrays: `(x_train, y_train), (x_test, y_test)`. | tensorflow/python/keras/_impl/keras/datasets/cifar10.py | load_data | 252125889/tensorflow | python | def load_data():
'Loads CIFAR10 dataset.\n\n Returns:\n Tuple of Numpy arrays: `(x_train, y_train), (x_test, y_test)`.\n '
dirname = 'cifar-10-batches-py'
origin = 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz'
path = get_file(dirname, origin=origin, untar=True)
num_train_samples = 50000
x_train = np.empty((num_train_samples, 3, 32, 32), dtype='uint8')
y_train = np.empty((num_train_samples,), dtype='uint8')
for i in range(1, 6):
fpath = os.path.join(path, ('data_batch_' + str(i)))
(x_train[((i - 1) * 10000):(i * 10000), :, :, :], y_train[((i - 1) * 10000):(i * 10000)]) = load_batch(fpath)
fpath = os.path.join(path, 'test_batch')
(x_test, y_test) = load_batch(fpath)
y_train = np.reshape(y_train, (len(y_train), 1))
y_test = np.reshape(y_test, (len(y_test), 1))
if (K.image_data_format() == 'channels_last'):
x_train = x_train.transpose(0, 2, 3, 1)
x_test = x_test.transpose(0, 2, 3, 1)
return ((x_train, y_train), (x_test, y_test)) |
def set_meas_constants(self, trig_name, targ_name, trig_dir_str, targ_dir_str, trig_vdd, targ_vdd):
'Set the constants for this measurement: signal names, directions, and trigger scales'
self.trig_dir_str = trig_dir_str
self.targ_dir_str = targ_dir_str
self.trig_val_of_vdd = trig_vdd
self.targ_val_of_vdd = targ_vdd
self.trig_name_no_port = trig_name
self.targ_name_no_port = targ_name | -4,321,173,536,370,213,400 | Set the constants for this measurement: signal names, directions, and trigger scales | compiler/characterizer/measurements.py | set_meas_constants | ckdur/OpenRAM | python | def set_meas_constants(self, trig_name, targ_name, trig_dir_str, targ_dir_str, trig_vdd, targ_vdd):
self.trig_dir_str = trig_dir_str
self.targ_dir_str = targ_dir_str
self.trig_val_of_vdd = trig_vdd
self.targ_val_of_vdd = targ_vdd
self.trig_name_no_port = trig_name
self.targ_name_no_port = targ_name |
def get_measure_values(self, trig_td, targ_td, vdd_voltage, port=None):
'Constructs inputs to stimulus measurement function. Variant values are inputs here.'
self.port_error_check(port)
trig_val = (self.trig_val_of_vdd * vdd_voltage)
targ_val = (self.targ_val_of_vdd * vdd_voltage)
if (port != None):
meas_name = '{}{}'.format(self.name, port)
trig_name = self.trig_name_no_port.format(port)
targ_name = self.targ_name_no_port.format(port)
else:
meas_name = self.name
trig_name = self.trig_name_no_port
targ_name = self.targ_name_no_port
return (meas_name, trig_name, targ_name, trig_val, targ_val, self.trig_dir_str, self.targ_dir_str, trig_td, targ_td) | 8,585,018,006,580,844,000 | Constructs inputs to stimulus measurement function. Variant values are inputs here. | compiler/characterizer/measurements.py | get_measure_values | ckdur/OpenRAM | python | def get_measure_values(self, trig_td, targ_td, vdd_voltage, port=None):
self.port_error_check(port)
trig_val = (self.trig_val_of_vdd * vdd_voltage)
targ_val = (self.targ_val_of_vdd * vdd_voltage)
if (port != None):
meas_name = '{}{}'.format(self.name, port)
trig_name = self.trig_name_no_port.format(port)
targ_name = self.targ_name_no_port.format(port)
else:
meas_name = self.name
trig_name = self.trig_name_no_port
targ_name = self.targ_name_no_port
return (meas_name, trig_name, targ_name, trig_val, targ_val, self.trig_dir_str, self.targ_dir_str, trig_td, targ_td) |
def set_meas_constants(self, signal_name, slew_dir_str):
'Set the values needed to generate a Spice measurement statement based on the name of the measurement.'
self.trig_dir_str = slew_dir_str
self.targ_dir_str = slew_dir_str
if (slew_dir_str == 'RISE'):
self.trig_val_of_vdd = 0.1
self.targ_val_of_vdd = 0.9
elif (slew_dir_str == 'FALL'):
self.trig_val_of_vdd = 0.9
self.targ_val_of_vdd = 0.1
else:
debug.error('Unrecognised slew measurement direction={}'.format(slew_dir_str), 1)
self.trig_name_no_port = signal_name
self.targ_name_no_port = signal_name | 1,089,750,063,097,577,300 | Set the values needed to generate a Spice measurement statement based on the name of the measurement. | compiler/characterizer/measurements.py | set_meas_constants | ckdur/OpenRAM | python | def set_meas_constants(self, signal_name, slew_dir_str):
self.trig_dir_str = slew_dir_str
self.targ_dir_str = slew_dir_str
if (slew_dir_str == 'RISE'):
self.trig_val_of_vdd = 0.1
self.targ_val_of_vdd = 0.9
elif (slew_dir_str == 'FALL'):
self.trig_val_of_vdd = 0.9
self.targ_val_of_vdd = 0.1
else:
debug.error('Unrecognised slew measurement direction={}'.format(slew_dir_str), 1)
self.trig_name_no_port = signal_name
self.targ_name_no_port = signal_name |
def set_meas_constants(self, power_type):
'Sets values useful for power simulations. This value is only meta related to the lib file (rise/fall)'
self.power_type = power_type | -4,338,757,808,079,665,000 | Sets values useful for power simulations. This value is only meta related to the lib file (rise/fall) | compiler/characterizer/measurements.py | set_meas_constants | ckdur/OpenRAM | python | def set_meas_constants(self, power_type):
self.power_type = power_type |
def get_measure_values(self, t_initial, t_final, port=None):
'Constructs inputs to stimulus measurement function. Variant values are inputs here.'
self.port_error_check(port)
if (port != None):
meas_name = '{}{}'.format(self.name, port)
else:
meas_name = self.name
return (meas_name, t_initial, t_final) | -9,196,840,615,746,831,000 | Constructs inputs to stimulus measurement function. Variant values are inputs here. | compiler/characterizer/measurements.py | get_measure_values | ckdur/OpenRAM | python | def get_measure_values(self, t_initial, t_final, port=None):
self.port_error_check(port)
if (port != None):
meas_name = '{}{}'.format(self.name, port)
else:
meas_name = self.name
return (meas_name, t_initial, t_final) |
def set_meas_constants(self, trig_name, targ_name, trig_dir_str, trig_vdd):
'Sets values useful for power simulations. This value is only meta related to the lib file (rise/fall)'
self.trig_dir_str = trig_dir_str
self.trig_val_of_vdd = trig_vdd
self.trig_name_no_port = trig_name
self.targ_name_no_port = targ_name | 3,653,245,460,261,028,400 | Sets values useful for power simulations. This value is only meta related to the lib file (rise/fall) | compiler/characterizer/measurements.py | set_meas_constants | ckdur/OpenRAM | python | def set_meas_constants(self, trig_name, targ_name, trig_dir_str, trig_vdd):
self.trig_dir_str = trig_dir_str
self.trig_val_of_vdd = trig_vdd
self.trig_name_no_port = trig_name
self.targ_name_no_port = targ_name |
def get_measure_values(self, trig_td, vdd_voltage, port=None):
'Constructs inputs to stimulus measurement function. Variant values are inputs here.'
self.port_error_check(port)
if (port != None):
meas_name = '{}{}'.format(self.name, port)
trig_name = self.trig_name_no_port.format(port)
targ_name = self.targ_name_no_port.format(port)
else:
meas_name = self.name
trig_name = self.trig_name_no_port
targ_name = self.targ_name_no_port
trig_voltage = (self.trig_val_of_vdd * vdd_voltage)
return (meas_name, trig_name, targ_name, trig_voltage, self.trig_dir_str, trig_td) | -1,249,913,863,619,797,000 | Constructs inputs to stimulus measurement function. Variant values are inputs here. | compiler/characterizer/measurements.py | get_measure_values | ckdur/OpenRAM | python | def get_measure_values(self, trig_td, vdd_voltage, port=None):
self.port_error_check(port)
if (port != None):
meas_name = '{}{}'.format(self.name, port)
trig_name = self.trig_name_no_port.format(port)
targ_name = self.targ_name_no_port.format(port)
else:
meas_name = self.name
trig_name = self.trig_name_no_port
targ_name = self.targ_name_no_port
trig_voltage = (self.trig_val_of_vdd * vdd_voltage)
return (meas_name, trig_name, targ_name, trig_voltage, self.trig_dir_str, trig_td) |
def set_meas_constants(self, targ_name):
'Sets values useful for power simulations. This value is only meta related to the lib file (rise/fall)'
self.targ_name_no_port = targ_name | -5,146,723,263,897,668,000 | Sets values useful for power simulations. This value is only meta related to the lib file (rise/fall) | compiler/characterizer/measurements.py | set_meas_constants | ckdur/OpenRAM | python | def set_meas_constants(self, targ_name):
self.targ_name_no_port = targ_name |
def get_measure_values(self, time_at, port=None):
'Constructs inputs to stimulus measurement function. Variant values are inputs here.'
self.port_error_check(port)
if (port != None):
meas_name = '{}{}'.format(self.name, port)
targ_name = self.targ_name_no_port.format(port)
else:
meas_name = self.name
targ_name = self.targ_name_no_port
return (meas_name, targ_name, time_at) | 6,943,203,446,779,191,000 | Constructs inputs to stimulus measurement function. Variant values are inputs here. | compiler/characterizer/measurements.py | get_measure_values | ckdur/OpenRAM | python | def get_measure_values(self, time_at, port=None):
self.port_error_check(port)
if (port != None):
meas_name = '{}{}'.format(self.name, port)
targ_name = self.targ_name_no_port.format(port)
else:
meas_name = self.name
targ_name = self.targ_name_no_port
return (meas_name, targ_name, time_at) |
def write_version_py(filename: str='popmon/version.py') -> None:
'Write package version to version.py.\n\n This will ensure that the version in version.py is in sync with us.\n\n :param filename: The version.py to write too.\n :type filename: str\n '
version_str = '"""THIS FILE IS AUTO-GENERATED BY SETUP.PY."""\n\nname = "{name!s}"\nversion = "{version!s}"\nfull_version = "{full_version!s}"\nrelease = {is_release!s}\n'
with open(filename, 'w') as version_file:
version_file.write(version_str.format(name=NAME.lower(), version=VERSION, full_version=FULL_VERSION, is_release=(not DEV))) | 1,453,976,218,261,424,000 | Write package version to version.py.
This will ensure that the version in version.py is in sync with us.
:param filename: The version.py to write too.
:type filename: str | setup.py | write_version_py | stephanecollot/popmon | python | def write_version_py(filename: str='popmon/version.py') -> None:
'Write package version to version.py.\n\n This will ensure that the version in version.py is in sync with us.\n\n :param filename: The version.py to write too.\n :type filename: str\n '
version_str = '"THIS FILE IS AUTO-GENERATED BY SETUP.PY."\n\nname = "{name!s}"\nversion = "{version!s}"\nfull_version = "{full_version!s}"\nrelease = {is_release!s}\n'
with open(filename, 'w') as version_file:
version_file.write(version_str.format(name=NAME.lower(), version=VERSION, full_version=FULL_VERSION, is_release=(not DEV))) |
def setup_package() -> None:
'The main setup method.\n\n It is responsible for setting up and installing the package.\n '
write_version_py()
setup(name=NAME, version=VERSION, url='https://github.com/ing-bank/popmon', license='MIT', author='ING Wholesale Banking Advanced Analytics', description='Monitor the stability of a pandas or spark dataset', keywords='pandas spark data-science data-analysis monitoring statistics python jupyter ipython', long_description=long_description, long_description_content_type='text/x-rst', python_requires='>=3.6', packages=find_packages(), install_requires=REQUIREMENTS, classifiers=['Programming Language :: Python :: 3', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent'], package_data=dict(popmon=['visualization/templates/*.html', 'visualization/templates/assets/css/*.css', 'visualization/templates/assets/js/*.js', 'test_data/*.csv.gz', 'test_data/*.json*', 'notebooks/popmon*tutorial*.ipynb']), entry_points={'console_scripts': ['popmon_run = popmon.pipeline.amazing_pipeline:run']}) | -8,776,056,129,339,171,000 | The main setup method.
It is responsible for setting up and installing the package. | setup.py | setup_package | stephanecollot/popmon | python | def setup_package() -> None:
'The main setup method.\n\n It is responsible for setting up and installing the package.\n '
write_version_py()
setup(name=NAME, version=VERSION, url='https://github.com/ing-bank/popmon', license='MIT', author='ING Wholesale Banking Advanced Analytics', description='Monitor the stability of a pandas or spark dataset', keywords='pandas spark data-science data-analysis monitoring statistics python jupyter ipython', long_description=long_description, long_description_content_type='text/x-rst', python_requires='>=3.6', packages=find_packages(), install_requires=REQUIREMENTS, classifiers=['Programming Language :: Python :: 3', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent'], package_data=dict(popmon=['visualization/templates/*.html', 'visualization/templates/assets/css/*.css', 'visualization/templates/assets/js/*.js', 'test_data/*.csv.gz', 'test_data/*.json*', 'notebooks/popmon*tutorial*.ipynb']), entry_points={'console_scripts': ['popmon_run = popmon.pipeline.amazing_pipeline:run']}) |
def load_fairsharing(force_download: bool=False, use_tqdm: bool=True, **kwargs):
'Get the FAIRsharing registry.'
path = ensure_fairsharing(force_download=force_download, use_tqdm=use_tqdm, **kwargs)
with path.open() as file:
return yaml.safe_load(file) | -7,010,215,355,243,540,000 | Get the FAIRsharing registry. | src/fairsharing_client/api.py | load_fairsharing | cthoyt/fairsharing-client | python | def load_fairsharing(force_download: bool=False, use_tqdm: bool=True, **kwargs):
path = ensure_fairsharing(force_download=force_download, use_tqdm=use_tqdm, **kwargs)
with path.open() as file:
return yaml.safe_load(file) |
def ensure_fairsharing(force_download: bool=False, use_tqdm: bool=True, **kwargs):
'Get the FAIRsharing registry.'
if (PATH.exists() and (not force_download)):
return PATH
client = FairsharingClient(**kwargs)
rv = {row['prefix']: row for row in tqdm(client.iter_records(), unit_scale=True, unit='record', desc='Downloading FAIRsharing', disable=(not use_tqdm))}
with PATH.open('w') as file:
yaml.safe_dump(rv, file, allow_unicode=True, sort_keys=True)
return PATH | -3,742,049,016,979,473,000 | Get the FAIRsharing registry. | src/fairsharing_client/api.py | ensure_fairsharing | cthoyt/fairsharing-client | python | def ensure_fairsharing(force_download: bool=False, use_tqdm: bool=True, **kwargs):
if (PATH.exists() and (not force_download)):
return PATH
client = FairsharingClient(**kwargs)
rv = {row['prefix']: row for row in tqdm(client.iter_records(), unit_scale=True, unit='record', desc='Downloading FAIRsharing', disable=(not use_tqdm))}
with PATH.open('w') as file:
yaml.safe_dump(rv, file, allow_unicode=True, sort_keys=True)
return PATH |
def __init__(self, login: Optional[str]=None, password: Optional[str]=None, base_url: Optional[str]=None):
'Instantiate the client and get an appropriate JWT token.\n\n :param login: FAIRsharing username\n :param password: Corresponding FAIRsharing password\n :param base_url: The base URL\n '
self.base_url = (base_url or 'https://api.fairsharing.org')
self.signin_url = f'{self.base_url}/users/sign_in'
self.records_url = f'{self.base_url}/fairsharing_records'
self.username = pystow.get_config('fairsharing', 'login', passthrough=login, raise_on_missing=True)
self.password = pystow.get_config('fairsharing', 'password', passthrough=password, raise_on_missing=True)
self.jwt = self.get_jwt()
self.session = requests.Session()
self.session.headers.update({'Accept': 'application/json', 'Content-Type': 'application/json', 'Authorization': f'Bearer {self.jwt}'}) | -7,216,728,358,557,764,000 | Instantiate the client and get an appropriate JWT token.
:param login: FAIRsharing username
:param password: Corresponding FAIRsharing password
:param base_url: The base URL | src/fairsharing_client/api.py | __init__ | cthoyt/fairsharing-client | python | def __init__(self, login: Optional[str]=None, password: Optional[str]=None, base_url: Optional[str]=None):
'Instantiate the client and get an appropriate JWT token.\n\n :param login: FAIRsharing username\n :param password: Corresponding FAIRsharing password\n :param base_url: The base URL\n '
self.base_url = (base_url or 'https://api.fairsharing.org')
self.signin_url = f'{self.base_url}/users/sign_in'
self.records_url = f'{self.base_url}/fairsharing_records'
self.username = pystow.get_config('fairsharing', 'login', passthrough=login, raise_on_missing=True)
self.password = pystow.get_config('fairsharing', 'password', passthrough=password, raise_on_missing=True)
self.jwt = self.get_jwt()
self.session = requests.Session()
self.session.headers.update({'Accept': 'application/json', 'Content-Type': 'application/json', 'Authorization': f'Bearer {self.jwt}'}) |
def get_jwt(self) -> str:
'Get the JWT.'
payload = {'user': {'login': self.username, 'password': self.password}}
res = requests.post(self.signin_url, json=payload).json()
return res['jwt'] | 2,762,539,216,933,605,400 | Get the JWT. | src/fairsharing_client/api.py | get_jwt | cthoyt/fairsharing-client | python | def get_jwt(self) -> str:
payload = {'user': {'login': self.username, 'password': self.password}}
res = requests.post(self.signin_url, json=payload).json()
return res['jwt'] |
def iter_records(self) -> Iterable[Mapping[(str, Any)]]:
'Iterate over all FAIRsharing records.'
(yield from self._iter_records_helper(self.records_url)) | -8,303,350,746,535,719,000 | Iterate over all FAIRsharing records. | src/fairsharing_client/api.py | iter_records | cthoyt/fairsharing-client | python | def iter_records(self) -> Iterable[Mapping[(str, Any)]]:
(yield from self._iter_records_helper(self.records_url)) |
def load_reference(path_to_reference):
'Load Reference reference relevant passages\n Args:path_to_reference (str): path to a file to load.\n Returns:qids_to_relevant_passageids (dict): dictionary mapping from query_id (int) to relevant passages (list of ints).\n '
with open(path_to_reference, 'r') as f:
qids_to_relevant_passageids = load_reference_from_stream(f)
return qids_to_relevant_passageids | 7,859,981,109,900,859,000 | Load Reference reference relevant passages
Args:path_to_reference (str): path to a file to load.
Returns:qids_to_relevant_passageids (dict): dictionary mapping from query_id (int) to relevant passages (list of ints). | demo/search/src/eval/evaluation.py | load_reference | meta-soul/MetaSpore | python | def load_reference(path_to_reference):
'Load Reference reference relevant passages\n Args:path_to_reference (str): path to a file to load.\n Returns:qids_to_relevant_passageids (dict): dictionary mapping from query_id (int) to relevant passages (list of ints).\n '
with open(path_to_reference, 'r') as f:
qids_to_relevant_passageids = load_reference_from_stream(f)
return qids_to_relevant_passageids |
def load_candidate(path_to_candidate):
'Load candidate data from a file.\n Args:path_to_candidate (str): path to file to load.\n Returns:qid_to_ranked_candidate_passages (dict): dictionary mapping from query_id (int) to a list of 1000 passage ids(int) ranked by relevance and importance\n '
with open(path_to_candidate, 'r') as f:
qid_to_ranked_candidate_passages = load_candidate_from_stream(f)
return qid_to_ranked_candidate_passages | 2,387,017,372,047,628,300 | Load candidate data from a file.
Args:path_to_candidate (str): path to file to load.
Returns:qid_to_ranked_candidate_passages (dict): dictionary mapping from query_id (int) to a list of 1000 passage ids(int) ranked by relevance and importance | demo/search/src/eval/evaluation.py | load_candidate | meta-soul/MetaSpore | python | def load_candidate(path_to_candidate):
'Load candidate data from a file.\n Args:path_to_candidate (str): path to file to load.\n Returns:qid_to_ranked_candidate_passages (dict): dictionary mapping from query_id (int) to a list of 1000 passage ids(int) ranked by relevance and importance\n '
with open(path_to_candidate, 'r') as f:
qid_to_ranked_candidate_passages = load_candidate_from_stream(f)
return qid_to_ranked_candidate_passages |
def quality_checks_qids(qids_to_relevant_passageids, qids_to_ranked_candidate_passages):
'Perform quality checks on the dictionaries\n Args:\n p_qids_to_relevant_passageids (dict): dictionary of query-passage mapping\n Dict as read in with load_reference or load_reference_from_stream\n p_qids_to_ranked_candidate_passages (dict): dictionary of query-passage candidates\n Returns:\n bool,str: Boolean whether allowed, message to be shown in case of a problem\n '
message = ''
allowed = True
candidate_set = set(qids_to_ranked_candidate_passages.keys())
ref_set = set(qids_to_relevant_passageids.keys())
for qid in qids_to_ranked_candidate_passages:
duplicate_pids = set([item for (item, count) in Counter(qids_to_ranked_candidate_passages[qid]).items() if (count > 1)])
if (len((duplicate_pids - set([0]))) > 0):
message = 'Cannot rank a passage multiple times for a single query. QID={qid}, PID={pid}'.format(qid=qid, pid=list(duplicate_pids)[0])
allowed = False
return (allowed, message) | 3,041,526,021,280,315,400 | Perform quality checks on the dictionaries
Args:
p_qids_to_relevant_passageids (dict): dictionary of query-passage mapping
Dict as read in with load_reference or load_reference_from_stream
p_qids_to_ranked_candidate_passages (dict): dictionary of query-passage candidates
Returns:
bool,str: Boolean whether allowed, message to be shown in case of a problem | demo/search/src/eval/evaluation.py | quality_checks_qids | meta-soul/MetaSpore | python | def quality_checks_qids(qids_to_relevant_passageids, qids_to_ranked_candidate_passages):
'Perform quality checks on the dictionaries\n Args:\n p_qids_to_relevant_passageids (dict): dictionary of query-passage mapping\n Dict as read in with load_reference or load_reference_from_stream\n p_qids_to_ranked_candidate_passages (dict): dictionary of query-passage candidates\n Returns:\n bool,str: Boolean whether allowed, message to be shown in case of a problem\n '
message =
allowed = True
candidate_set = set(qids_to_ranked_candidate_passages.keys())
ref_set = set(qids_to_relevant_passageids.keys())
for qid in qids_to_ranked_candidate_passages:
duplicate_pids = set([item for (item, count) in Counter(qids_to_ranked_candidate_passages[qid]).items() if (count > 1)])
if (len((duplicate_pids - set([0]))) > 0):
message = 'Cannot rank a passage multiple times for a single query. QID={qid}, PID={pid}'.format(qid=qid, pid=list(duplicate_pids)[0])
allowed = False
return (allowed, message) |
def compute_metrics(qids_to_relevant_passageids, qids_to_ranked_candidate_passages):
"Compute MRR metric\n Args:\n p_qids_to_relevant_passageids (dict): dictionary of query-passage mapping\n Dict as read in with load_reference or load_reference_from_stream\n p_qids_to_ranked_candidate_passages (dict): dictionary of query-passage candidates\n Returns:\n dict: dictionary of metrics {'MRR': <MRR Score>}\n "
all_scores = {}
MRR = 0
qids_with_relevant_passages = 0
ranking = []
recall_q_top1 = set()
recall_q_top50 = set()
recall_q_all = set()
for qid in qids_to_ranked_candidate_passages:
if (qid in qids_to_relevant_passageids):
ranking.append(0)
target_pid = qids_to_relevant_passageids[qid]
candidate_pid = qids_to_ranked_candidate_passages[qid]
for i in range(0, MaxMRRRank):
if (candidate_pid[i] in target_pid):
MRR += (1.0 / (i + 1))
ranking.pop()
ranking.append((i + 1))
break
for (i, pid) in enumerate(candidate_pid):
if (pid in target_pid):
recall_q_all.add(qid)
if (i < 50):
recall_q_top50.add(qid)
if (i == 0):
recall_q_top1.add(qid)
break
if (len(ranking) == 0):
raise IOError('No matching QIDs found. Are you sure you are scoring the evaluation set?')
MRR = (MRR / len(qids_to_relevant_passageids))
recall_top1 = ((len(recall_q_top1) * 1.0) / len(qids_to_relevant_passageids))
recall_top50 = ((len(recall_q_top50) * 1.0) / len(qids_to_relevant_passageids))
recall_all = ((len(recall_q_all) * 1.0) / len(qids_to_relevant_passageids))
all_scores['MRR@10'] = MRR
all_scores['recall@1'] = recall_top1
all_scores['recall@50'] = recall_top50
all_scores['QueriesRanked'] = len(qids_to_ranked_candidate_passages)
return all_scores | -6,520,825,046,772,404,000 | Compute MRR metric
Args:
p_qids_to_relevant_passageids (dict): dictionary of query-passage mapping
Dict as read in with load_reference or load_reference_from_stream
p_qids_to_ranked_candidate_passages (dict): dictionary of query-passage candidates
Returns:
dict: dictionary of metrics {'MRR': <MRR Score>} | demo/search/src/eval/evaluation.py | compute_metrics | meta-soul/MetaSpore | python | def compute_metrics(qids_to_relevant_passageids, qids_to_ranked_candidate_passages):
"Compute MRR metric\n Args:\n p_qids_to_relevant_passageids (dict): dictionary of query-passage mapping\n Dict as read in with load_reference or load_reference_from_stream\n p_qids_to_ranked_candidate_passages (dict): dictionary of query-passage candidates\n Returns:\n dict: dictionary of metrics {'MRR': <MRR Score>}\n "
all_scores = {}
MRR = 0
qids_with_relevant_passages = 0
ranking = []
recall_q_top1 = set()
recall_q_top50 = set()
recall_q_all = set()
for qid in qids_to_ranked_candidate_passages:
if (qid in qids_to_relevant_passageids):
ranking.append(0)
target_pid = qids_to_relevant_passageids[qid]
candidate_pid = qids_to_ranked_candidate_passages[qid]
for i in range(0, MaxMRRRank):
if (candidate_pid[i] in target_pid):
MRR += (1.0 / (i + 1))
ranking.pop()
ranking.append((i + 1))
break
for (i, pid) in enumerate(candidate_pid):
if (pid in target_pid):
recall_q_all.add(qid)
if (i < 50):
recall_q_top50.add(qid)
if (i == 0):
recall_q_top1.add(qid)
break
if (len(ranking) == 0):
raise IOError('No matching QIDs found. Are you sure you are scoring the evaluation set?')
MRR = (MRR / len(qids_to_relevant_passageids))
recall_top1 = ((len(recall_q_top1) * 1.0) / len(qids_to_relevant_passageids))
recall_top50 = ((len(recall_q_top50) * 1.0) / len(qids_to_relevant_passageids))
recall_all = ((len(recall_q_all) * 1.0) / len(qids_to_relevant_passageids))
all_scores['MRR@10'] = MRR
all_scores['recall@1'] = recall_top1
all_scores['recall@50'] = recall_top50
all_scores['QueriesRanked'] = len(qids_to_ranked_candidate_passages)
return all_scores |
def main():
'Command line:\n python result_eval.py <path_to_reference_file> <path_to_candidate_file>\n '
if (len(sys.argv) == 3):
path_to_reference = sys.argv[1]
path_to_candidate = sys.argv[2]
else:
print('Usage: result_eval.py <reference ranking> <candidate ranking>')
exit()
metrics = compute_metrics_from_files(path_to_reference, path_to_candidate)
result = dict()
for metric in sorted(metrics):
result[metric] = metrics[metric]
result_json = json.dumps(result)
print(result_json) | 208,726,705,023,159,900 | Command line:
python result_eval.py <path_to_reference_file> <path_to_candidate_file> | demo/search/src/eval/evaluation.py | main | meta-soul/MetaSpore | python | def main():
'Command line:\n python result_eval.py <path_to_reference_file> <path_to_candidate_file>\n '
if (len(sys.argv) == 3):
path_to_reference = sys.argv[1]
path_to_candidate = sys.argv[2]
else:
print('Usage: result_eval.py <reference ranking> <candidate ranking>')
exit()
metrics = compute_metrics_from_files(path_to_reference, path_to_candidate)
result = dict()
for metric in sorted(metrics):
result[metric] = metrics[metric]
result_json = json.dumps(result)
print(result_json) |
def __init__(self, data, time, timestamp=True):
'\n I parametri di input sono\n - "data": il dato che si vuole memorizzare (di qualsiasi natura)\n - "time": l\'informazione temporale associata al dato (numero intero)\n - "timestamp": flag booleana. Se vero, il campo "time" e\' un timestamp; altrimenti,\n e\' un intervallo di tempo\n '
try:
time = int(time)
except:
raise TypeError('"time" parameter is invalid. It must be an integer number')
self.data = data
self.time = time
self.timestamp = (True if timestamp else False) | 4,228,763,057,017,822,700 | I parametri di input sono
- "data": il dato che si vuole memorizzare (di qualsiasi natura)
- "time": l'informazione temporale associata al dato (numero intero)
- "timestamp": flag booleana. Se vero, il campo "time" e' un timestamp; altrimenti,
e' un intervallo di tempo | timed_structures.py | __init__ | gavalle94/P2P-Sim | python | def __init__(self, data, time, timestamp=True):
'\n I parametri di input sono\n - "data": il dato che si vuole memorizzare (di qualsiasi natura)\n - "time": l\'informazione temporale associata al dato (numero intero)\n - "timestamp": flag booleana. Se vero, il campo "time" e\' un timestamp; altrimenti,\n e\' un intervallo di tempo\n '
try:
time = int(time)
except:
raise TypeError('"time" parameter is invalid. It must be an integer number')
self.data = data
self.time = time
self.timestamp = (True if timestamp else False) |
def get_data(self):
'\n Ritorna il campo "data"\n '
return self.data | 85,169,138,149,347,760 | Ritorna il campo "data" | timed_structures.py | get_data | gavalle94/P2P-Sim | python | def get_data(self):
'\n \n '
return self.data |
def get_time(self):
'\n Ritorna il campo "time"\n '
return self.time | 4,622,078,850,810,152,000 | Ritorna il campo "time" | timed_structures.py | get_time | gavalle94/P2P-Sim | python | def get_time(self):
'\n \n '
return self.time |
def __init__(self, timestamp=True, empty=True):
'\n La flag "timestamp" serve per specificare se la lista contiene dati con un timestamp (True) oppure un \n intervallo temporale (False) associato: la flag "empty" permette invece di creare, se settata a False, \n un TimedArray contenente al suo interno un nodo di partenza (d = 0, t = 0)\n '
self._list = []
self.timestamp = (timestamp is True)
if (not empty):
self.append(TimedData(0, 0, self.timestamp)) | 4,569,864,705,304,169,500 | La flag "timestamp" serve per specificare se la lista contiene dati con un timestamp (True) oppure un
intervallo temporale (False) associato: la flag "empty" permette invece di creare, se settata a False,
un TimedArray contenente al suo interno un nodo di partenza (d = 0, t = 0) | timed_structures.py | __init__ | gavalle94/P2P-Sim | python | def __init__(self, timestamp=True, empty=True):
'\n La flag "timestamp" serve per specificare se la lista contiene dati con un timestamp (True) oppure un \n intervallo temporale (False) associato: la flag "empty" permette invece di creare, se settata a False, \n un TimedArray contenente al suo interno un nodo di partenza (d = 0, t = 0)\n '
self._list = []
self.timestamp = (timestamp is True)
if (not empty):
self.append(TimedData(0, 0, self.timestamp)) |
def get_list(self):
'\n Ritorna l\'elenco di oggetti "TimedData", memorizzati come lista\n '
return self._list | -8,256,815,946,186,110,000 | Ritorna l'elenco di oggetti "TimedData", memorizzati come lista | timed_structures.py | get_list | gavalle94/P2P-Sim | python | def get_list(self):
'\n Ritorna l\'elenco di oggetti "TimedData", memorizzati come lista\n '
return self._list |
def get_data_list(self):
'\n Ritorna gli attributi "data" di ogni elemento del vettore, sottoforma di lista\n '
return map((lambda x: x.get_data()), self._list) | 5,630,010,020,618,524,000 | Ritorna gli attributi "data" di ogni elemento del vettore, sottoforma di lista | timed_structures.py | get_data_list | gavalle94/P2P-Sim | python | def get_data_list(self):
'\n \n '
return map((lambda x: x.get_data()), self._list) |
def get_time_list(self):
'\n Ritorna gli attributi "time" di ogni elemento del vettore, sottoforma di lista\n '
return map((lambda x: x.get_time()), self._list) | 1,463,834,359,463,817,000 | Ritorna gli attributi "time" di ogni elemento del vettore, sottoforma di lista | timed_structures.py | get_time_list | gavalle94/P2P-Sim | python | def get_time_list(self):
'\n \n '
return map((lambda x: x.get_time()), self._list) |
def has_time_intervals(self):
'\n Ritorna True se gli elementi del vettore hanno associato un intervallo temporale\n '
return (self.timestamp is False) | -6,681,286,669,567,149,000 | Ritorna True se gli elementi del vettore hanno associato un intervallo temporale | timed_structures.py | has_time_intervals | gavalle94/P2P-Sim | python | def has_time_intervals(self):
'\n \n '
return (self.timestamp is False) |
def append(self, item):
'\n Aggiungo un elemento alla lista\n '
if (not isinstance(item, TimedData)):
raise TypeError('cannot add a non-"TimedData" object to a "TimedArray" list')
if (item.timestamp != self.timestamp):
raise ValueError(('"item" parameter is invalid: its "timestamp" attribute must be equal to %s' % self.timestamp))
self._list.append(item) | -585,549,019,964,779,300 | Aggiungo un elemento alla lista | timed_structures.py | append | gavalle94/P2P-Sim | python | def append(self, item):
'\n \n '
if (not isinstance(item, TimedData)):
raise TypeError('cannot add a non-"TimedData" object to a "TimedArray" list')
if (item.timestamp != self.timestamp):
raise ValueError(('"item" parameter is invalid: its "timestamp" attribute must be equal to %s' % self.timestamp))
self._list.append(item) |
def remove(self, item):
'\n Questa funzione rimuove "item" (se presente) dall\'array\n '
if (not isinstance(item, TimedData)):
raise TypeError('the item to remove must be a "TimedData" object')
if (item in self._list):
self._list.remove(item) | 8,417,262,223,646,293,000 | Questa funzione rimuove "item" (se presente) dall'array | timed_structures.py | remove | gavalle94/P2P-Sim | python | def remove(self, item):
'\n Questa funzione rimuove "item" (se presente) dall\'array\n '
if (not isinstance(item, TimedData)):
raise TypeError('the item to remove must be a "TimedData" object')
if (item in self._list):
self._list.remove(item) |
def remove_all(self, items):
'\n Questa funzione permette di rimuovere un elenco di oggetti "TimedData"\n '
if (not isinstance(items, (list, tuple))):
raise TypeError('"items" parameter must be an array')
try:
for x in items:
self.remove(x)
except TypeError:
raise TypeError('the items list must contain only "TimedData" objects') | 6,566,842,987,476,713,000 | Questa funzione permette di rimuovere un elenco di oggetti "TimedData" | timed_structures.py | remove_all | gavalle94/P2P-Sim | python | def remove_all(self, items):
'\n \n '
if (not isinstance(items, (list, tuple))):
raise TypeError('"items" parameter must be an array')
try:
for x in items:
self.remove(x)
except TypeError:
raise TypeError('the items list must contain only "TimedData" objects') |
def filter(self, f):
'\n Questa funzione applica la funzione f per filtrare il contenuto del vettore\n '
res = TimedArray(self.timestamp, empty=True)
res._list = filter(f, self._list)
return res | 154,201,250,522,479 | Questa funzione applica la funzione f per filtrare il contenuto del vettore | timed_structures.py | filter | gavalle94/P2P-Sim | python | def filter(self, f):
'\n \n '
res = TimedArray(self.timestamp, empty=True)
res._list = filter(f, self._list)
return res |
def filter_data_range(self, start, end):
'\n La funzione filtra il vettore per range di valori "Data"\n '
return self.filter((lambda x: (start <= x.get_data() <= end))) | -7,030,954,649,003,596,000 | La funzione filtra il vettore per range di valori "Data" | timed_structures.py | filter_data_range | gavalle94/P2P-Sim | python | def filter_data_range(self, start, end):
'\n \n '
return self.filter((lambda x: (start <= x.get_data() <= end))) |
def filter_time_range(self, start, end):
'\n La funzione filtra il vettore per range di valori "Data"\n '
return self.filter((lambda x: (start <= x.get_time() <= end))) | -147,114,222,026,584,930 | La funzione filtra il vettore per range di valori "Data" | timed_structures.py | filter_time_range | gavalle94/P2P-Sim | python | def filter_time_range(self, start, end):
'\n \n '
return self.filter((lambda x: (start <= x.get_time() <= end))) |
def search(self, to_search):
'\n Funzione di ricerca all\'interno del contenuto del vettore.\n Se "timestamp" e\' True, la chiave per la ricerca e\' il timestamp: altrimenti,\n la chiave diventa il contenuto a cui e\' associato l\'intervallo temporale.\n '
if self.timestamp:
res = self.search_by_time(to_search)
else:
res = self.search_by_data(to_search)
return res | 7,965,807,605,075,835,000 | Funzione di ricerca all'interno del contenuto del vettore.
Se "timestamp" e' True, la chiave per la ricerca e' il timestamp: altrimenti,
la chiave diventa il contenuto a cui e' associato l'intervallo temporale. | timed_structures.py | search | gavalle94/P2P-Sim | python | def search(self, to_search):
'\n Funzione di ricerca all\'interno del contenuto del vettore.\n Se "timestamp" e\' True, la chiave per la ricerca e\' il timestamp: altrimenti,\n la chiave diventa il contenuto a cui e\' associato l\'intervallo temporale.\n '
if self.timestamp:
res = self.search_by_time(to_search)
else:
res = self.search_by_data(to_search)
return res |
def search_by_data(self, to_search):
'\n Funzione di ricerca per campo "data", all\'interno del vettore\n '
research = (lambda x: (x.data == to_search))
return filter(research, self._list) | -6,827,395,980,579,480,000 | Funzione di ricerca per campo "data", all'interno del vettore | timed_structures.py | search_by_data | gavalle94/P2P-Sim | python | def search_by_data(self, to_search):
'\n Funzione di ricerca per campo "data", all\'interno del vettore\n '
research = (lambda x: (x.data == to_search))
return filter(research, self._list) |
def search_by_datas(self, search_params):
'\n Funzione di ricerca per campo "data", all\'interno del vettore: il parametro di ricerca e\' un vettore\n '
if (not isinstance(search_params, (list, tuple))):
raise TypeError('"searchParams" parameter is invalid. It must be an array')
result = []
for x in search_params:
tmp = self.search_by_data(x)
for t in tmp:
result.append(t)
return result | 4,315,657,999,801,148,000 | Funzione di ricerca per campo "data", all'interno del vettore: il parametro di ricerca e' un vettore | timed_structures.py | search_by_datas | gavalle94/P2P-Sim | python | def search_by_datas(self, search_params):
'\n Funzione di ricerca per campo "data", all\'interno del vettore: il parametro di ricerca e\' un vettore\n '
if (not isinstance(search_params, (list, tuple))):
raise TypeError('"searchParams" parameter is invalid. It must be an array')
result = []
for x in search_params:
tmp = self.search_by_data(x)
for t in tmp:
result.append(t)
return result |
def search_by_time(self, to_search):
'\n Funzione di ricerca per campo "time", all\'interno del vettore\n Il parametro "toSearch" deve essere un numero intero\n '
if (not isinstance(to_search, (int, long))):
raise TypeError('the research parameter must be an integer number (timestamp)')
research = (lambda x: (x.time == to_search))
return filter(research, self._list) | -6,471,579,091,854,855,000 | Funzione di ricerca per campo "time", all'interno del vettore
Il parametro "toSearch" deve essere un numero intero | timed_structures.py | search_by_time | gavalle94/P2P-Sim | python | def search_by_time(self, to_search):
'\n Funzione di ricerca per campo "time", all\'interno del vettore\n Il parametro "toSearch" deve essere un numero intero\n '
if (not isinstance(to_search, (int, long))):
raise TypeError('the research parameter must be an integer number (timestamp)')
research = (lambda x: (x.time == to_search))
return filter(research, self._list) |
def search_by_times(self, search_params):
'\n Funzione di ricerca per campo "time", all\'interno del vettore: il parametro di ricerca e\' un vettore\n '
if (not isinstance(search_params, (list, tuple))):
raise TypeError('"searchParams" parameter is invalid. It must be an array')
result = []
for x in search_params:
tmp = self.search_by_time(x)
for t in tmp:
result.append(t)
return result | 2,318,858,354,737,550,000 | Funzione di ricerca per campo "time", all'interno del vettore: il parametro di ricerca e' un vettore | timed_structures.py | search_by_times | gavalle94/P2P-Sim | python | def search_by_times(self, search_params):
'\n Funzione di ricerca per campo "time", all\'interno del vettore: il parametro di ricerca e\' un vettore\n '
if (not isinstance(search_params, (list, tuple))):
raise TypeError('"searchParams" parameter is invalid. It must be an array')
result = []
for x in search_params:
tmp = self.search_by_time(x)
for t in tmp:
result.append(t)
return result |
def contains(self, to_search):
'\n La funzione mi dice se la ricerca nel vettore, sulla base della chiave di ricerca \n "toSearch" specificata, produce risultati\n '
return (len(self.search(to_search)) > 0) | -942,463,144,239,270,000 | La funzione mi dice se la ricerca nel vettore, sulla base della chiave di ricerca
"toSearch" specificata, produce risultati | timed_structures.py | contains | gavalle94/P2P-Sim | python | def contains(self, to_search):
'\n La funzione mi dice se la ricerca nel vettore, sulla base della chiave di ricerca \n "toSearch" specificata, produce risultati\n '
return (len(self.search(to_search)) > 0) |
def update(self, to_search, new_value):
'\n Questa funzione aggiorna il contenuto degli elementi del vettore che\n soddisfano il criterio di ricerca specificato\n - "toSearch" e\' la chiave di ricerca\n - "newValue" e\' il valore aggiornato da inserire\n '
items = self.search(to_search)
if self.timestamp:
def update_function(x):
x.data = new_value
else:
def update_function(x):
x.time = new_value
map(update_function, items) | 2,321,393,015,156,305,400 | Questa funzione aggiorna il contenuto degli elementi del vettore che
soddisfano il criterio di ricerca specificato
- "toSearch" e' la chiave di ricerca
- "newValue" e' il valore aggiornato da inserire | timed_structures.py | update | gavalle94/P2P-Sim | python | def update(self, to_search, new_value):
'\n Questa funzione aggiorna il contenuto degli elementi del vettore che\n soddisfano il criterio di ricerca specificato\n - "toSearch" e\' la chiave di ricerca\n - "newValue" e\' il valore aggiornato da inserire\n '
items = self.search(to_search)
if self.timestamp:
def update_function(x):
x.data = new_value
else:
def update_function(x):
x.time = new_value
map(update_function, items) |
@click.group()
def cli():
'\n Click entry point: vue-cli commands group\n By convention all new cli has a cli function with a pass statement\n '
pass | -7,861,764,993,612,917,000 | Click entry point: vue-cli commands group
By convention all new cli has a cli function with a pass statement | python_vuejs/vuejs.py | cli | Timtech4u/python-vuejs | python | @click.group()
def cli():
'\n Click entry point: vue-cli commands group\n By convention all new cli has a cli function with a pass statement\n '
pass |
@cli.command()
def vuecheck():
'\n Check if node > 5 and npm > 3 are installed\n '
if VueJs.node_check():
click.echo(click.style('Found node and npm', fg='green'))
else:
click.echo(click.style('Missing node and npm installation', fg='red')) | -9,014,432,238,725,884,000 | Check if node > 5 and npm > 3 are installed | python_vuejs/vuejs.py | vuecheck | Timtech4u/python-vuejs | python | @cli.command()
def vuecheck():
'\n \n '
if VueJs.node_check():
click.echo(click.style('Found node and npm', fg='green'))
else:
click.echo(click.style('Missing node and npm installation', fg='red')) |
@cli.command()
def installvuecli():
'\n Install vue-cli\n '
if VueJs.vue_cli_check():
click.echo(click.style('Found valid vue-cli', fg='green'))
else:
VueJs.install_cli()
click.echo(click.style('Installed vue-cli globally', fg='green')) | 6,865,345,044,462,891,000 | Install vue-cli | python_vuejs/vuejs.py | installvuecli | Timtech4u/python-vuejs | python | @cli.command()
def installvuecli():
'\n \n '
if VueJs.vue_cli_check():
click.echo(click.style('Found valid vue-cli', fg='green'))
else:
VueJs.install_cli()
click.echo(click.style('Installed vue-cli globally', fg='green')) |
@cli.command()
@click.argument('project')
def startvueapp(project):
'\n Init vue project via vue-cli\n '
result = VueJsBuilder.startproject(project)
click.echo(click.style(result.message, fg=result.color)) | -6,052,704,749,312,351,000 | Init vue project via vue-cli | python_vuejs/vuejs.py | startvueapp | Timtech4u/python-vuejs | python | @cli.command()
@click.argument('project')
def startvueapp(project):
'\n \n '
result = VueJsBuilder.startproject(project)
click.echo(click.style(result.message, fg=result.color)) |
@cli.command()
def vuedev():
'\n Run frontend dev server via npm\n '
VueJs.dev() | 1,504,815,223,673,680,400 | Run frontend dev server via npm | python_vuejs/vuejs.py | vuedev | Timtech4u/python-vuejs | python | @cli.command()
def vuedev():
'\n \n '
VueJs.dev() |
@cli.command()
def vuebuild():
'\n Build Vue.js project via npm\n '
VueJs.build() | 1,892,445,388,804,446,700 | Build Vue.js project via npm | python_vuejs/vuejs.py | vuebuild | Timtech4u/python-vuejs | python | @cli.command()
def vuebuild():
'\n \n '
VueJs.build() |
@staticmethod
def node_check():
'\n Node and npm version checker\n '
node_ver = check_output('node -v'.split()).decode('utf-8').rsplit('.')[0]
npm_ver = check_output('npm -v'.split()).decode('utf-8').rsplit('.')[0]
return all([(node_ver > 'v5'), (npm_ver >= '4')]) | 7,613,313,706,571,738,000 | Node and npm version checker | python_vuejs/vuejs.py | node_check | Timtech4u/python-vuejs | python | @staticmethod
def node_check():
'\n \n '
node_ver = check_output('node -v'.split()).decode('utf-8').rsplit('.')[0]
npm_ver = check_output('npm -v'.split()).decode('utf-8').rsplit('.')[0]
return all([(node_ver > 'v5'), (npm_ver >= '4')]) |
@staticmethod
def vue_cli_check():
'\n vue-cli version checker\n '
try:
return check_output('vue -V'.split()).decode('utf-8').rsplit('.')[0]
except OSError:
return False | 8,401,622,990,614,264,000 | vue-cli version checker | python_vuejs/vuejs.py | vue_cli_check | Timtech4u/python-vuejs | python | @staticmethod
def vue_cli_check():
'\n \n '
try:
return check_output('vue -V'.split()).decode('utf-8').rsplit('.')[0]
except OSError:
return False |
def rot_matrix(theta):
'\n rot_matrix(theta)\n 2D rotation matrix for theta in radians\n returns numpy matrix\n '
(c, s) = (np.cos(theta), np.sin(theta))
return np.matrix([[c, (- s)], [s, c]]) | -2,153,688,713,178,053,600 | rot_matrix(theta)
2D rotation matrix for theta in radians
returns numpy matrix | schmidt_funcs.py | rot_matrix | johnarban/arban | python | def rot_matrix(theta):
'\n rot_matrix(theta)\n 2D rotation matrix for theta in radians\n returns numpy matrix\n '
(c, s) = (np.cos(theta), np.sin(theta))
return np.matrix([[c, (- s)], [s, c]]) |
def rectangle(c, w, h, angle=0, center=True):
'\n create rotated rectangle\n for input into PIL ImageDraw.polygon\n to make a rectangle polygon mask\n\n Rectagle is created and rotated with center\n at zero, and then translated to center position\n\n accepters centers\n Default : center\n tl, tr, bl, br\n '
(cx, cy) = c
x = (((- w) / 2.0), ((+ w) / 2.0), ((+ w) / 2.0), ((- w) / 2.0))
y = (((+ h) / 2.0), ((+ h) / 2.0), ((- h) / 2.0), ((- h) / 2.0))
if (center is not True):
if (center[0] == 'b'):
cy = (cy + (h / 2.0))
else:
cy = (cy - (h / 2.0))
if (center[1] == 'l'):
cx = (cx + (w / 2.0))
else:
cx = (cx - (w / 2.0))
R = rot_matrix(((angle * np.pi) / 180.0))
c = []
for i in range(4):
(xr, yr) = np.dot(R, np.asarray([x[i], y[i]])).A.ravel()
c.append(((cx + xr), (cy + yr)))
return c | 7,472,526,589,179,137,000 | create rotated rectangle
for input into PIL ImageDraw.polygon
to make a rectangle polygon mask
Rectagle is created and rotated with center
at zero, and then translated to center position
accepters centers
Default : center
tl, tr, bl, br | schmidt_funcs.py | rectangle | johnarban/arban | python | def rectangle(c, w, h, angle=0, center=True):
'\n create rotated rectangle\n for input into PIL ImageDraw.polygon\n to make a rectangle polygon mask\n\n Rectagle is created and rotated with center\n at zero, and then translated to center position\n\n accepters centers\n Default : center\n tl, tr, bl, br\n '
(cx, cy) = c
x = (((- w) / 2.0), ((+ w) / 2.0), ((+ w) / 2.0), ((- w) / 2.0))
y = (((+ h) / 2.0), ((+ h) / 2.0), ((- h) / 2.0), ((- h) / 2.0))
if (center is not True):
if (center[0] == 'b'):
cy = (cy + (h / 2.0))
else:
cy = (cy - (h / 2.0))
if (center[1] == 'l'):
cx = (cx + (w / 2.0))
else:
cx = (cx - (w / 2.0))
R = rot_matrix(((angle * np.pi) / 180.0))
c = []
for i in range(4):
(xr, yr) = np.dot(R, np.asarray([x[i], y[i]])).A.ravel()
c.append(((cx + xr), (cy + yr)))
return c |
def comp(arr):
'\n returns the compressed version\n of the input array if it is a\n numpy MaskedArray\n '
try:
return arr.compressed()
except:
return arr | -4,376,504,528,940,478,000 | returns the compressed version
of the input array if it is a
numpy MaskedArray | schmidt_funcs.py | comp | johnarban/arban | python | def comp(arr):
'\n returns the compressed version\n of the input array if it is a\n numpy MaskedArray\n '
try:
return arr.compressed()
except:
return arr |
def mavg(arr, n=2, mode='valid'):
'\n returns the moving average of an array.\n returned array is shorter by (n-1)\n '
if (len(arr) > 400):
return signal.fftconvolve(arr, ([(1.0 / float(n))] * n), mode=mode)
else:
return signal.convolve(arr, ([(1.0 / float(n))] * n), mode=mode) | -4,092,778,539,070,365,700 | returns the moving average of an array.
returned array is shorter by (n-1) | schmidt_funcs.py | mavg | johnarban/arban | python | def mavg(arr, n=2, mode='valid'):
'\n returns the moving average of an array.\n returned array is shorter by (n-1)\n '
if (len(arr) > 400):
return signal.fftconvolve(arr, ([(1.0 / float(n))] * n), mode=mode)
else:
return signal.convolve(arr, ([(1.0 / float(n))] * n), mode=mode) |
def mgeo(arr, n=2):
"\n Returns array of lenth len(arr) - (n-1)\n\n # # written by me\n # # slower for short loops\n # # faster for n ~ len(arr) and large arr\n a = []\n for i in xrange(len(arr)-(n-1)):\n a.append(stats.gmean(arr[i:n+i]))\n\n # # Original method# #\n # # written by me ... ~10x faster for short arrays\n b = np.array([np.roll(np.pad(arr,(0,n),mode='constant',constant_values=1),i)\n for i in xrange(n)])\n return np.product(b,axis=0)[n-1:-n]**(1./float(n))\n "
a = []
for i in range((len(arr) - (n - 1))):
a.append(stats.gmean(arr[i:(n + i)]))
return np.asarray(a) | 2,791,907,089,048,375,000 | Returns array of lenth len(arr) - (n-1)
# # written by me
# # slower for short loops
# # faster for n ~ len(arr) and large arr
a = []
for i in xrange(len(arr)-(n-1)):
a.append(stats.gmean(arr[i:n+i]))
# # Original method# #
# # written by me ... ~10x faster for short arrays
b = np.array([np.roll(np.pad(arr,(0,n),mode='constant',constant_values=1),i)
for i in xrange(n)])
return np.product(b,axis=0)[n-1:-n]**(1./float(n)) | schmidt_funcs.py | mgeo | johnarban/arban | python | def mgeo(arr, n=2):
"\n Returns array of lenth len(arr) - (n-1)\n\n # # written by me\n # # slower for short loops\n # # faster for n ~ len(arr) and large arr\n a = []\n for i in xrange(len(arr)-(n-1)):\n a.append(stats.gmean(arr[i:n+i]))\n\n # # Original method# #\n # # written by me ... ~10x faster for short arrays\n b = np.array([np.roll(np.pad(arr,(0,n),mode='constant',constant_values=1),i)\n for i in xrange(n)])\n return np.product(b,axis=0)[n-1:-n]**(1./float(n))\n "
a = []
for i in range((len(arr) - (n - 1))):
a.append(stats.gmean(arr[i:(n + i)]))
return np.asarray(a) |
def avg(arr, n=2):
'\n NOT a general averaging function\n return bin centers (lin and log)\n '
diff = np.diff(arr)
if np.allclose(diff, diff[::(- 1)]):
return mavg(arr, n=n)
else:
return np.power(10.0, mavg(np.log10(arr), n=n)) | -197,540,613,873,403,330 | NOT a general averaging function
return bin centers (lin and log) | schmidt_funcs.py | avg | johnarban/arban | python | def avg(arr, n=2):
'\n NOT a general averaging function\n return bin centers (lin and log)\n '
diff = np.diff(arr)
if np.allclose(diff, diff[::(- 1)]):
return mavg(arr, n=n)
else:
return np.power(10.0, mavg(np.log10(arr), n=n)) |
def llspace(xmin, xmax, n=None, log=False, dx=None, dex=None):
'\n llspace(xmin, xmax, n = None, log = False, dx = None, dex = None)\n get values evenly spaced in linear or log spaced\n n [10] -- Optional -- number of steps\n log [false] : switch for log spacing\n dx : spacing for linear bins\n dex : spacing for log bins (in base 10)\n dx and dex override n\n '
(xmin, xmax) = (float(xmin), float(xmax))
nisNone = (n is None)
dxisNone = (dx is None)
dexisNone = (dex is None)
if ((nisNone & dxisNone) & dexisNone):
print('Error: Defaulting to 10 linears steps')
n = 10.0
nisNone = False
log = (log or (dxisNone and (not dexisNone)))
if log:
if (xmin == 0):
print('log(0) is -inf. xmin must be > 0 for log spacing')
(xmin, xmax) = (np.log10(xmin), np.log10(xmax))
if (not nisNone):
if (log and dexisNone):
dex = ((xmax - xmin) / n)
elif ((not log) and dxisNone):
dx = ((xmax - xmin) / n)
if log:
return np.power(10, np.arange(xmin, (xmax + dex), dex))
else:
return np.arange(xmin, (xmax + dx), dx) | 1,981,684,264,025,986,300 | llspace(xmin, xmax, n = None, log = False, dx = None, dex = None)
get values evenly spaced in linear or log spaced
n [10] -- Optional -- number of steps
log [false] : switch for log spacing
dx : spacing for linear bins
dex : spacing for log bins (in base 10)
dx and dex override n | schmidt_funcs.py | llspace | johnarban/arban | python | def llspace(xmin, xmax, n=None, log=False, dx=None, dex=None):
'\n llspace(xmin, xmax, n = None, log = False, dx = None, dex = None)\n get values evenly spaced in linear or log spaced\n n [10] -- Optional -- number of steps\n log [false] : switch for log spacing\n dx : spacing for linear bins\n dex : spacing for log bins (in base 10)\n dx and dex override n\n '
(xmin, xmax) = (float(xmin), float(xmax))
nisNone = (n is None)
dxisNone = (dx is None)
dexisNone = (dex is None)
if ((nisNone & dxisNone) & dexisNone):
print('Error: Defaulting to 10 linears steps')
n = 10.0
nisNone = False
log = (log or (dxisNone and (not dexisNone)))
if log:
if (xmin == 0):
print('log(0) is -inf. xmin must be > 0 for log spacing')
(xmin, xmax) = (np.log10(xmin), np.log10(xmax))
if (not nisNone):
if (log and dexisNone):
dex = ((xmax - xmin) / n)
elif ((not log) and dxisNone):
dx = ((xmax - xmin) / n)
if log:
return np.power(10, np.arange(xmin, (xmax + dex), dex))
else:
return np.arange(xmin, (xmax + dx), dx) |
def nametoradec(name):
'\n Get names formatted as\n hhmmss.ss+ddmmss to Decimal Degree\n only works for dec > 0 (splits on +, not -)\n Will fix this eventually...\n '
if ('string' not in str(type(name))):
rightascen = []
declinatio = []
for n in name:
(ra, de) = n.split('+')
ra = ((((((ra[0:2] + ':') + ra[2:4]) + ':') + ra[4:6]) + '.') + ra[6:8])
de = ((((de[0:2] + ':') + de[2:4]) + ':') + de[4:6])
coord = SkyCoord(ra, de, frame='icrs', unit=('hourangle', 'degree'))
rightascen.append(coord.ra.value)
declinatio.append(coord.dec.value)
return (np.array(rightascen), np.array(declinatio))
else:
(ra, de) = name.split('+')
ra = ((((((ra[0:2] + ':') + ra[2:4]) + ':') + ra[4:6]) + '.') + ra[6:8])
de = ((((de[0:2] + ':') + de[2:4]) + ':') + de[4:6])
coord = SkyCoord(ra, de, frame='icrs', unit=('hourangle', 'degree'))
return (np.array(coord.ra.value), np.array(coord.dec.value)) | -6,515,821,912,911,989,000 | Get names formatted as
hhmmss.ss+ddmmss to Decimal Degree
only works for dec > 0 (splits on +, not -)
Will fix this eventually... | schmidt_funcs.py | nametoradec | johnarban/arban | python | def nametoradec(name):
'\n Get names formatted as\n hhmmss.ss+ddmmss to Decimal Degree\n only works for dec > 0 (splits on +, not -)\n Will fix this eventually...\n '
if ('string' not in str(type(name))):
rightascen = []
declinatio = []
for n in name:
(ra, de) = n.split('+')
ra = ((((((ra[0:2] + ':') + ra[2:4]) + ':') + ra[4:6]) + '.') + ra[6:8])
de = ((((de[0:2] + ':') + de[2:4]) + ':') + de[4:6])
coord = SkyCoord(ra, de, frame='icrs', unit=('hourangle', 'degree'))
rightascen.append(coord.ra.value)
declinatio.append(coord.dec.value)
return (np.array(rightascen), np.array(declinatio))
else:
(ra, de) = name.split('+')
ra = ((((((ra[0:2] + ':') + ra[2:4]) + ':') + ra[4:6]) + '.') + ra[6:8])
de = ((((de[0:2] + ':') + de[2:4]) + ':') + de[4:6])
coord = SkyCoord(ra, de, frame='icrs', unit=('hourangle', 'degree'))
return (np.array(coord.ra.value), np.array(coord.dec.value)) |
def get_ext(extmap, errmap, extwcs, ra, de):
'\n Get the extinction (errors) for a particular position or\n list of positions\n More generally get the value (error) for a particular\n position given a wcs and world coordinates\n '
try:
(xp, yp) = extwcs.all_world2pix(np.array([ra]).flatten(), np.array([de]).flatten(), 0)
except:
(xp, yp) = WCS(extwcs).all_world2pix(np.array([ra]).flatten(), np.array([de]).flatten(), 0)
ext = []
err = []
for i in range(len(np.array(xp))):
try:
ext.append(extmap[(yp[int(round(i))], xp[int(round(i))])])
if (errmap is not None):
err.append(errmap[(yp[int(round(i))], xp[int(round(i))])])
except IndexError:
ext.append(np.nan)
if (errmap is not None):
err.append(np.nan)
if (errmap is not None):
return (np.array(ext), np.array(err))
else:
return (np.array(ext), None) | -8,182,216,514,830,697,000 | Get the extinction (errors) for a particular position or
list of positions
More generally get the value (error) for a particular
position given a wcs and world coordinates | schmidt_funcs.py | get_ext | johnarban/arban | python | def get_ext(extmap, errmap, extwcs, ra, de):
'\n Get the extinction (errors) for a particular position or\n list of positions\n More generally get the value (error) for a particular\n position given a wcs and world coordinates\n '
try:
(xp, yp) = extwcs.all_world2pix(np.array([ra]).flatten(), np.array([de]).flatten(), 0)
except:
(xp, yp) = WCS(extwcs).all_world2pix(np.array([ra]).flatten(), np.array([de]).flatten(), 0)
ext = []
err = []
for i in range(len(np.array(xp))):
try:
ext.append(extmap[(yp[int(round(i))], xp[int(round(i))])])
if (errmap is not None):
err.append(errmap[(yp[int(round(i))], xp[int(round(i))])])
except IndexError:
ext.append(np.nan)
if (errmap is not None):
err.append(np.nan)
if (errmap is not None):
return (np.array(ext), np.array(err))
else:
return (np.array(ext), None) |
def pdf(values, bins):
'\n ** Normalized differential area function. **\n (statistical) probability denisty function\n normalized so that the integral is 1\n and. The integral over a range is the\n probability of the value is within\n that range.\n\n Returns array of size len(bins)-1\n Plot versus bins[:-1]\n '
if hasattr(bins, '__getitem__'):
range = (np.nanmin(bins), np.nanmax(bins))
else:
range = None
(h, x) = np.histogram(values, bins=bins, range=range, density=False)
pdf = (h / (np.sum(h, dtype=float) * np.diff(x)))
return (pdf, avg(x)) | 1,778,812,167,562,346,800 | ** Normalized differential area function. **
(statistical) probability denisty function
normalized so that the integral is 1
and. The integral over a range is the
probability of the value is within
that range.
Returns array of size len(bins)-1
Plot versus bins[:-1] | schmidt_funcs.py | pdf | johnarban/arban | python | def pdf(values, bins):
'\n ** Normalized differential area function. **\n (statistical) probability denisty function\n normalized so that the integral is 1\n and. The integral over a range is the\n probability of the value is within\n that range.\n\n Returns array of size len(bins)-1\n Plot versus bins[:-1]\n '
if hasattr(bins, '__getitem__'):
range = (np.nanmin(bins), np.nanmax(bins))
else:
range = None
(h, x) = np.histogram(values, bins=bins, range=range, density=False)
pdf = (h / (np.sum(h, dtype=float) * np.diff(x)))
return (pdf, avg(x)) |
def pdf2(values, bins):
'\n The ~ PDF normalized so that\n the integral is equal to the\n total amount of a quantity.\n The integral over a range is the\n total amount within that range.\n\n Returns array of size len(bins)-1\n Plot versus bins[:-1]\n '
if hasattr(bins, '__getitem__'):
range = (np.nanmin(bins), np.nanmax(bins))
else:
range = None
(pdf, x) = np.histogram(values, bins=bins, range=range, density=False)
pdf = (pdf.astype(float) / np.diff(x))
return (pdf, avg(x)) | -9,115,071,158,060,257,000 | The ~ PDF normalized so that
the integral is equal to the
total amount of a quantity.
The integral over a range is the
total amount within that range.
Returns array of size len(bins)-1
Plot versus bins[:-1] | schmidt_funcs.py | pdf2 | johnarban/arban | python | def pdf2(values, bins):
'\n The ~ PDF normalized so that\n the integral is equal to the\n total amount of a quantity.\n The integral over a range is the\n total amount within that range.\n\n Returns array of size len(bins)-1\n Plot versus bins[:-1]\n '
if hasattr(bins, '__getitem__'):
range = (np.nanmin(bins), np.nanmax(bins))
else:
range = None
(pdf, x) = np.histogram(values, bins=bins, range=range, density=False)
pdf = (pdf.astype(float) / np.diff(x))
return (pdf, avg(x)) |
def cdf(values, bins):
'\n (statistical) cumulative distribution function\n Integral on [-inf, b] is the fraction below b.\n CDF is invariant to binning.\n This assumes you are using the entire range in the binning.\n Returns array of size len(bins)\n Plot versus bins[:-1]\n '
if hasattr(bins, '__getitem__'):
range = (np.nanmin(bins), np.nanmax(bins))
else:
range = None
(h, bins) = np.histogram(values, bins=bins, range=range, density=False)
c = np.cumsum((h / np.sum(h, dtype=float)))
return (np.append(0, c), bins) | -1,919,396,916,063,731,500 | (statistical) cumulative distribution function
Integral on [-inf, b] is the fraction below b.
CDF is invariant to binning.
This assumes you are using the entire range in the binning.
Returns array of size len(bins)
Plot versus bins[:-1] | schmidt_funcs.py | cdf | johnarban/arban | python | def cdf(values, bins):
'\n (statistical) cumulative distribution function\n Integral on [-inf, b] is the fraction below b.\n CDF is invariant to binning.\n This assumes you are using the entire range in the binning.\n Returns array of size len(bins)\n Plot versus bins[:-1]\n '
if hasattr(bins, '__getitem__'):
range = (np.nanmin(bins), np.nanmax(bins))
else:
range = None
(h, bins) = np.histogram(values, bins=bins, range=range, density=False)
c = np.cumsum((h / np.sum(h, dtype=float)))
return (np.append(0, c), bins) |
def cdf2(values, bins):
'\n # # Exclusively for area_function which needs to be unnormalized\n (statistical) cumulative distribution function\n Value at b is total amount below b.\n CDF is invariante to binning\n\n Plot versus bins[:-1]\n Not normalized to 1\n '
if hasattr(bins, '__getitem__'):
range = (np.nanmin(bins), np.nanmax(bins))
else:
range = None
(h, bins) = np.histogram(values, bins=bins, range=range, density=False)
c = np.cumsum(h).astype(float)
return (np.append(0.0, c), bins) | -3,582,090,697,934,871,000 | # # Exclusively for area_function which needs to be unnormalized
(statistical) cumulative distribution function
Value at b is total amount below b.
CDF is invariante to binning
Plot versus bins[:-1]
Not normalized to 1 | schmidt_funcs.py | cdf2 | johnarban/arban | python | def cdf2(values, bins):
'\n # # Exclusively for area_function which needs to be unnormalized\n (statistical) cumulative distribution function\n Value at b is total amount below b.\n CDF is invariante to binning\n\n Plot versus bins[:-1]\n Not normalized to 1\n '
if hasattr(bins, '__getitem__'):
range = (np.nanmin(bins), np.nanmax(bins))
else:
range = None
(h, bins) = np.histogram(values, bins=bins, range=range, density=False)
c = np.cumsum(h).astype(float)
return (np.append(0.0, c), bins) |
def area_function(extmap, bins):
'\n Complimentary CDF for cdf2 (not normalized to 1)\n Value at b is total amount above b.\n '
(c, bins) = cdf2(extmap, bins)
return ((c.max() - c), bins) | 2,923,124,846,594,189,300 | Complimentary CDF for cdf2 (not normalized to 1)
Value at b is total amount above b. | schmidt_funcs.py | area_function | johnarban/arban | python | def area_function(extmap, bins):
'\n Complimentary CDF for cdf2 (not normalized to 1)\n Value at b is total amount above b.\n '
(c, bins) = cdf2(extmap, bins)
return ((c.max() - c), bins) |
def diff_area_function(extmap, bins, scale=1):
'\n See pdf2\n '
(s, bins) = area_function(extmap, bins)
dsdx = ((- np.diff(s)) / np.diff(bins))
return ((dsdx * scale), avg(bins)) | -843,582,300,145,384,000 | See pdf2 | schmidt_funcs.py | diff_area_function | johnarban/arban | python | def diff_area_function(extmap, bins, scale=1):
'\n \n '
(s, bins) = area_function(extmap, bins)
dsdx = ((- np.diff(s)) / np.diff(bins))
return ((dsdx * scale), avg(bins)) |
def log_diff_area_function(extmap, bins):
'\n See pdf2\n '
(s, bins) = diff_area_function(extmap, bins)
g = (s > 0)
dlnsdlnx = (np.diff(np.log(s[g])) / np.diff(np.log(bins[g])))
return (dlnsdlnx, avg(bins[g])) | 2,197,432,665,241,749,200 | See pdf2 | schmidt_funcs.py | log_diff_area_function | johnarban/arban | python | def log_diff_area_function(extmap, bins):
'\n \n '
(s, bins) = diff_area_function(extmap, bins)
g = (s > 0)
dlnsdlnx = (np.diff(np.log(s[g])) / np.diff(np.log(bins[g])))
return (dlnsdlnx, avg(bins[g])) |
def mass_function(values, bins, scale=1, aktomassd=183):
'\n M(>Ak), mass weighted complimentary cdf\n '
if hasattr(bins, '__getitem__'):
range = (np.nanmin(bins), np.nanmax(bins))
else:
range = None
(h, bins) = np.histogram(values, bins=bins, range=range, density=False, weights=((values * aktomassd) * scale))
c = np.cumsum(h).astype(float)
return ((c.max() - c), bins) | -7,993,964,941,922,672,000 | M(>Ak), mass weighted complimentary cdf | schmidt_funcs.py | mass_function | johnarban/arban | python | def mass_function(values, bins, scale=1, aktomassd=183):
'\n \n '
if hasattr(bins, '__getitem__'):
range = (np.nanmin(bins), np.nanmax(bins))
else:
range = None
(h, bins) = np.histogram(values, bins=bins, range=range, density=False, weights=((values * aktomassd) * scale))
c = np.cumsum(h).astype(float)
return ((c.max() - c), bins) |
def hist(values, bins, err=False, density=False, **kwargs):
'\n really just a wrapper for numpy.histogram\n '
if hasattr(bins, '__getitem__'):
range = (np.nanmin(bins), np.nanmax(bins))
else:
range = None
(hist, x) = np.histogram(values, bins=bins, range=range, density=density, **kwargs)
if ((err is None) or (err is False)):
return (hist.astype(np.float), avg(x))
else:
return (hist.astype(np.float), avg(x), np.sqrt(hist)) | -5,347,693,388,444,016,000 | really just a wrapper for numpy.histogram | schmidt_funcs.py | hist | johnarban/arban | python | def hist(values, bins, err=False, density=False, **kwargs):
'\n \n '
if hasattr(bins, '__getitem__'):
range = (np.nanmin(bins), np.nanmax(bins))
else:
range = None
(hist, x) = np.histogram(values, bins=bins, range=range, density=density, **kwargs)
if ((err is None) or (err is False)):
return (hist.astype(np.float), avg(x))
else:
return (hist.astype(np.float), avg(x), np.sqrt(hist)) |
def bootstrap(X, X_err=None, n=None, smooth=False):
'\n (smooth) bootstrap\n bootstrap(X,Xerr,n,smooth=True)\n X : array to be resampled\n X_err [optional]: errors to perturb data for smooth bootstrap\n only provide is doing smooth bootstrapping\n n : number of samples. Default - len(X)\n smooth: optionally use smooth bootstrapping.\n will be set to False if no X_err is provided\n '
if (X_err is None):
smooth = False
if (n is None):
n = len(X)
resample_i = np.random.randint(0, len(X), size=(n,))
X_resample = np.asarray(X)[resample_i]
if smooth:
X_resample = np.random.normal(X_resample, np.asarray(X_err)[resample_i])
return X_resample | -7,011,435,233,662,548,000 | (smooth) bootstrap
bootstrap(X,Xerr,n,smooth=True)
X : array to be resampled
X_err [optional]: errors to perturb data for smooth bootstrap
only provide is doing smooth bootstrapping
n : number of samples. Default - len(X)
smooth: optionally use smooth bootstrapping.
will be set to False if no X_err is provided | schmidt_funcs.py | bootstrap | johnarban/arban | python | def bootstrap(X, X_err=None, n=None, smooth=False):
'\n (smooth) bootstrap\n bootstrap(X,Xerr,n,smooth=True)\n X : array to be resampled\n X_err [optional]: errors to perturb data for smooth bootstrap\n only provide is doing smooth bootstrapping\n n : number of samples. Default - len(X)\n smooth: optionally use smooth bootstrapping.\n will be set to False if no X_err is provided\n '
if (X_err is None):
smooth = False
if (n is None):
n = len(X)
resample_i = np.random.randint(0, len(X), size=(n,))
X_resample = np.asarray(X)[resample_i]
if smooth:
X_resample = np.random.normal(X_resample, np.asarray(X_err)[resample_i])
return X_resample |
def alpha_ML(data, xmin, xmax):
'\n uses maximum likelihood to estimation\n to determine power-law and error\n From Clauset et al. 2010\n '
data = data[np.isfinite(data)]
data = data[((data >= xmin) & (data <= xmax))]
alpha = (1 + (len(data) * (np.sum(np.log((data / xmin))) ** (- 1))))
error = ((alpha - 1) / np.sqrt(len(data)))
N = len(data)
loglike = (((N * np.log((alpha - 1))) - (N * np.log(xmin))) - (alpha * np.sum(np.log((data / xmin)))))
return (alpha, error, loglike, xmin, xmax) | -285,406,338,309,995,040 | uses maximum likelihood to estimation
to determine power-law and error
From Clauset et al. 2010 | schmidt_funcs.py | alpha_ML | johnarban/arban | python | def alpha_ML(data, xmin, xmax):
'\n uses maximum likelihood to estimation\n to determine power-law and error\n From Clauset et al. 2010\n '
data = data[np.isfinite(data)]
data = data[((data >= xmin) & (data <= xmax))]
alpha = (1 + (len(data) * (np.sum(np.log((data / xmin))) ** (- 1))))
error = ((alpha - 1) / np.sqrt(len(data)))
N = len(data)
loglike = (((N * np.log((alpha - 1))) - (N * np.log(xmin))) - (alpha * np.sum(np.log((data / xmin)))))
return (alpha, error, loglike, xmin, xmax) |
def surfd(X, Xmap, bins, Xerr=None, Xmaperr=None, boot=False, scale=1.0, return_err=False, smooth=False):
'\n call: surfd(X, map, bins,\n xerr = None, merr = None, scale = 1.)\n calculates H(X)/H(M) = Nx pdf(x) dx / Nm pdf(m) dm ; dm = dx\n so it is independent of whether dx or dlog(x)\n '
if boot:
n = np.histogram(bootstrap(X, Xerr, smooth=True), bins=bins, range=(bins.min(), bins.max()))[0]
s = (np.histogram(bootstrap(Xmap, Xmaperr, smooth=True), bins=bins, range=(bins.min(), bins.max()))[0] * scale)
else:
n = np.histogram(X, bins=bins, range=(bins.min(), bins.max()))[0]
s = (np.histogram(Xmap, bins=bins, range=(bins.min(), bins.max()))[0] * scale)
if (not return_err):
return (n / s)
else:
return ((n / s), ((n / s) * np.sqrt(((1.0 / n) - (scale / s))))) | 8,136,631,929,769,016,000 | call: surfd(X, map, bins,
xerr = None, merr = None, scale = 1.)
calculates H(X)/H(M) = Nx pdf(x) dx / Nm pdf(m) dm ; dm = dx
so it is independent of whether dx or dlog(x) | schmidt_funcs.py | surfd | johnarban/arban | python | def surfd(X, Xmap, bins, Xerr=None, Xmaperr=None, boot=False, scale=1.0, return_err=False, smooth=False):
'\n call: surfd(X, map, bins,\n xerr = None, merr = None, scale = 1.)\n calculates H(X)/H(M) = Nx pdf(x) dx / Nm pdf(m) dm ; dm = dx\n so it is independent of whether dx or dlog(x)\n '
if boot:
n = np.histogram(bootstrap(X, Xerr, smooth=True), bins=bins, range=(bins.min(), bins.max()))[0]
s = (np.histogram(bootstrap(Xmap, Xmaperr, smooth=True), bins=bins, range=(bins.min(), bins.max()))[0] * scale)
else:
n = np.histogram(X, bins=bins, range=(bins.min(), bins.max()))[0]
s = (np.histogram(Xmap, bins=bins, range=(bins.min(), bins.max()))[0] * scale)
if (not return_err):
return (n / s)
else:
return ((n / s), ((n / s) * np.sqrt(((1.0 / n) - (scale / s))))) |
def alpha(y, x, err=None, return_kappa=False, cov=False):
'\n this returns -1*alpha, and optionally kappa and errors\n '
a1 = set(np.nonzero(np.multiply(x, y))[0])
a2 = set(np.where(np.isfinite(np.add(x, y, err)))[0])
a = np.asarray(list((a1 & a2)))
y = np.log(y[a])
x = np.log(x[a])
if (err is None):
(p, covar) = np.polyfit(x, y, 1, cov=True)
(m, b) = p
(me, be) = np.sqrt(np.sum((covar * [[1, 0], [0, 1]]), axis=1))
(me, be)
else:
err = err[a]
err = (err / y)
(p, covar) = np.polyfit(x, y, 1, w=(1.0 / (err ** 2)), cov=True)
(m, b) = p
(me, be) = np.sqrt(np.sum((covar * [[1, 0], [0, 1]]), axis=1))
(me, be)
if return_kappa:
if cov:
return (m, np.exp(b), me, be)
else:
return (m, np.exp(b))
elif cov:
return (m, me)
else:
return m | 732,717,894,788,148,200 | this returns -1*alpha, and optionally kappa and errors | schmidt_funcs.py | alpha | johnarban/arban | python | def alpha(y, x, err=None, return_kappa=False, cov=False):
'\n \n '
a1 = set(np.nonzero(np.multiply(x, y))[0])
a2 = set(np.where(np.isfinite(np.add(x, y, err)))[0])
a = np.asarray(list((a1 & a2)))
y = np.log(y[a])
x = np.log(x[a])
if (err is None):
(p, covar) = np.polyfit(x, y, 1, cov=True)
(m, b) = p
(me, be) = np.sqrt(np.sum((covar * [[1, 0], [0, 1]]), axis=1))
(me, be)
else:
err = err[a]
err = (err / y)
(p, covar) = np.polyfit(x, y, 1, w=(1.0 / (err ** 2)), cov=True)
(m, b) = p
(me, be) = np.sqrt(np.sum((covar * [[1, 0], [0, 1]]), axis=1))
(me, be)
if return_kappa:
if cov:
return (m, np.exp(b), me, be)
else:
return (m, np.exp(b))
elif cov:
return (m, me)
else:
return m |
def schmidt_law(Ak, theta):
'\n schmidt_law(Ak,(beta,kappa))\n beta is the power law index (same as alpha)\n '
if (len(theta) == 2):
(beta, kappa) = theta
return (kappa * (Ak ** beta))
elif (len(theta) == 3):
(beta, kappa, Ak0) = theta
sfr = ((Heaviside((Ak - Ak0)) * kappa) * (Ak ** beta))
sfr[(Ak < Ak0)] = 0
return sfr | 6,937,067,721,059,908,000 | schmidt_law(Ak,(beta,kappa))
beta is the power law index (same as alpha) | schmidt_funcs.py | schmidt_law | johnarban/arban | python | def schmidt_law(Ak, theta):
'\n schmidt_law(Ak,(beta,kappa))\n beta is the power law index (same as alpha)\n '
if (len(theta) == 2):
(beta, kappa) = theta
return (kappa * (Ak ** beta))
elif (len(theta) == 3):
(beta, kappa, Ak0) = theta
sfr = ((Heaviside((Ak - Ak0)) * kappa) * (Ak ** beta))
sfr[(Ak < Ak0)] = 0
return sfr |
def emcee_schmidt(x, y, yerr, pos=None, pose=None, nwalkers=None, nsteps=None, burnin=200, verbose=True):
'\n emcee_schmidt provides a convenient wrapper for fitting the schimdt law\n to binned x,log(y) data. Generally, it fits a normalization and a slope\n '
def model(x, theta):
'\n theta = (beta, kappa)\n '
return np.log(schmidt_law(x, theta))
def lnlike(theta, x, y, yerr):
mod = model(x, theta)
inv_sigma2 = (1 / (yerr ** 2))
return ((- 0.5) * np.sum((((y - mod) ** 2) * inv_sigma2)))
def lnprior(theta):
if (len(theta) == 3):
(beta, kappa, Ak0) = theta
c3 = (0.0 < Ak0 <= 5.0)
c4 = True
else:
(beta, kappa) = theta
c3 = True
c4 = True
c1 = (0 <= beta <= 6)
c2 = (0 <= kappa)
if (c1 and c2 and c3 and c4):
return 0.0
return (- np.inf)
def lnprob(theta, x, y, yerr):
lp = lnprior(theta)
if (not np.isfinite(lp)):
return (- np.inf)
return (lp + lnlike(theta, x, y, yerr))
(ndim, nwalkers) = (len(pos), nwalkers)
pos = [(np.array(pos) + ((np.array(pose) * 0.5) * (0.5 - np.random.rand(ndim)))) for i in range(nwalkers)]
sampler = emcee.EnsembleSampler(nwalkers, ndim, lnprob, args=(x, y, yerr))
sampler.run_mcmc(pos, nsteps)
samples = sampler.chain[:, burnin:, :].reshape(((- 1), sampler.ndim))
theta_mcmc = np.percentile(samples, [16, 50, 84], axis=0).T
if verbose:
print(sampler.acor)
if verbose:
for (i, item) in enumerate(theta_mcmc):
j = ['beta', 'kappa', 'A_{K,0}', 'A_{K,f}']
inserts = (j[i], item[1], (item[2] - item[1]), (item[1] - item[0]))
print(('%s = %0.2f (+%0.2f,-%0.2f)' % inserts))
return (sampler, np.median(samples, axis=0), np.std(samples, axis=0)) | 3,047,723,245,439,450,000 | emcee_schmidt provides a convenient wrapper for fitting the schimdt law
to binned x,log(y) data. Generally, it fits a normalization and a slope | schmidt_funcs.py | emcee_schmidt | johnarban/arban | python | def emcee_schmidt(x, y, yerr, pos=None, pose=None, nwalkers=None, nsteps=None, burnin=200, verbose=True):
'\n emcee_schmidt provides a convenient wrapper for fitting the schimdt law\n to binned x,log(y) data. Generally, it fits a normalization and a slope\n '
def model(x, theta):
'\n theta = (beta, kappa)\n '
return np.log(schmidt_law(x, theta))
def lnlike(theta, x, y, yerr):
mod = model(x, theta)
inv_sigma2 = (1 / (yerr ** 2))
return ((- 0.5) * np.sum((((y - mod) ** 2) * inv_sigma2)))
def lnprior(theta):
if (len(theta) == 3):
(beta, kappa, Ak0) = theta
c3 = (0.0 < Ak0 <= 5.0)
c4 = True
else:
(beta, kappa) = theta
c3 = True
c4 = True
c1 = (0 <= beta <= 6)
c2 = (0 <= kappa)
if (c1 and c2 and c3 and c4):
return 0.0
return (- np.inf)
def lnprob(theta, x, y, yerr):
lp = lnprior(theta)
if (not np.isfinite(lp)):
return (- np.inf)
return (lp + lnlike(theta, x, y, yerr))
(ndim, nwalkers) = (len(pos), nwalkers)
pos = [(np.array(pos) + ((np.array(pose) * 0.5) * (0.5 - np.random.rand(ndim)))) for i in range(nwalkers)]
sampler = emcee.EnsembleSampler(nwalkers, ndim, lnprob, args=(x, y, yerr))
sampler.run_mcmc(pos, nsteps)
samples = sampler.chain[:, burnin:, :].reshape(((- 1), sampler.ndim))
theta_mcmc = np.percentile(samples, [16, 50, 84], axis=0).T
if verbose:
print(sampler.acor)
if verbose:
for (i, item) in enumerate(theta_mcmc):
j = ['beta', 'kappa', 'A_{K,0}', 'A_{K,f}']
inserts = (j[i], item[1], (item[2] - item[1]), (item[1] - item[0]))
print(('%s = %0.2f (+%0.2f,-%0.2f)' % inserts))
return (sampler, np.median(samples, axis=0), np.std(samples, axis=0)) |
def fit(bins, samp, samperr, maps, mapserr, scale=1.0, sampler=None, log=False, pos=None, pose=None, nwalkers=100, nsteps=10000.0, boot=1000, burnin=200, threshold=False, threshold2=False, verbose=True):
"\n # # # A Schmidt Law fitting Function using EMCEE by D.F.M.\n fit(bins, samp, samperr, maps, mapserr, scale=1.,\n pos=None, pose=None, nwalkers=100, nsteps=1e4)\n bins: bin edges for binning data (I know it's bad to bin)\n samp : values for your sample\n samperr : errors on values for you sample\n maps: map of values from which you drew your sample\n mapserr: error on maps...\n pos : initial location of ball of walkers\n pose : initial spread of walkers\n "
x = avg(bins)
(y, yerr) = surfd(samp, maps, bins, scale=scale, return_err=True)
bins2 = shift_bins(bins, 0.5)
bin
x2 = avg(bins2)
(y2, yerr2) = surfd(samp, maps, bins2, scale=scale, return_err=True)
concatx = np.concatenate((x, x2))
concaty = np.concatenate((y, y2))
concatyerr = np.concatenate((yerr, yerr2))
srt = np.argsort(concatx)
x = concatx[srt]
y = concaty[srt]
yerr = concatyerr[srt]
nonzero = ((np.isfinite((1.0 / y)) & np.isfinite(yerr)) & np.isfinite((1.0 / yerr)))
y = y[nonzero]
yerr = yerr[nonzero]
x = x[nonzero]
init = alpha(y, x, return_kappa=True, cov=True)
if (pos is None):
pos = init[:2]
if (pose is None):
if np.isnan((init[2] + init[3])):
pose = (1, 1)
else:
pose = (init[2], init[3])
if (threshold | threshold2):
pos = (pos + (0.4,))
pose = (pose + (0.2,))
if threshold2:
pos = (pos + (8.0,))
pose = (pose + (0.5,))
pos = np.asarray(pos)
pose = (0.1 * pos)
if (sampler is None):
if verbose:
print('Sampler autocorrelation times . . .')
(sampler, theta, theta_std) = emcee_schmidt(x, np.log(y), (yerr / y), pos=pos, pose=pose, nwalkers=nwalkers, nsteps=nsteps, burnin=burnin, verbose=verbose)
else:
print((("Next time don't give me a " + str(type(sampler))) + '.'))
try:
return (sampler, x, y, yerr, theta, theta_std)
except:
return (sampler, x, y, yerr) | 1,029,633,922,976,774,800 | # # # A Schmidt Law fitting Function using EMCEE by D.F.M.
fit(bins, samp, samperr, maps, mapserr, scale=1.,
pos=None, pose=None, nwalkers=100, nsteps=1e4)
bins: bin edges for binning data (I know it's bad to bin)
samp : values for your sample
samperr : errors on values for you sample
maps: map of values from which you drew your sample
mapserr: error on maps...
pos : initial location of ball of walkers
pose : initial spread of walkers | schmidt_funcs.py | fit | johnarban/arban | python | def fit(bins, samp, samperr, maps, mapserr, scale=1.0, sampler=None, log=False, pos=None, pose=None, nwalkers=100, nsteps=10000.0, boot=1000, burnin=200, threshold=False, threshold2=False, verbose=True):
"\n # # # A Schmidt Law fitting Function using EMCEE by D.F.M.\n fit(bins, samp, samperr, maps, mapserr, scale=1.,\n pos=None, pose=None, nwalkers=100, nsteps=1e4)\n bins: bin edges for binning data (I know it's bad to bin)\n samp : values for your sample\n samperr : errors on values for you sample\n maps: map of values from which you drew your sample\n mapserr: error on maps...\n pos : initial location of ball of walkers\n pose : initial spread of walkers\n "
x = avg(bins)
(y, yerr) = surfd(samp, maps, bins, scale=scale, return_err=True)
bins2 = shift_bins(bins, 0.5)
bin
x2 = avg(bins2)
(y2, yerr2) = surfd(samp, maps, bins2, scale=scale, return_err=True)
concatx = np.concatenate((x, x2))
concaty = np.concatenate((y, y2))
concatyerr = np.concatenate((yerr, yerr2))
srt = np.argsort(concatx)
x = concatx[srt]
y = concaty[srt]
yerr = concatyerr[srt]
nonzero = ((np.isfinite((1.0 / y)) & np.isfinite(yerr)) & np.isfinite((1.0 / yerr)))
y = y[nonzero]
yerr = yerr[nonzero]
x = x[nonzero]
init = alpha(y, x, return_kappa=True, cov=True)
if (pos is None):
pos = init[:2]
if (pose is None):
if np.isnan((init[2] + init[3])):
pose = (1, 1)
else:
pose = (init[2], init[3])
if (threshold | threshold2):
pos = (pos + (0.4,))
pose = (pose + (0.2,))
if threshold2:
pos = (pos + (8.0,))
pose = (pose + (0.5,))
pos = np.asarray(pos)
pose = (0.1 * pos)
if (sampler is None):
if verbose:
print('Sampler autocorrelation times . . .')
(sampler, theta, theta_std) = emcee_schmidt(x, np.log(y), (yerr / y), pos=pos, pose=pose, nwalkers=nwalkers, nsteps=nsteps, burnin=burnin, verbose=verbose)
else:
print((("Next time don't give me a " + str(type(sampler))) + '.'))
try:
return (sampler, x, y, yerr, theta, theta_std)
except:
return (sampler, x, y, yerr) |
def schmidt_results_plots(sampler, model, x, y, yerr, burnin=200, akmap=None, bins=None, scale=None, triangle_plot=True):
'\n model: should pass schmidt_law()\n '
try:
mpl.style.use('john')
except:
None
if hasattr(sampler, '__getitem__'):
chain = sampler
dim = chain.shape[(- 1)]
else:
chain = sampler.chain
dim = sampler.dim
samples = chain[:, burnin:, :].reshape(((- 1), dim))
theta_mcmc = np.percentile(samples, [16, 50, 84], axis=0).T
n_params = len(theta_mcmc[:, 1])
for (i, item) in enumerate(theta_mcmc):
j = ['beta', 'kappa', 'A_{K,0}', 'A_{K,f}']
inserts = (j[i], item[1], (item[2] - item[1]), (item[1] - item[0]))
print(('%s = %0.2f (+%0.2f,-%0.2f)' % inserts))
if triangle_plot:
if (n_params == 3):
labels = ['beta', 'kappa', 'A_{K,0}']
elif (n_params == 4):
labels = ['beta', 'kappa', 'A_{K,0}', 'A_{K,f}']
else:
labels = ['beta', 'kappa']
_ = triangle.corner(samples, labels=labels, truths=theta_mcmc[:, 1], quantiles=[0.16, 0.84], verbose=False)
xln = np.logspace(np.log10((x.min() * 0.5)), np.log10((x.max() * 2.0)), 100)
smlaw_samps = np.asarray([schmidt_law(xln, samp) for samp in samples])
percent = (lambda x: np.nanpercentile(smlaw_samps, x, interpolation='linear', axis=0))
fig = plt.figure()
plt.plot(xln, percent(50), 'k')
plt.errorbar(x, y, yerr, fmt='rs', alpha=0.7, mec='none')
plt.legend(['Median', 'Data'], loc='upper left', fontsize=12)
plt.fill_between(xln, percent(1), percent(99), color='0.9')
plt.fill_between(xln, percent(2), percent(98), color='0.75')
plt.fill_between(xln, percent(16), percent(84), color='0.5')
plt.loglog(nonposy='clip')
return plt.gca() | -3,195,698,405,562,711,600 | model: should pass schmidt_law() | schmidt_funcs.py | schmidt_results_plots | johnarban/arban | python | def schmidt_results_plots(sampler, model, x, y, yerr, burnin=200, akmap=None, bins=None, scale=None, triangle_plot=True):
'\n \n '
try:
mpl.style.use('john')
except:
None
if hasattr(sampler, '__getitem__'):
chain = sampler
dim = chain.shape[(- 1)]
else:
chain = sampler.chain
dim = sampler.dim
samples = chain[:, burnin:, :].reshape(((- 1), dim))
theta_mcmc = np.percentile(samples, [16, 50, 84], axis=0).T
n_params = len(theta_mcmc[:, 1])
for (i, item) in enumerate(theta_mcmc):
j = ['beta', 'kappa', 'A_{K,0}', 'A_{K,f}']
inserts = (j[i], item[1], (item[2] - item[1]), (item[1] - item[0]))
print(('%s = %0.2f (+%0.2f,-%0.2f)' % inserts))
if triangle_plot:
if (n_params == 3):
labels = ['beta', 'kappa', 'A_{K,0}']
elif (n_params == 4):
labels = ['beta', 'kappa', 'A_{K,0}', 'A_{K,f}']
else:
labels = ['beta', 'kappa']
_ = triangle.corner(samples, labels=labels, truths=theta_mcmc[:, 1], quantiles=[0.16, 0.84], verbose=False)
xln = np.logspace(np.log10((x.min() * 0.5)), np.log10((x.max() * 2.0)), 100)
smlaw_samps = np.asarray([schmidt_law(xln, samp) for samp in samples])
percent = (lambda x: np.nanpercentile(smlaw_samps, x, interpolation='linear', axis=0))
fig = plt.figure()
plt.plot(xln, percent(50), 'k')
plt.errorbar(x, y, yerr, fmt='rs', alpha=0.7, mec='none')
plt.legend(['Median', 'Data'], loc='upper left', fontsize=12)
plt.fill_between(xln, percent(1), percent(99), color='0.9')
plt.fill_between(xln, percent(2), percent(98), color='0.75')
plt.fill_between(xln, percent(16), percent(84), color='0.5')
plt.loglog(nonposy='clip')
return plt.gca() |
def plot_walkers(sampler, limits=None, bad=None):
'\n sampler : emcee Sampler class\n '
if hasattr(sampler, '__getitem__'):
chain = sampler
ndim = chain.shape[(- 1)]
else:
chain = sampler.chain
ndim = sampler.ndim
fig = plt.figure(figsize=((8 * ndim), (4 * ndim)))
if hasattr(limits, '__getitem__'):
limits += ([None] * (3 - len(limits)))
slices = slice(limits[0], limits[1], limits[2])
else:
slices = slice(None, limits, None)
for (w, walk) in enumerate(chain[:, slices, :]):
if (bad is None):
color = 'k'
elif bad[w]:
color = 'r'
else:
color = 'k'
for (p, param) in enumerate(walk.T):
ax = plt.subplot(ndim, 1, (p + 1))
ax.plot(param, color, alpha=0.75, lw=0.75)
plt.tight_layout()
return fig | -7,042,728,002,737,024,000 | sampler : emcee Sampler class | schmidt_funcs.py | plot_walkers | johnarban/arban | python | def plot_walkers(sampler, limits=None, bad=None):
'\n \n '
if hasattr(sampler, '__getitem__'):
chain = sampler
ndim = chain.shape[(- 1)]
else:
chain = sampler.chain
ndim = sampler.ndim
fig = plt.figure(figsize=((8 * ndim), (4 * ndim)))
if hasattr(limits, '__getitem__'):
limits += ([None] * (3 - len(limits)))
slices = slice(limits[0], limits[1], limits[2])
else:
slices = slice(None, limits, None)
for (w, walk) in enumerate(chain[:, slices, :]):
if (bad is None):
color = 'k'
elif bad[w]:
color = 'r'
else:
color = 'k'
for (p, param) in enumerate(walk.T):
ax = plt.subplot(ndim, 1, (p + 1))
ax.plot(param, color, alpha=0.75, lw=0.75)
plt.tight_layout()
return fig |
def model(x, theta):
'\n theta = (beta, kappa)\n '
return np.log(schmidt_law(x, theta)) | -4,696,528,238,367,610,000 | theta = (beta, kappa) | schmidt_funcs.py | model | johnarban/arban | python | def model(x, theta):
'\n \n '
return np.log(schmidt_law(x, theta)) |
def __init__(self):
'Initialize vocab dictionaries.'
self._words = []
self._counts = []
self._total_count = 0 | -7,167,729,922,947,978,000 | Initialize vocab dictionaries. | word2vec/estimators/word2vec.py | __init__ | akb89/word2vec | python | def __init__(self):
self._words = []
self._counts = []
self._total_count = 0 |
@property
def vocab_size(self):
'Return the number of items in vocabulary.\n\n Since we use len(word_freq_dict) as the default index for UKN in\n the index_table, we have to add 1 to the length\n '
return (len(self._words) + 1) | -396,653,238,297,316,860 | Return the number of items in vocabulary.
Since we use len(word_freq_dict) as the default index for UKN in
the index_table, we have to add 1 to the length | word2vec/estimators/word2vec.py | vocab_size | akb89/word2vec | python | @property
def vocab_size(self):
'Return the number of items in vocabulary.\n\n Since we use len(word_freq_dict) as the default index for UKN in\n the index_table, we have to add 1 to the length\n '
return (len(self._words) + 1) |
def build_vocab(self, data_filepath, vocab_filepath, min_count):
'Create vocabulary-related data.'
logger.info('Building vocabulary from file {}'.format(data_filepath))
logger.info('Loading word counts...')
if (self.vocab_size > 1):
logger.warning("This instance of W2V's vocabulary does not seem to be empty. Erasing previously stored vocab...")
(self._words, self._counts, self._total_count) = ([], [], 0)
word_count_dict = defaultdict(int)
with open(data_filepath, 'r') as data_stream:
for line in data_stream:
for word in line.strip().split():
word_count_dict[word] += 1
logger.info('Saving word frequencies to file: {}'.format(vocab_filepath))
with open(vocab_filepath, 'w') as vocab_stream:
for (word, count) in sorted(word_count_dict.items(), key=(lambda x: x[1]), reverse=True):
print('{}\t{}'.format(word, count), file=vocab_stream)
if (count >= min_count):
self._words.append(word)
self._counts.append(count)
self._total_count += count | -3,329,502,410,839,565,300 | Create vocabulary-related data. | word2vec/estimators/word2vec.py | build_vocab | akb89/word2vec | python | def build_vocab(self, data_filepath, vocab_filepath, min_count):
logger.info('Building vocabulary from file {}'.format(data_filepath))
logger.info('Loading word counts...')
if (self.vocab_size > 1):
logger.warning("This instance of W2V's vocabulary does not seem to be empty. Erasing previously stored vocab...")
(self._words, self._counts, self._total_count) = ([], [], 0)
word_count_dict = defaultdict(int)
with open(data_filepath, 'r') as data_stream:
for line in data_stream:
for word in line.strip().split():
word_count_dict[word] += 1
logger.info('Saving word frequencies to file: {}'.format(vocab_filepath))
with open(vocab_filepath, 'w') as vocab_stream:
for (word, count) in sorted(word_count_dict.items(), key=(lambda x: x[1]), reverse=True):
print('{}\t{}'.format(word, count), file=vocab_stream)
if (count >= min_count):
self._words.append(word)
self._counts.append(count)
self._total_count += count |
def load_vocab(self, vocab_filepath, min_count):
'Load a previously saved vocabulary file.'
logger.info('Loading word counts from file {}'.format(vocab_filepath))
(self._words, self._counts, self._total_count) = ([], [], 0)
with open(vocab_filepath, 'r', encoding='UTF-8') as vocab_stream:
for line in vocab_stream:
word_count = line.strip().split('\t', 1)
(word, count) = (word_count[0], int(word_count[1]))
if (count >= min_count):
self._words.append(word)
self._counts.append(count)
self._total_count += count
logger.info('Done loading word counts') | -8,126,846,170,437,619,000 | Load a previously saved vocabulary file. | word2vec/estimators/word2vec.py | load_vocab | akb89/word2vec | python | def load_vocab(self, vocab_filepath, min_count):
logger.info('Loading word counts from file {}'.format(vocab_filepath))
(self._words, self._counts, self._total_count) = ([], [], 0)
with open(vocab_filepath, 'r', encoding='UTF-8') as vocab_stream:
for line in vocab_stream:
word_count = line.strip().split('\t', 1)
(word, count) = (word_count[0], int(word_count[1]))
if (count >= min_count):
self._words.append(word)
self._counts.append(count)
self._total_count += count
logger.info('Done loading word counts') |
def train(self, train_mode, training_data_filepath, model_dirpath, batch_size, embedding_size, num_neg_samples, learning_rate, window_size, num_epochs, sampling_rate, p_num_threads, t_num_threads, shuffling_buffer_size, save_summary_steps, save_checkpoints_steps, keep_checkpoint_max, log_step_count_steps, debug, debug_port, xla):
'Train Word2Vec.'
if (self.vocab_size == 1):
raise Exception('You need to build or load a vocabulary before training word2vec')
if (train_mode not in ('cbow', 'skipgram')):
raise Exception("Unsupported train_mode '{}'".format(train_mode))
sess_config = tf.compat.v1.ConfigProto(log_device_placement=True)
sess_config.intra_op_parallelism_threads = t_num_threads
sess_config.inter_op_parallelism_threads = t_num_threads
run_config = tf.estimator.RunConfig(session_config=sess_config, save_summary_steps=save_summary_steps, save_checkpoints_steps=save_checkpoints_steps, keep_checkpoint_max=keep_checkpoint_max, log_step_count_steps=log_step_count_steps)
estimator = tf.estimator.Estimator(model_fn=w2v_model.model, model_dir=model_dirpath, config=run_config, params={'mode': train_mode, 'vocab_size': self.vocab_size, 'batch_size': batch_size, 'embedding_size': embedding_size, 'num_neg_samples': num_neg_samples, 'learning_rate': learning_rate, 'words': self._words, 'p_num_threads': p_num_threads, 'xla': xla, 'men': MEN(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'resources', 'MEN_dataset_natural_form_full'))})
tf.compat.v1.disable_eager_execution()
if debug:
raise Exception('Unsupported parameter: waiting for the TF team to release v2 equivalents for TensorBoardDebugHook')
hooks = [tf.estimator.ProfilerHook(save_steps=save_summary_steps, show_dataflow=True, show_memory=True, output_dir=model_dirpath)]
estimator.train(input_fn=(lambda : datasets_utils.get_w2v_train_dataset(training_data_filepath, train_mode, self._words, self._counts, self._total_count, window_size, sampling_rate, batch_size, num_epochs, p_num_threads, shuffling_buffer_size)), hooks=hooks) | -3,904,962,833,964,570,600 | Train Word2Vec. | word2vec/estimators/word2vec.py | train | akb89/word2vec | python | def train(self, train_mode, training_data_filepath, model_dirpath, batch_size, embedding_size, num_neg_samples, learning_rate, window_size, num_epochs, sampling_rate, p_num_threads, t_num_threads, shuffling_buffer_size, save_summary_steps, save_checkpoints_steps, keep_checkpoint_max, log_step_count_steps, debug, debug_port, xla):
if (self.vocab_size == 1):
raise Exception('You need to build or load a vocabulary before training word2vec')
if (train_mode not in ('cbow', 'skipgram')):
raise Exception("Unsupported train_mode '{}'".format(train_mode))
sess_config = tf.compat.v1.ConfigProto(log_device_placement=True)
sess_config.intra_op_parallelism_threads = t_num_threads
sess_config.inter_op_parallelism_threads = t_num_threads
run_config = tf.estimator.RunConfig(session_config=sess_config, save_summary_steps=save_summary_steps, save_checkpoints_steps=save_checkpoints_steps, keep_checkpoint_max=keep_checkpoint_max, log_step_count_steps=log_step_count_steps)
estimator = tf.estimator.Estimator(model_fn=w2v_model.model, model_dir=model_dirpath, config=run_config, params={'mode': train_mode, 'vocab_size': self.vocab_size, 'batch_size': batch_size, 'embedding_size': embedding_size, 'num_neg_samples': num_neg_samples, 'learning_rate': learning_rate, 'words': self._words, 'p_num_threads': p_num_threads, 'xla': xla, 'men': MEN(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'resources', 'MEN_dataset_natural_form_full'))})
tf.compat.v1.disable_eager_execution()
if debug:
raise Exception('Unsupported parameter: waiting for the TF team to release v2 equivalents for TensorBoardDebugHook')
hooks = [tf.estimator.ProfilerHook(save_steps=save_summary_steps, show_dataflow=True, show_memory=True, output_dir=model_dirpath)]
estimator.train(input_fn=(lambda : datasets_utils.get_w2v_train_dataset(training_data_filepath, train_mode, self._words, self._counts, self._total_count, window_size, sampling_rate, batch_size, num_epochs, p_num_threads, shuffling_buffer_size)), hooks=hooks) |
def get_cocktail_irradiation(self):
'\n example cocktail.json\n\n {\n "chronology": "2016-06-01 17:00:00",\n "j": 4e-4,\n "j_err": 4e-9\n }\n\n :return:\n '
p = os.path.join(paths.meta_root, 'cocktail.json')
ret = dvc_load(p)
nret = {}
if ret:
lines = ['1.0, {}, {}'.format(ret['chronology'], ret['chronology'])]
c = Chronology.from_lines(lines)
nret['chronology'] = c
nret['flux'] = ufloat(ret['j'], ret['j_err'])
return nret | -2,350,478,959,779,339,000 | example cocktail.json
{
"chronology": "2016-06-01 17:00:00",
"j": 4e-4,
"j_err": 4e-9
}
:return: | pychron/dvc/meta_repo.py | get_cocktail_irradiation | UManPychron/pychron | python | def get_cocktail_irradiation(self):
'\n example cocktail.json\n\n {\n "chronology": "2016-06-01 17:00:00",\n "j": 4e-4,\n "j_err": 4e-9\n }\n\n :return:\n '
p = os.path.join(paths.meta_root, 'cocktail.json')
ret = dvc_load(p)
nret = {}
if ret:
lines = ['1.0, {}, {}'.format(ret['chronology'], ret['chronology'])]
c = Chronology.from_lines(lines)
nret['chronology'] = c
nret['flux'] = ufloat(ret['j'], ret['j_err'])
return nret |
def test_column_generation_dtalite():
' validation using DTALite '
print('start column generation using DTALite')
st = time()
mode = 1
iter_num = 20
column_update_num = 20
pg.perform_network_assignment_DTALite(mode, iter_num, column_update_num)
print(f'processing time of column generation: {(time() - st):.2f} s for {iter_num} assignment iterations and {column_update_num} iterations in column generation')
print('\npath finding results can be found in agent.csv') | -1,906,266,710,231,534,000 | validation using DTALite | tests/demo.py | test_column_generation_dtalite | FangTang999/Path4GMNS | python | def test_column_generation_dtalite():
' '
print('start column generation using DTALite')
st = time()
mode = 1
iter_num = 20
column_update_num = 20
pg.perform_network_assignment_DTALite(mode, iter_num, column_update_num)
print(f'processing time of column generation: {(time() - st):.2f} s for {iter_num} assignment iterations and {column_update_num} iterations in column generation')
print('\npath finding results can be found in agent.csv') |
def api_request(self, method_name, params):
' Make api request and return single wrapped object\n\n :param method_name: name of API methods\n :param params: dict-wrapped params for specific API call\n '
data = self.client.api_request(method_name, params)
if (isinstance(data, dict) and (len(data) > 1)):
for x in data.keys():
data[x] = self._get_return_object_type(data.get(x))
return data
class_name = to_snake(self.__class__.__name__.replace('Broker', ''))
if (class_name in data):
result_name = class_name
else:
result_name = method_name.split('/')[(- 1)]
if (result_name not in data):
return data
return self._get_return_object_type(data.get(result_name)) | -6,943,514,198,024,048,000 | Make api request and return single wrapped object
:param method_name: name of API methods
:param params: dict-wrapped params for specific API call | infoblox_netmri/api/broker/broker.py | api_request | IngmarVG-IB/infoblox-netmri | python | def api_request(self, method_name, params):
' Make api request and return single wrapped object\n\n :param method_name: name of API methods\n :param params: dict-wrapped params for specific API call\n '
data = self.client.api_request(method_name, params)
if (isinstance(data, dict) and (len(data) > 1)):
for x in data.keys():
data[x] = self._get_return_object_type(data.get(x))
return data
class_name = to_snake(self.__class__.__name__.replace('Broker', ))
if (class_name in data):
result_name = class_name
else:
result_name = method_name.split('/')[(- 1)]
if (result_name not in data):
return data
return self._get_return_object_type(data.get(result_name)) |
def api_mixed_request(self, method_name, params):
' Make api request and download a file and return\n JSON response or request status dictionary\n\n :param method_name: name of API methods\n :param params: dict-wrapped params for specific API call\n '
data = self.client.api_request(method_name, params, downloadable=True)
class_name = to_snake(self.__class__.__name__.replace('Broker', ''))
if (class_name in data):
result_name = class_name
else:
result_name = method_name.split('/')[(- 1)]
if (result_name not in data):
return data
return self._get_return_object_type(data.get(result_name)) | -3,617,585,501,267,358,000 | Make api request and download a file and return
JSON response or request status dictionary
:param method_name: name of API methods
:param params: dict-wrapped params for specific API call | infoblox_netmri/api/broker/broker.py | api_mixed_request | IngmarVG-IB/infoblox-netmri | python | def api_mixed_request(self, method_name, params):
' Make api request and download a file and return\n JSON response or request status dictionary\n\n :param method_name: name of API methods\n :param params: dict-wrapped params for specific API call\n '
data = self.client.api_request(method_name, params, downloadable=True)
class_name = to_snake(self.__class__.__name__.replace('Broker', ))
if (class_name in data):
result_name = class_name
else:
result_name = method_name.split('/')[(- 1)]
if (result_name not in data):
return data
return self._get_return_object_type(data.get(result_name)) |
def api_list_request(self, method_name, params):
' Make api request and return list of wrapped objects\n\n :param method_name: name of API methods\n :param params: dict-wrapped params for specific API call\n '
data = self.client.api_request(method_name, params)
if (not data):
return None
try:
return [self._get_return_object_type(x) for x in data[self.controller]]
except KeyError:
print('Sorry, this method will be implemented in the future versions of NetMRI')
raise NotImplementedException(self.controller, method_name) | 6,639,086,436,260,162,000 | Make api request and return list of wrapped objects
:param method_name: name of API methods
:param params: dict-wrapped params for specific API call | infoblox_netmri/api/broker/broker.py | api_list_request | IngmarVG-IB/infoblox-netmri | python | def api_list_request(self, method_name, params):
' Make api request and return list of wrapped objects\n\n :param method_name: name of API methods\n :param params: dict-wrapped params for specific API call\n '
data = self.client.api_request(method_name, params)
if (not data):
return None
try:
return [self._get_return_object_type(x) for x in data[self.controller]]
except KeyError:
print('Sorry, this method will be implemented in the future versions of NetMRI')
raise NotImplementedException(self.controller, method_name) |
def _get_method_fullname(self, method):
' Returns full API method name using controller name\n\n **Input**\n :param method: method name\n :return: full API path\n '
return '{}/{}'.format(self.controller, method) | 2,949,533,357,265,416,700 | Returns full API method name using controller name
**Input**
:param method: method name
:return: full API path | infoblox_netmri/api/broker/broker.py | _get_method_fullname | IngmarVG-IB/infoblox-netmri | python | def _get_method_fullname(self, method):
' Returns full API method name using controller name\n\n **Input**\n :param method: method name\n :return: full API path\n '
return '{}/{}'.format(self.controller, method) |
def _get_return_object_type(self, data):
' Returns wrapped response which inherits from RemoteModel class\n\n :param data: API responce data\n :return: RemoteModel child class\n '
if ((not data) or (type(data) != dict)):
return data
class_name = data.get('_class')
obj_class = locate(self._get_remote_class_name(class_name))
return obj_class(data, self.client) | 5,006,086,119,267,887,000 | Returns wrapped response which inherits from RemoteModel class
:param data: API responce data
:return: RemoteModel child class | infoblox_netmri/api/broker/broker.py | _get_return_object_type | IngmarVG-IB/infoblox-netmri | python | def _get_return_object_type(self, data):
' Returns wrapped response which inherits from RemoteModel class\n\n :param data: API responce data\n :return: RemoteModel child class\n '
if ((not data) or (type(data) != dict)):
return data
class_name = data.get('_class')
obj_class = locate(self._get_remote_class_name(class_name))
return obj_class(data, self.client) |
def _get_remote_class_name(self, name):
' Generate full path to specific RemoteModel instance\n\n :param name: name of model\n :return: full path for model\n '
return 'infoblox_netmri.api.remote.models.{pckg}_remote.{name}Remote'.format(pckg=to_snake(name), name=name) | -4,085,173,532,365,311,000 | Generate full path to specific RemoteModel instance
:param name: name of model
:return: full path for model | infoblox_netmri/api/broker/broker.py | _get_remote_class_name | IngmarVG-IB/infoblox-netmri | python | def _get_remote_class_name(self, name):
' Generate full path to specific RemoteModel instance\n\n :param name: name of model\n :return: full path for model\n '
return 'infoblox_netmri.api.remote.models.{pckg}_remote.{name}Remote'.format(pckg=to_snake(name), name=name) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.