[Bx21]\n g_avg_pool_sqzd = tf.squeeze(g_avg_pool, axis=[1, 2])\n pred = tf.nn.softmax(g_avg_pool_sqzd)\n\n # Get the class activation map\n raw_output_up = tf.image.resize_bilinear(raw_output_bcgd_rmvd, tf.shape(image_batch)[1:3,])\n raw_output_up = raw_output_up - tf.reduce_min(tf.reduce_min(raw_output_up, axis=1, keep_dims=True), axis=2, keep_dims=True) + EPSILON\n raw_output_up = raw_output_up / tf.reduce_max(tf.reduce_max(raw_output_up, axis=1, keep_dims=True), axis=2, keep_dims=True)\n cam_m_1 = tf.argmax(raw_output_up, dimension=3) + 1\n raw_output_catgs_rmvd = raw_output_up * tf.expand_dims(tf.expand_dims(binary_catg_batch, 1), 2)\n cam_m_2 = tf.argmax(raw_output_catgs_rmvd, dimension=3) + 1\n cam = tf.cast(tf.equal(cam_m_1, cam_m_2), tf.int64) * cam_m_1\n\n cam_batch = tf.expand_dims(cam, dim=3)\n\n # Set up tf session and initialize variables. \n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n sess = tf.Session(config=config)\n init = tf.global_variables_initializer()\n \n sess.run(init)\n sess.run(tf.local_variables_initializer())\n \n # Load weights.\n loader = tf.train.Saver(var_list=restore_var)\n if args.restore_from is not None:\n load(loader, sess, args.restore_from)\n \n # Start queue threads.\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\n \n # Iterate over training steps.\n for step in range(args.num_steps):\n preds, images, cams, bin_catg = sess.run([pred, image_batch, cam_batch, binary_catg])\n \"\"\"\n print(bin_catg)\n print(np.unique(np.unique(cams)))\n \"\"\"\n img = inv_preprocess(images)\n attMap = decode_labels(cams)\n output_dir = './output_maps_binary_without_norm/'\n img_name = output_dir + str(step) + '.jpg'\n map_name = output_dir + str(step) + '.png'\n misc.imsave(img_name, img[0,:,:,:])\n misc.imsave(map_name, attMap[0,:,:,:])\n coord.request_stop()\n coord.join(threads)","def model(inputs, target_images, is_training):\n # if isinstance(inputs, tuple):\n assert mask_augs >= 0. and mask_augs <= 1., \"mask_augs must be in [0, 1]\"\n if FLAGS.use_td_loss and isinstance(inputs, tuple):\n # print('#'*80)\n # print(inputs)\n assert metric is not None, \"Metric function is None\"\n inputs, augs = inputs\n B = inputs.get_shape().as_list()[0]\n A = augs.get_shape().as_list()[1]\n if mask_augs > 0:\n mask = tf.cast(tf.greater(tf.random.uniform(shape=[B, A], minval=0., maxval=1.), 0.5), augs.dtype) # noqa\n bias = mask * -1\n augs = (augs * mask) + bias # Randomly mask out augs for difficulty and code those dims as -1\n with tf.variable_scope('encoder'): # variable_scope name_scope\n features, block_activities = encoder(inputs, is_training=is_training)\n print(\"Features: \")\n print(features)\n print(\"---\")\n # Global average pool of B 7 7 2048 -> B 2048\n if data_format == 'channels_last':\n outputs = tf.reduce_mean(features, [1, 2])\n else:\n outputs = tf.reduce_mean(features, [2, 3])\n outputs = tf.identity(outputs, 'final_avg_pool')\n print(\"Outputs: \")\n print(outputs)\n print(\"---\")\n # B 2048\n\n h_w = features.get_shape().as_list()[1]\n # print(h_w)\n\n augs = tf.tile(augs[:,None,None,:], tf.constant([1,h_w,h_w,1]))\n print(\"Augs: \")\n print(augs)\n print(\"---\")\n features = tf.concat([features, augs], axis=-1)\n \n with tf.variable_scope('decoder'):\n recon_images = decoder(\n features,\n block_activities,\n is_training=is_training,\n skip=skip)\n print(\"Reconstructed images and target images: \")\n print(recon_images)\n print(target_images)\n print(\"---\")\n with tf.variable_scope('metric'):\n # Squash both recon and target images\n recon_images_squash = tf.tanh(recon_images)\n target_images = (target_images * 2) - 1\n Bt = target_images.get_shape().as_list()[0]\n Br = recon_images_squash.get_shape().as_list()[0]\n if Bt == Br:\n # Attractive + repulsive loss\n pass\n elif Bt * 2 == Br:\n # Attractive-only loss\n target_images = tf.concat([target_images, target_images], 0)\n\n # Differentiable perceptual metric. First reconstruction.\n # both_images = tf.concat([recon_images, target_images], -1) # B H W 6\n all_images = tf.concat([recon_images_squash, target_images], 0) # Stack these in batch dim\n metric_all_images = metric(all_images, is_training=is_training)\n # B = metric_all_images.get_shape().as_list()[0]\n metric_all_images = tf.reshape(metric_all_images, [B, -1])\n metric_hidden_r, metric_hidden_t = tf.split(metric_all_images, 2, 0) # Split these in batch dim\n\n # Prep recon_images for visualization\n # recon_images = tf.clip_by_value(recon_images, clip_value_min=-5, clip_value_max=5)\n # recon_images = (recon_images + 5) / 10\n\n recon_mean, recon_std = tf.nn.moments(recon_images, axes=[1, 2], keep_dims=True)\n recon_images = (recon_images - recon_mean) / recon_std\n recon_images = tf.clip_by_value(recon_images, clip_value_min=-5, clip_value_max=5)\n recon_images = (recon_images + 5) / 10\n # recon_images = recon_images_squash\n if greyscale_viz:\n recon_images = tf.image.rgb_to_grayscale(recon_images)\n recon_images = tf.concat([recon_images, recon_images, recon_images], -1)\n print(\"Embedding output: \")\n print(metric_hidden_t)\n print(\"---\")\n return outputs, recon_images, metric_hidden_r, metric_hidden_t\n\n else:\n # augs = None\n \n with tf.variable_scope('encoder'): # variable_scope name_scope\n features, block_activities = encoder(inputs, is_training)\n \n if data_format == 'channels_last':\n print(\"Features:\")\n print(features)\n outputs = tf.reduce_mean(features, [1, 2])\n else:\n outputs = tf.reduce_mean(features, [2, 3])\n outputs = tf.identity(outputs, 'final_avg_pool')\n \n # filter_trainable_variables(trainable_variables, after_block=5)\n # add_to_collection(trainable_variables, 'trainable_variables_inblock_')\n\n return outputs","def architecture(lq, img=None, mode=None):\r\n\r\n phase = mode == tf.estimator.ModeKeys.TRAIN #phase is true during training\r\n concat_axis = 3\r\n\r\n ##Reusable blocks\r\n\r\n def conv_block(input, filters, phase=phase):\r\n \"\"\"\r\n Convolution -> batch normalisation -> leaky relu\r\n phase defaults to true, meaning that the network is being trained\r\n \"\"\"\r\n\r\n conv_block = tf.layers.conv2d(\r\n inputs=input,\r\n filters=filters,\r\n kernel_size=3,\r\n padding=\"SAME\",\r\n activation=tf.nn.relu)\r\n\r\n #conv_block = tf.contrib.layers.batch_norm(\r\n # conv_block, \r\n # center=True, scale=True, \r\n # is_training=phase)\r\n\r\n #conv_block = tf.nn.leaky_relu(\r\n # features=conv_block,\r\n # alpha=0.2)\r\n #conv_block = tf.nn.relu(conv_block)\r\n\r\n return conv_block\r\n\r\n def aspp_block(input, phase=phase):\r\n \"\"\"\r\n Atrous spatial pyramid pooling\r\n phase defaults to true, meaning that the network is being trained\r\n \"\"\"\r\n\r\n #Convolutions at multiple rates\r\n conv1x1 = tf.layers.conv2d(\r\n inputs=input,\r\n filters=aspp_filters,\r\n kernel_size=1,\r\n padding=\"same\",\r\n activation=tf.nn.relu,\r\n name=\"1x1\")\r\n #conv1x1 = tf.contrib.layers.batch_norm(\r\n # conv1x1, \r\n # center=True, scale=True, \r\n # is_training=phase)\r\n\r\n conv3x3_rateSmall = tf.layers.conv2d(\r\n inputs=input,\r\n filters=aspp_filters,\r\n kernel_size=3,\r\n padding=\"same\",\r\n dilation_rate=aspp_rateSmall,\r\n activation=tf.nn.relu,\r\n name=\"lowRate\")\r\n #conv3x3_rateSmall = tf.contrib.layers.batch_norm(\r\n # conv3x3_rateSmall, \r\n # center=True, scale=True, \r\n # is_training=phase)\r\n\r\n conv3x3_rateMedium = tf.layers.conv2d(\r\n inputs=input,\r\n filters=aspp_filters,\r\n kernel_size=3,\r\n padding=\"same\",\r\n dilation_rate=aspp_rateMedium,\r\n activation=tf.nn.relu,\r\n name=\"mediumRate\")\r\n #conv3x3_rateMedium = tf.contrib.layers.batch_norm(\r\n # conv3x3_rateMedium, \r\n # center=True, scale=True, \r\n # is_training=phase)\r\n\r\n conv3x3_rateLarge = tf.layers.conv2d(\r\n inputs=input,\r\n filters=aspp_filters,\r\n kernel_size=3,\r\n padding=\"same\",\r\n dilation_rate=aspp_rateLarge,\r\n activation=tf.nn.relu,\r\n name=\"highRate\")\r\n #conv3x3_rateLarge = tf.contrib.layers.batch_norm(\r\n # conv3x3_rateLarge, \r\n # center=True, scale=True, \r\n # is_training=phase)\r\n\r\n #Image-level features\r\n pooling = tf.nn.pool(\r\n input=input,\r\n window_shape=(2,2),\r\n pooling_type=\"AVG\",\r\n padding=\"SAME\",\r\n strides=(2, 2))\r\n #Use 1x1 convolutions to project into a feature space the same size as the atrous convolutions'\r\n pooling = tf.layers.conv2d(\r\n inputs=pooling,\r\n filters=aspp_filters,\r\n kernel_size=1,\r\n padding=\"SAME\",\r\n name=\"imageLevel\")\r\n pooling = tf.image.resize_images(pooling, [64, 64])\r\n #pooling = tf.contrib.layers.batch_norm(\r\n # pooling,\r\n # center=True, scale=True,\r\n # is_training=phase)\r\n\r\n #Concatenate the atrous and image-level pooling features\r\n concatenation = tf.concat(\r\n values=[conv1x1, conv3x3_rateSmall, conv3x3_rateMedium, conv3x3_rateLarge, pooling],\r\n axis=concat_axis)\r\n\r\n #Reduce the number of channels\r\n reduced = tf.layers.conv2d( #Not sure if this is the correct way to reshape...\r\n inputs=concatenation,\r\n filters=aspp_filters,\r\n kernel_size=1,\r\n padding=\"SAME\")\r\n\r\n return reduced\r\n\r\n\r\n def strided_conv_block(input, filters, stride, rate=1, phase=phase):\r\n \r\n return slim.separable_convolution2d(\r\n inputs=input,\r\n num_outputs=filters,\r\n kernel_size=3,\r\n depth_multiplier=1,\r\n stride=stride,\r\n padding='SAME',\r\n data_format='NHWC',\r\n rate=rate,\r\n activation_fn=tf.nn.relu,\r\n normalizer_fn=None,\r\n normalizer_params=None,\r\n weights_initializer=tf.contrib.layers.xavier_initializer(),\r\n weights_regularizer=None,\r\n biases_initializer=tf.zeros_initializer(),\r\n biases_regularizer=None,\r\n reuse=None,\r\n variables_collections=None,\r\n outputs_collections=None,\r\n trainable=True,\r\n scope=None)\r\n\r\n\r\n def deconv_block(input, filters, phase=phase):\r\n '''Transpositionally convolute a feature space to upsample it'''\r\n \r\n deconv_block = tf.layers.conv2d_transpose(\r\n inputs=input,\r\n filters=filters,\r\n kernel_size=3,\r\n strides=2,\r\n padding=\"SAME\",\r\n activation=tf.nn.relu)\r\n\r\n #deconv_block = tf.contrib.layers.batch_norm(\r\n # deconv_block, \r\n # center=True, scale=True, \r\n # is_training=phase)\r\n\r\n #deconv_block = tf.nn.leaky_relu(\r\n # features=deconv_block,\r\n # alpha=0.2)\r\n #deconv_block = tf.nn.relu(deconv_block)\r\n\r\n return deconv_block\r\n\r\n '''Model building'''\r\n input_layer = tf.reshape(lq, [-1, cropsize, cropsize, channels])\r\n\r\n #Encoding block 0\r\n cnn0 = conv_block(\r\n input=input_layer, \r\n filters=features0)\r\n cnn0_last = conv_block(\r\n input=cnn0, \r\n filters=features0)\r\n cnn0_strided = strided_conv_block(\r\n input=cnn0_last,\r\n filters=features0,\r\n stride=2)\r\n\r\n #Encoding block 1\r\n cnn1 = conv_block(\r\n input=cnn0_strided, \r\n filters=features1)\r\n cnn1_last = conv_block(\r\n input=cnn1, \r\n filters=features1)\r\n cnn1_strided = strided_conv_block(\r\n input=cnn1_last,\r\n filters=features1,\r\n stride=2)\r\n\r\n #Encoding block 2\r\n cnn2 = conv_block(\r\n input=cnn1_strided,\r\n filters=features2)\r\n cnn2_last = conv_block(\r\n input=cnn2,\r\n filters=features2)\r\n cnn2_strided = strided_conv_block(\r\n input=cnn2_last,\r\n filters=features2,\r\n stride=2)\r\n\r\n #Encoding block 3\r\n cnn3 = conv_block(\r\n input=cnn2_strided,\r\n filters=features3)\r\n cnn3 = conv_block(\r\n input=cnn3,\r\n filters=features3)\r\n cnn3_last = conv_block(\r\n input=cnn3,\r\n filters=features3)\r\n cnn3_strided = strided_conv_block(\r\n input=cnn3_last,\r\n filters=features3,\r\n stride=2)\r\n\r\n #Encoding block 4\r\n cnn4 = conv_block(\r\n input=cnn3_strided,\r\n filters=features4)\r\n cnn4 = conv_block(\r\n input=cnn4,\r\n filters=features4)\r\n cnn4_last = conv_block(\r\n input=cnn4,\r\n filters=features4)\r\n\r\n #cnn4_strided = split_separable_conv2d(\r\n # inputs=cnn4_last,\r\n # filters=features4,\r\n # rate=2,\r\n # stride=2)\r\n\r\n #Prepare for aspp\r\n aspp_input = strided_conv_block(\r\n input=cnn4_last,\r\n filters=features4,\r\n stride=1,\r\n rate=2)\r\n aspp_input = conv_block(\r\n input=aspp_input,\r\n filters=features4)\r\n\r\n ##Atrous spatial pyramid pooling\r\n aspp = aspp_block(aspp_input)\r\n\r\n #Upsample the semantics by a factor of 4\r\n #upsampled_aspp = tf.image.resize_bilinear(\r\n # images=aspp,\r\n # tf.shape(aspp)[1:3],\r\n # align_corners=True)\r\n\r\n #Decoding block 1 (deepest)\r\n deconv4 = conv_block(aspp, features4)\r\n deconv4 = conv_block(deconv4, features4)\r\n deconv4 = conv_block(deconv4, features4)\r\n \r\n #Decoding block 2\r\n deconv4to3 = deconv_block(deconv4, features4)\r\n concat3 = tf.concat(\r\n values=[deconv4to3, cnn3_last],\r\n axis=concat_axis)\r\n deconv3 = conv_block(concat3, features3)\r\n deconv3 = conv_block(deconv3, features3)\r\n deconv3 = conv_block(deconv3, features3)\r\n\r\n #Decoding block 3\r\n deconv3to2 = deconv_block(deconv3, features3)\r\n concat2 = tf.concat(\r\n values=[deconv3to2, cnn2_last],\r\n axis=concat_axis)\r\n deconv2 = conv_block(concat2, features2)\r\n deconv2 = conv_block(deconv2, features2)\r\n \r\n #Decoding block 4\r\n deconv2to1 = deconv_block(deconv2, features2)\r\n concat1 = tf.concat(\r\n values=[deconv2to1, cnn1_last],\r\n axis=concat_axis)\r\n deconv1 = conv_block(concat1, features1)\r\n deconv1 = conv_block(deconv1, features1)\r\n\r\n #Decoding block 5\r\n deconv1to0 = deconv_block(deconv1, features1)\r\n concat0 = tf.concat(\r\n values=[deconv1to0, cnn0_last],\r\n axis=concat_axis)\r\n deconv0 = conv_block(concat0, features0)\r\n deconv0 = conv_block(deconv0, features0)\r\n\r\n #Create final image with 1x1 convolutions\r\n deconv_final = tf.layers.conv2d_transpose(\r\n inputs=deconv0,\r\n filters=1,\r\n kernel_size=3,\r\n padding=\"SAME\",\r\n activation=tf.nn.relu)\r\n\r\n\r\n #Residually connect the input to the output\r\n output = deconv_final#+input_layer\r\n\r\n #Image values will be between 0 and 1\r\n output = tf.clip_by_value(\r\n output,\r\n clip_value_min=0,\r\n clip_value_max=1)\r\n\r\n if phase: #Calculate loss during training\r\n ground_truth = tf.reshape(img, [-1, cropsize, cropsize, channels])\r\n loss = 1.0-tf_ssim(output, ground_truth)#cropsize*cropsize*tf.reduce_mean(tf.squared_difference(output, ground_truth))\r\n \r\n #tf.log(cropsize*cropsize*tf.reduce_mean(tf.squared_difference(output, ground_truth))+1)\r\n #tf.summary.histogram(\"loss\", loss)\r\n else:\r\n loss = -1\r\n\r\n return loss, output","def construct_model():\n import lbann\n\n # Layer graph\n input = lbann.Input(target_mode='N/A', name='inp_data')\n # data is 64*64*4 images + 15 scalar + 5 param\n #inp_slice = lbann.Slice(input, axis=0, slice_points=\"0 16399 16404\",name='inp_slice')\n inp_slice = lbann.Slice(input, axis=0, slice_points=str_list([0,args.ydim,args.ydim+5]),name='inp_slice')\n gt_y = lbann.Identity(inp_slice,name='gt_y')\n gt_x = lbann.Identity(inp_slice, name='gt_x') #param not used\n\n zero = lbann.Constant(value=0.0,num_neurons='1',name='zero')\n one = lbann.Constant(value=1.0,num_neurons='1',name='one')\n\n z_dim = 20 #Latent space dim\n\n z = lbann.Gaussian(mean=0.0,stdev=1.0, neuron_dims=\"20\")\n model = macc_models.MACCWAE(args.zdim,args.ydim,cf=args.mcf,use_CNN=args.useCNN)\n d1_real, d1_fake, d_adv, pred_y = model(z,gt_y)\n\n d1_real_bce = lbann.SigmoidBinaryCrossEntropy([d1_real,one],name='d1_real_bce')\n d1_fake_bce = lbann.SigmoidBinaryCrossEntropy([d1_fake,zero],name='d1_fake_bce')\n d_adv_bce = lbann.SigmoidBinaryCrossEntropy([d_adv,one],name='d_adv_bce')\n img_loss = lbann.MeanSquaredError([pred_y,gt_y])\n rec_error = lbann.L2Norm2(lbann.WeightedSum([pred_y,gt_y], scaling_factors=\"1 -1\"))\n\n layers = list(lbann.traverse_layer_graph(input))\n # Setup objective function\n weights = set()\n src_layers = []\n dst_layers = []\n for l in layers:\n if(l.weights and \"disc0\" in l.name and \"instance1\" in l.name):\n src_layers.append(l.name)\n #freeze weights in disc2\n if(l.weights and \"disc1\" in l.name):\n dst_layers.append(l.name)\n for idx in range(len(l.weights)):\n l.weights[idx].optimizer = lbann.NoOptimizer()\n weights.update(l.weights)\n l2_reg = lbann.L2WeightRegularization(weights=weights, scale=1e-4)\n d_adv_bce = lbann.LayerTerm(d_adv_bce,scale=0.01)\n obj = lbann.ObjectiveFunction([d1_real_bce,d1_fake_bce,d_adv_bce,img_loss,rec_error,l2_reg])\n # Initialize check metric callback\n metrics = [lbann.Metric(img_loss, name='recon_error')]\n #pred_y = macc_models.MACCWAE.pred_y_name\n callbacks = [lbann.CallbackPrint(),\n lbann.CallbackTimer(),\n lbann.CallbackSaveModel(dir=args.dump_models),\n lbann.CallbackReplaceWeights(source_layers=list2str(src_layers),\n destination_layers=list2str(dst_layers),\n batch_interval=2)]\n\n if(args.ltfb_batch_interval > 0) :\n callbacks.append(lbann.CallbackLTFB(batch_interval=args.ltfb_batch_interval,metric='recon_error',\n low_score_wins=True,\n exchange_hyperparameters=True))\n\n # Construct model\n return lbann.Model(args.num_epochs,\n serialize_io=True,\n weights=weights,\n layers=layers,\n metrics=metrics,\n objective_function=obj,\n callbacks=callbacks)","def mgcNetArchNin(outLayer, l2_val, **kwargs):\n\n def_vals = {\"input_img_rows\" : 72,\n \"input_img_cols\" : 72,\n \"channels\" : 1,\n \"nb_classes\" : 13\n } # default parameters value\n\n for k, v in def_vals.items():\n kwargs.setdefault(k, v)\n\n input_img_rows = kwargs['input_img_rows']\n input_img_cols = kwargs['input_img_cols']\n channels = kwargs['channels']\n nb_classes = kwargs['nb_classes']\n\n \n # Input: 72 x 72 x 1\n img_shape = layers.Input(shape = (input_img_rows, input_img_cols, channels))\n\n # Layer 1\n #------------------------\n conv1 = layers.Conv2D(filters=16, kernel_size=(5, 5), padding='valid', activation='relu')(img_shape)\n conv1 = layers.Conv2D(filters=16, kernel_size=(1, 1), activation='relu')(conv1)\n conv1 = layers.Conv2D(filters=16, kernel_size=(1, 1), activation='relu')(conv1)\n conv1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)\n conv1 = layers.Dropout(0.4)(conv1)\n\n # Layer 2\n #------------------------\n conv2 = layers.Conv2D(filters=32, kernel_size=(5, 5), padding='same', activation='relu')(conv1)\n conv2 = layers.Conv2D(filters=32, kernel_size=(1, 1), activation='relu')(conv2)\n conv2 = layers.Conv2D(filters=32, kernel_size=(1, 1), activation='relu')(conv2)\n conv2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)\n conv2 = layers.Dropout(0.4)(conv2)\n\n # Layer 3\n #------------------------\n conv3 = layers.Conv2D(filters=64, kernel_size=(3, 3), padding='same', activation='relu')(conv2)\n conv3 = layers.Conv2D(filters=64, kernel_size=(1, 1), activation='relu')(conv3)\n conv3 = layers.Conv2D(filters=64, kernel_size=(1, 1), activation='relu')(conv3)\n conv3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)\n conv3 = layers.Dropout(0.4)(conv3)\n\n # Layer 4\n #------------------------\n #conv4 = layers.Conv2D(filters=128, kernel_size=(2, 2), padding='same', activation='relu')(conv3)\n #conv4 = layers.Conv2D(filters=128, kernel_size=(1, 1), activation='relu')(conv4)\n #conv4 = layers.Conv2D(filters=128, kernel_size=(1, 1), activation='relu')(conv4)\n #conv4 = layers.MaxPooling2D(pool_size=(2, 2))(conv4)\n #conv4 = layers.Dropout(0.4)(conv4)\n\n # Layer 5\n #------------------------\n output = layers.Conv2D(filters=128, kernel_size=(2, 2), padding='same', activation='relu')(conv3) # skip layer 4\n output = layers.Conv2D(filters=64, kernel_size=(1, 1), activation='relu')(output)\n output = layers.Conv2D(filters=32, kernel_size=(1, 1))(output)\n output = layers.MaxPooling2D(pool_size=(2, 2))(output)\n output = layers.Dropout(0.4)(output)\n\n \n # FC Layer\n #------------------------\n outputmlp = layers.Flatten()(output)\n outputmlp = layers.Dense(64, activation = 'relu')(outputmlp)\n outputmlp = layers.Dropout(0.5)(outputmlp)\n\n predictionsMlp = layers.Dense(nb_classes, activation='softmax')(outputmlp)\n \n \n # global averaging\n weight_decay=1E-4\n concat_axis = 1\n \n x = BatchNormalization(axis=concat_axis,\n gamma_regularizer=regularizers.l2(weight_decay),\n beta_regularizer=regularizers.l2(weight_decay))(output)\n x = Activation('relu')(x)\n x = layers.Dropout(0.4)(x)\n x = GlobalAveragePooling2D(data_format=K.image_data_format())(x)\n \n predictionsGloAvg = layers.Dense(nb_classes,\n activation='softmax',\n kernel_regularizer=regularizers.l2(weight_decay),\n bias_regularizer=regularizers.l2(weight_decay))(x)\n \n if outLayer == \"gloAvg\":\n predictions = predictionsGloAvg\n elif outLayer == \"mlp\":\n predictions = predictionsMlp\n \n # prediction model\n model = Model(img_shape, predictions, name = 'net_in_net')\n\n\n return model","def model(images, is_training=True):\n images = tf.reshape(images, [-1, 28, 28, 1])\n\n # First convolutional layer with max pooling and ReLU activation.\n conv1 = slim.conv2d(images, 32, [5, 5], activation_fn=tf.nn.relu, scope='conv1')\n pool1 = slim.max_pool2d(conv1, [2, 2], scope='pool1')\n\n # Second convolutional layer with max pooling and ReLU activation.\n conv2 = slim.conv2d(pool1, 64, [5, 5], activation_fn=tf.nn.relu, scope='conv2')\n pool2 = slim.max_pool2d(conv2, [2, 2], scope='pool2')\n\n # First fully connected layer with ReLU activation.\n flat = slim.flatten(pool2)\n fc1 = slim.fully_connected(flat, 1024, activation_fn=tf.nn.relu, scope='fc1')\n\n # Dropout.\n drop = slim.dropout(fc1, 0.5, is_training=is_training)\n\n # Fully connected output layer (logits).\n fc2 = slim.fully_connected(drop, 10, activation_fn=None, scope='fc2')\n return fc2","def __call__(\n self, \n image: ndarray, \n adversarial_image: ndarray\n ) -> Dict[str, Union[float, int]]:\n ...","def GNIs(features, labels, mode, params, config):\n del config\n N, H = params[\"N\"], params[\"H\"]\n n_samples = params[\"n_samples\"]\n\n params[\"non_targeted_layers\"] = []\n\n if params[\"input_inject\"]:\n params[\"non_targeted_layers\"] = list(range(1, N + 1))\n\n params[\"non_targeted_layers\"] += [N + 1]\n\n image_tile_summary(\"input\", features, rows=1, cols=16)\n\n # --- Ensure input data is flat\n features = tf.reshape(features, (-1, np.prod(params['image_shape'])))\n features = tf.cast(features, dtype=tf.float32)\n if labels is not None:\n labels = tf.cast(labels, dtype=tf.float32)\n else:\n labels = tf.ones_like(features[:, :10], dtype=None)\n B = int_shape(labels)[0]\n n_output = int_shape(labels)[-1]\n\n if params['activation'] != 'linear':\n activation = getattr(tf.nn, params['activation'])\n else:\n activation = None\n\n # --- Make discriminator\n if params[\"disc_type\"] == 'mlp':\n mlp = make_mlp(activation, np.prod(params['image_shape']), N, H,\n n_output)\n if params[\"disc_type\"] == 'convnet':\n mlp = make_convnet(activation, params['image_shape'], n_output)\n if params[\"disc_type\"] == 'vgg':\n mlp = make_vgg13(activation, params['image_shape'], n_output)\n\n # --- Retrieve intermediate activations, and layer output\n # --- we don't want to mask the final layer so activations doesn't include the output layer\n p_phi_y = mlp(features)\n\n sel_layer_shapes = [p_phi_y['layer_shapes'][i] for i in range(N + 1)]\n\n # --- Get Predictions using log(p(y|x))\n preds = p_phi_y['activations'][-1]\n\n # --- Classification loss, log(p(y|x))\n if params[\"loss\"] == 'cross_entropy':\n loss = cross_entropy(labels, preds)\n pred_class = tf.argmax(input=preds, axis=-1)\n true_class = tf.argmax(input=labels, axis=-1)\n acc = tf.cast(tf.equal(pred_class, true_class), tf.float32)\n tf.compat.v1.summary.scalar(\"accuracy\", tf.reduce_mean(acc))\n elif params[\"loss\"] == 'mse':\n loss = square_error(labels, preds)\n\n global_step = tf.compat.v1.train.get_or_create_global_step()\n\n p_phi_y_noisy = replace_mask_layer(\n features,\n p_phi_y,\n non_targeted_layers=params['non_targeted_layers'],\n var=params[\"var\"],\n n_samples=n_samples,\n mode=params[\"noise_mode\"])\n\n preds_noisy = p_phi_y_noisy['activations'][-1]\n\n # --- Classification loss, log(p(y|x))\n if params[\"loss\"] == 'cross_entropy':\n noisy_loss = cross_entropy(labels, preds_noisy)\n elif params[\"loss\"] == 'mse':\n noisy_loss = square_error(labels, preds_noisy)\n\n optimizer = tf.compat.v1.train.GradientDescentOptimizer(\n params[\"learning_rate\"])\n\n gradients, variables = [], []\n\n tf.compat.v1.summary.scalar(\"learning_rate\", params[\"learning_rate\"])\n tf.compat.v1.summary.scalar(\"batch_size\", B)\n\n # --- Enumerate over activation layers, zip automatically removes final\n # --- logit layer\n\n layers = [\n l for l in p_phi_y['net'].layers\n if ('dense' in l.name or 'conv' in l.name)\n ]\n\n noises = [\n tf.reshape(n, (B, n_samples, -1)) for n in p_phi_y_noisy['noise'][:-1]\n ]\n\n weights = [layers[i].trainable_weights[0] for i in range(N + 1)]\n acts = p_phi_y['activations'][:-1]\n\n Js = [\n tf.reshape(batch_jacobian(preds, a, use_pfor=True), (B, -1, n_output))\n for a in acts\n ]\n print(Js)\n\n G, C, H = calc_taylor_expansion(Js, loss, preds, noises, B, n_samples)\n\n EC = calc_tikhonov_reg(Js, acts, preds, params[\"noise_mode\"],\n params[\"var\"], params[\"loss\"])\n\n H_sig = heavy_tail_variance(Js, loss, preds)\n\n l_noise = 0\n if params[\"noise_type\"] is None:\n noisy_loss_estimate = loss\n elif params[\"noise_type\"] == 'input':\n noisy_loss_estimate = noisy_loss\n elif 'full' in params[\"noise_type\"]:\n # --- This is the Gaussian stuff\n assert n_samples == 1\n l_noise += H + G + C\n noisy_loss_estimate = loss + l_noise\n\n elif 'marginal' in params[\"noise_type\"]:\n # --- Don't ever noise final layer\n assert n_samples == 1\n l_noise = EC\n if 'H' in params[\"noise_type\"]:\n l_noise += H\n\n if 'C' in params[\"noise_type\"]:\n # alpha, beta, sigma, mu = tf.py_func(\n # estimate_all_params,\n # inp=[(C - EC)],\n # Tout=[tf.float32, tf.float32, tf.float32, tf.float32])\n #\n # tf.compat.v1.summary.scalar('C/alpha', alpha)\n # tf.compat.v1.summary.scalar('C/beta', beta)\n # tf.compat.v1.summary.scalar('C/sigma', sigma)\n # tf.compat.v1.summary.scalar('C/mu', mu)\n # tf.compat.v1.summary.scalar('C', tf.reduce_mean(C - EC))\n # tf.compat.v1.summary.histogram('C', C)\n l_noise += (C - EC)\n if 'G' in params[\"noise_type\"]:\n l_noise += G\n noisy_loss_estimate = loss + l_noise\n\n actual_noise = tf.reduce_mean(noisy_loss - loss)\n estimated_noise = tf.reduce_mean(noisy_loss_estimate - loss)\n\n tf.compat.v1.summary.scalar('loss/actual_noise', actual_noise)\n tf.compat.v1.summary.scalar('loss/estimated_noise', estimated_noise)\n\n tf.compat.v1.summary.scalar(\"loss/noisy_\" + params[\"loss\"],\n tf.reduce_mean(noisy_loss))\n tf.compat.v1.summary.scalar(\"loss/og_\" + params[\"loss\"],\n tf.reduce_mean(loss))\n\n noise_err = tf.reduce_mean(estimated_noise - actual_noise)\n\n tf.compat.v1.summary.scalar(\n 'loss/noise_est_pe',\n tf.abs(noise_err / tf.reduce_mean(actual_noise + 1e-8)))\n\n tf.compat.v1.summary.scalar('loss/noise_est_mse',\n tf.abs(tf.reduce_mean(noise_err**2)))\n\n loss_err = tf.reduce_mean(noisy_loss_estimate - noisy_loss)\n\n tf.compat.v1.summary.scalar(\n 'loss/loss_est_pe',\n tf.abs(loss_err / tf.reduce_mean(noisy_loss + 1e-8)))\n\n tf.compat.v1.summary.scalar('loss/loss_est_mse',\n tf.abs(tf.reduce_mean(loss_err**2)))\n\n if params[\"L2\"] > 0:\n vars = tf.trainable_variables()\n l2_reg = tf.add_n([tf.nn.l2_loss(v) for v in vars]) * params[\"L2\"]\n noisy_loss_estimate += l2_reg\n tf.compat.v1.summary.scalar(\"loss/L2_reg\", l2_reg)\n loss_err = tf.reduce_mean(noisy_loss_estimate - noisy_loss)\n\n # tf.compat.v1.summary.image('activations_covariance', activation_covariance)\n # g_noise =\n for i, w in enumerate(weights):\n layer_name = \"layer_\" + str(i)\n num_params = np.prod(int_shape(w))\n\n a = p_phi_y['activations'][i]\n noisy_a = p_phi_y_noisy['activations'][i]\n inj_noise = noisy_a - a\n print(noisy_a, a)\n\n # --- Display in tensorboard -- Injected noise stats\n tf.compat.v1.summary.histogram(layer_name + '/injected_noise',\n inj_noise)\n\n n_neurons = int_shape(a)[1]\n\n tf.compat.v1.summary.histogram(layer_name + '/w', w)\n corr = tfp.stats.correlation(a)\n tf.compat.v1.summary.scalar(layer_name + '/corr', tf.reduce_mean(corr))\n\n sparsity = tf.reduce_sum(tf.cast(a <= 1e-6, tf.float32))\n\n # tf.compat.v1.summary.scalar(layer_name + '/lifetime_sparsity',\n # sparsity / B)\n tf.compat.v1.summary.scalar(layer_name + '/population_sparsity',\n sparsity / (B * n_neurons))\n\n # --- Retrieve the noise of the gradient of each layer\n # --- = noisy gradients - gradients, this corresponds to\n # --- n_t * gradients where n_t is our noise matrix\n # --- W gradients\n\n og_W_n = tf.gradients([tf.reduce_mean(noisy_loss)], [w])[0]\n\n g_W_n = tf.gradients([tf.reduce_mean(noisy_loss_estimate)], [w])[0]\n g = tf.gradients(tf.reduce_mean(loss), w)[0]\n\n err = -g_W_n + og_W_n\n g_noise = g_W_n - g\n\n tf.compat.v1.summary.scalar(layer_name + '/mean_grad_noise',\n tf.reduce_mean(g_noise))\n tf.compat.v1.summary.histogram(layer_name + '/grad_noise', g_noise)\n\n tf.compat.v1.summary.scalar(layer_name + '/weights_l2/',\n tf.reduce_mean(tf.norm(w)))\n\n tf.compat.v1.summary.scalar(layer_name + '/grad_est_mse',\n tf.reduce_mean((og_W_n - g_W_n)**2))\n tf.compat.v1.summary.scalar(layer_name + '/grad_est_pe',\n tf.reduce_mean((-og_W_n + g_W_n) / og_W_n))\n\n gradients.extend([g_W_n])\n variables.extend([w])\n\n if i > 0 and params['calc_hessian']:\n # --- Number of parameters does not include batch_size\n\n hessians = trace_hessian([noisy_loss], weights)\n h_trace = tf.reduce_sum(tf.concat(hessians, axis=1)) / (B * n_samples)\n\n for i, h in enumerate(hessians):\n layer_name = \"layer_\" + str(i)\n tf.compat.v1.summary.scalar(layer_name + '/H_trace',\n tf.reduce_sum(h) / (B * n_samples))\n\n tf.compat.v1.summary.scalar('network/H_trace', h_trace)\n\n # --- Sum all them losses\n\n loss = tf.reduce_mean(loss)\n noisy_loss = tf.reduce_mean(noisy_loss)\n\n train_step = optimizer.apply_gradients(zip(gradients, variables),\n global_step=global_step)\n\n if mode == tf.estimator.ModeKeys.PREDICT:\n eval_metrics = {}\n predictions = {\n 'preds': tf.nn.softmax(p_phi_y['activations'][-1], axis=1)\n }\n predictions['GCH'] = G + C + H - EC\n\n for i, J in enumerate(Js):\n predictions['J' + str(i)] = J\n\n # for i, w in enumerate(weights):\n # predictions['dGCH' + str(i)] = tf.gradients(\n # [predictions['GCH']], [w])[0]\n if params['calc_hessian']:\n # --- Number of parameters does not include batch_size\n\n hessians = trace_hessian([noisy_loss], weights[1:3])\n h_trace = tf.reduce_sum(tf.concat(hessians,\n axis=1)) / (B * n_samples)\n\n predictions['h_trace'] = h_trace\n\n else:\n predictions = {}\n eval_metrics = {\n \"loss/og\": tf.compat.v1.metrics.mean(loss),\n }\n if params[\"loss\"] == 'cross_entropy':\n eval_metrics[\"accuracy\"] = tf.compat.v1.metrics.mean(acc)\n\n return tf.estimator.EstimatorSpec(mode=mode,\n loss=loss,\n predictions=predictions,\n train_op=train_step,\n eval_metric_ops=eval_metrics)","def pre_analyse():\n t = transform()\n model = modified_resnet50()\n model.load_state_dict(\n torch.load(\n \"model.pth.tar\",\n map_location=torch.device(\"cpu\"),\n )[\"state_dict\"]\n )\n model.eval()\n\n def get_preds(img_path):\n \"\"\"\n Gives labelds and probabilities for a single image\n This is were we preprocess the image, using a function defined in the model class\n \"\"\"\n # load image\n img = Image.open(img_path).convert(\"RGB\")\n # process it\n x = t(img)\n # get in in the right format\n x = Variable(x).unsqueeze(0)\n # predictions\n output = model(x)\n # decode\n output = decode(output.cpu().data.numpy()[0])\n\n # filter\n # return pred, proba\n return output\n\n return get_preds(\"image.jpg\")","def problem2():\n\n data = loaddata(\"data/bayerdata.npy\")\n r, g, b = separatechannels(data)\n\n img = assembleimage(r, g, b)\n display_image(img)\n\n img_interpolated = interpolate(r, g, b)\n display_image(img_interpolated)","def forward(self, images: Tensor) -> Tensor | list[Tensor] | tuple[list[Tensor]]:\n self.encoder.eval()\n\n if self.tiler:\n images = self.tiler.tile(images)\n encoder_features = self.encoder(images)\n encoder_features = list(encoder_features.values())\n decoder_features = self.decoder(self.bottleneck(encoder_features))\n\n if self.training:\n output = encoder_features, decoder_features\n else:\n output = self.anomaly_map_generator(encoder_features, decoder_features)\n if self.tiler:\n output = self.tiler.untile(output)\n\n return output","def train():\n\n ### DO NOT CHANGE SEEDS!\n # Set the random seeds for reproducibility\n np.random.seed(42)\n\n ## Prepare all functions\n # Get number of units in each hidden layer specified in the string such as 100,100\n if FLAGS.dnn_hidden_units:\n dnn_hidden_units = FLAGS.dnn_hidden_units.split(\",\")\n dnn_hidden_units = [int(dnn_hidden_unit_) for dnn_hidden_unit_ in dnn_hidden_units]\n else:\n dnn_hidden_units = []\n\n # Get negative slope parameter for LeakyReLU\n neg_slope = FLAGS.neg_slope\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n import matplotlib.pyplot as plt\n\n data = cifar10_utils.get_cifar10(FLAGS.data_dir)\n train = data['train']\n test = data['test']\n dim_x = train.images.shape[1]*train.images.shape[2]*train.images.shape[3]\n\n mlp = MLP(dim_x, dnn_hidden_units, train.labels.shape[1], neg_slope)\n loss_module = CrossEntropyModule()\n\n loss_train = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n loss_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n accuracy_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n\n images_test = test.images\n labels_test = test.labels\n images_test = np.reshape(images_test, (images_test.shape[0], dim_x))\n\n for i in range(0, FLAGS.max_steps):\n if PRINTS:\n print('iter', i+1, end='\\r')\n images, labels = train.next_batch(FLAGS.batch_size) \n images = np.reshape(images, (images.shape[0], dim_x))\n\n pred = mlp.forward(images)\n loss = loss_module.forward(pred, labels)\n loss_grad = loss_module.backward(pred, labels)\n mlp.backward(loss_grad)\n\n for module in reversed(mlp.modules):\n if isinstance(module, LinearModule):\n module.params['weight'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['weight']\n module.params['bias'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['bias']\n if (i+1) % FLAGS.eval_freq == 0:\n pred_test = mlp.forward(images_test)\n loss_train[i // FLAGS.eval_freq] = loss\n accuracy_test[i // FLAGS.eval_freq] = accuracy(pred_test, labels_test)\n loss_test[i // FLAGS.eval_freq] = loss_module.forward(pred_test, labels_test)\n if PRINTS:\n print()\n print('test_loss:', loss_test[i // FLAGS.eval_freq])\n print('test_accuracy:', accuracy_test[i // FLAGS.eval_freq])\n print('train_loss:', loss_train[i // FLAGS.eval_freq])\n\n if PLOTS:\n fig, ax = plt.subplots(1, 2, figsize=(10,5))\n fig.suptitle('Training curves for Numpy MLP\\nFinal test accuracy: {:0.4f}, default configuration'.format(accuracy_test[i // FLAGS.eval_freq]))\n\n ax[0].set_title('Loss')\n ax[0].set_ylabel('Loss value')\n ax[0].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\n ax[0].plot(loss_train, label='Train')\n ax[0].plot(loss_test, label='Test')\n ax[0].legend()\n\n ax[1].set_title('Accuracy')\n ax[1].set_ylabel('Accuracy value')\n ax[1].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\n ax[1].plot(accuracy_test, label='Test')\n ax[1].legend()\n plt.show()\n\n\n ########################\n # END OF YOUR CODE #\n #######################","def get_classification(self, image):\n\n\tif 'session' in locals() and session is not None:\n \t print('Close interactive session')\n session.close()\n\n time_start = time.time()\n #TODO implement light color prediction\n #image_np = self.__preprocess_image(image)\n \timage_np = image \n \n \t# Expand dimensions since the model expects images to have shape: [1, None, None, 3]\n image_np_expanded = np.expand_dims(image_np, axis=0)\n time0 = time.time()\n\n # Actual detection.\n with self.detection_graph.as_default():\n (boxes, scores, classes, num) = self.sess.run(\n [self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections],\n feed_dict={self.image_tensor: image_np_expanded})\n\n time1 = time.time()\n\n output = self.__postprocessing_detected_box(scores[0], classes[0])\n rospy.loginfo('Time in seconds' + str(time1-time_start)+' Result:'+self.__traffic_id_to_name(output))\n return output","def build(imageWidth, imageHeight, imageDepth, classesNumber, finalAct=\"sigmoid\"):\n\n # inizializzo il modello come sequenziale\n model = Sequential()\n inputShape = (imageHeight, imageWidth, imageDepth)\n chanDim = -1\n\n # Primo blocco Conv2D, Relu, Normalization, MaxPool\n # Utilizzo 32 filtri 3*3\n model.add(Conv2D(filters=32, kernel_size=(3, 3), padding=\"same\", input_shape=inputShape))\n # con attivazione Rectified Linear Unit\n model.add(Activation(\"relu\"))\n # applico una batch normalization\n model.add(BatchNormalization(axis=chanDim))\n # un MaxPooling 3*3\n model.add(MaxPooling2D(pool_size=(3, 3)))\n # ed un 25% di dropout per ridurre overfitting\n model.add(Dropout(0.25))\n\n # Secondo blocco\n model.add(Conv2D(64, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(Conv2D(64, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.25))\n\n # Terzo blocco\n model.add(Conv2D(128, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(Conv2D(128, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.25))\n\n # Passo ai Fully Connected Layers\n # Trasformo il modello in un vettore\n model.add(Flatten())\n model.add(Dense(1024))\n model.add(Activation(\"sigmoid\"))\n model.add(BatchNormalization())\n model.add(Dropout(0.5))\n\n # Infine utilizzo l'attivazione per la rete\n model.add(Dense(classesNumber))\n model.add(Activation(finalAct))\n\n return model","def encoder_decoder_archi_gan(inputs, is_train):\n\n encoder_layers = []\n\n encoded = inputs\n\n encoder_layers.append(encoded)\n\n for i in range(config.encoder_layers):\n encoded = encoder_conv_block_gan(encoded, i, is_train)\n encoder_layers.append(encoded)\n \n encoder_layers.reverse()\n\n\n\n decoded = encoder_layers[0]\n\n for i in range(config.encoder_layers):\n decoded = decoder_conv_block_gan(decoded, encoder_layers[i+1], i, is_train)\n\n return decoded","def loadGt(self):\n print('Loading and preparing results...')\n res = Pascal3D(self.cfg, self.dataset_dir, self.list_flag, self.transforms, self.training, load_cad=False)\n res.dataset = dict()\n res.dataset['categories'] = copy.deepcopy(self.category_to_id_map)\n res.dataset['images'] = []\n anns = []\n count = 1\n tic = time.time()\n for idx in tqdm(range(len(self.img_list_all))):\n res.dataset['images'].append({'id': self.img_list_all[idx]})\n if self.list_flag in ['train', 'val']:\n target = self._add_gt_annotations_Pascal3D(idx)\n\n for id in range(len(target)):\n ann = dict()\n ann['image_id'] = self.img_list_all[idx]\n ann['category_id'] = int(target.get_field('labels')[id].numpy())\n bb = target.bbox[id].numpy()\n x1, x2, y1, y2 = bb[0], bb[2], bb[1], bb[3]\n w = x2 - x1\n h = y2 - y1\n x_c = (x1 + x2)/2\n y_c = (y1 + y2)/2\n ann['bbox'] = [x_c, y_c, w, h]\n ann['area'] = w * h\n\n if target.has_field('segms'):\n ann['segms'] = target.get_field('segms')[id]\n # now only support compressed RLE format as segmentation results\n ann['area'] = maskUtils.area(ann['segms'])\n if not 'boxes' in ann:\n ann['boxes'] = maskUtils.toBbox(ann['segms'])\n\n ann['id'] = count\n ann['iscrowd'] = 0\n count += 1\n anns.append(ann)\n\n print('DONE (t={:0.2f}s)'.format(time.time() - tic))\n\n res.dataset['annotations'] = anns\n res.createIndex()\n return res","def extract_intrinsic_images_from_lighting_passes(self, outdir, vis=False):\n logger_name = thisfile + '->extract_intrinsic_images_from_lighting_passes()'\n xm.general.makedirs(outdir)\n data = self.data\n\n def collapse_passes(components):\n ch_arrays = []\n for ch in ['R', 'G', 'B']:\n comp_arrs = []\n for comp in components:\n comp_arrs.append(data[comp + '.' + ch])\n ch_array = np.sum(comp_arrs, axis=0) # sum components\n ch_arrays.append(ch_array)\n # Handle alpha channel\n first_alpha = data[components[0] + '.A']\n for ci in range(1, len(components)):\n assert (first_alpha == data[components[ci] + '.A']).all(), \\\n \"Alpha channels of all passes must be the same\"\n ch_arrays.append(first_alpha)\n return np.dstack(ch_arrays)\n\n # Albedo\n albedo = collapse_passes(['diffuse_color', 'glossy_color'])\n np.save(join(outdir, 'albedo.npy'), albedo)\n if vis:\n xm.vis.matrix_as_image(albedo, outpath=join(outdir, 'albedo.png'))\n # Shading\n shading = collapse_passes(['diffuse_indirect', 'diffuse_direct'])\n np.save(join(outdir, 'shading.npy'), shading)\n if vis:\n xm.vis.matrix_as_image(shading, join(outdir, 'shading.png'))\n # Specularity\n specularity = collapse_passes(['glossy_indirect', 'glossy_direct'])\n np.save(join(outdir, 'specularity.npy'), specularity)\n if vis:\n xm.vis.matrix_as_image(specularity, join(outdir, 'specularity.png'))\n # Reconstruction vs. ...\n recon = np.multiply(albedo, shading) + specularity\n recon[:, :, 3] = albedo[:, :, 3] # can't add up alpha channels\n np.save(join(outdir, 'recon.npy'), recon)\n if vis:\n xm.vis.matrix_as_image(recon, join(outdir, 'recon.png'))\n # ... composite from Blender, just for sanity check\n composite = collapse_passes(['composite'])\n np.save(join(outdir, 'composite.npy'), composite)\n if vis:\n xm.vis.matrix_as_image(composite, join(outdir, 'composite.png'))\n logger.name = logger_name\n logger.info(\"Intrinsic images extracted to %s\", outdir)","def build_conv_combo_autoencoder():\n input_img = Input(shape=(84, 84, 1))\n\n x = Convolution2D(48, 4, 4, activation='relu', border_mode='same', name='c1')(input_img)\n x = MaxPooling2D((2, 2), border_mode='same')(x)\n x = Convolution2D(48, 4, 4, activation='relu', border_mode='same', name='c2')(x)\n x = MaxPooling2D((3, 3), border_mode='same')(x)\n x = Flatten()(x)\n encoded = Dense(512, activation='relu')(x)\n\n encoded_input = Input((512,))\n d1 = Dense(9408, activation='relu')(encoded_input)\n d2 = Reshape((14, 14, 48))(d1)\n d3 = Convolution2D(48, 4, 4, activation='relu', border_mode='same', name='c5')(d2)\n d4 = UpSampling2D((3, 3))(d3)\n d5 = Convolution2D(48, 4, 4, activation='relu', border_mode='same', name='c6')(d4)\n d6 = UpSampling2D((2, 2))(d5)\n decoded = Convolution2D(1, 4, 4, activation='relu', border_mode='same', name='c9')(d6)\n\n encoder = Model(input=input_img, output=encoded, name='conv_encoder')\n decoder = Model(input=encoded_input, output=decoded, name='conv_decoder')\n\n autoencoder = Sequential(name='full_conv_autoencoder')\n autoencoder.add(encoder)\n autoencoder.add(decoder)\n\n encoder.compile(optimizer='adam', loss='mse')\n encoder.summary()\n decoder.compile(optimizer='adam', loss='mse')\n decoder.summary()\n autoencoder.compile(optimizer='adam', metrics=['mse'], loss='mse')\n autoencoder.summary()\n return autoencoder, encoder, decoder","def read():\n\n # load json and create model\n base_model = _model_builder.Network(0, model_type=\"load_model\")\n\n #load image and process\n digit = Image.open(\"./data/number.jpg\").convert(\"L\")\n digit = ImageOps.expand(digit,border=60,fill='black')\n digit = digit.resize((28, 28))\n\n #flatten the matrix (for input into MLP network todo:CNN)\n digit_flat = numpy.zeros((1, 784))\n counter = 0\n for j in range(0, 28):\n for i in range(0, 28):\n digit_flat[0][counter] = (digit.getpixel((i, j)))/255.0\n counter = counter+1\n\n #predict\n os.system('clear')\n base_model.predict(digit_flat)","def get_data(input_path):\n all_imgs = []\n classes_count = {}\n class_mapping = {}\n\n # parsing Flag\n visualise = False\n\n # MSCOCO directory\n data_path = input_path\n\n print('Parsing annotation files')\n annot_path = os.path.join(data_path, 'annotations_bbox')\n imgs_path = os.path.join(data_path, 'images')\n\n # images directory (train, val, trainval, test)\n imgsets_path_trainval = os.path.join(data_path, 'images', 'trainval.txt')\n imgsets_path_train = os.path.join(data_path, 'images', 'train.txt')\n imgsets_path_val = os.path.join(data_path, 'images', 'val.txt')\n imgsets_path_test = os.path.join(data_path, 'images', 'test.txt')\n\n trainval_files = []\n train_files = []\n val_files = []\n test_files = []\n\n with open(imgsets_path_trainval) as f:\n for line in f:\n trainval_files.append(line.strip())\n\n with open(imgsets_path_train) as f:\n for line in f:\n train_files.append(line.strip())\n\n with open(imgsets_path_val) as f:\n for line in f:\n val_files.append(line.strip())\n\n # test-set (default) not included in MSCOCO\n if os.path.isfile(imgsets_path_test):\n with open(imgsets_path_test) as f:\n for line in f:\n test_files.append(line.strip())\n\n # annotation read\n annots_train = json.load(open(os.path.join(annot_path, 'bbox_train2017.json'), 'r'))\n annots_val = json.load(open(os.path.join(annot_path, 'bbox_val2017.json'), 'r'))\n annots = dict()\n annots['train'] = annots_train\n annots['val'] = annots_val\n\n for part in ['train', 'val']:\n annots_keys = tqdm(annots[part].keys())\n for img_name in annots_keys:\n annots_keys.set_description(\"Processing %s\" % img_name)\n for bbox in annots[part][img_name]:\n class_name = bbox['label'].replace(' ', '')\n all_imgs.append({\n \"filepath\": os.path.join(data_path, 'images', '%s2017' % part, \"%s.jpg\" % img_name),\n \"width\": None,\n \"height\": None,\n \"bboxes\": [{\n \"class\": class_name,\n \"x1\": bbox['bbox']['x1'],\n \"y1\": bbox['bbox']['x2'],\n \"x2\": bbox['bbox']['y1'],\n \"y2\": bbox['bbox']['y2'],\n \"difficult\": False\n }],\n \"image_id\": img_name,\n \"imageset\": part\n })\n if class_name not in classes_count:\n classes_count[class_name] = 1\n else:\n classes_count[class_name] += 1\n if class_name not in class_mapping:\n class_mapping[class_name] = len(class_mapping)\n\n # visualise bounding boxes\n if visualise:\n img = cv2.imread(annotation_data['filepath'])\n for bbox in annotation_data['bboxes']:\n cv2.rectangle(img, (bbox['x1'], bbox['y1']), (bbox['x2'], bbox['y2']), (0, 0, 255))\n cv2.imshow('img', img)\n print(annotation_data['imageset'])\n cv2.waitKey(0)\n\n return all_imgs, classes_count, class_mapping","def loadRes(self, predictions):\n print('Loading and preparing results...')\n res = Pascal3D(self.cfg, self.dataset_dir, self.list_flag, self.transforms, self.training, load_cad=False)\n res.dataset = dict()\n res.dataset['categories'] = copy.deepcopy(self.category_to_id_map)\n res.dataset['images'] = []\n anns = []\n count = 1\n tic = time.time()\n masker = Masker(threshold=0.5, padding=1)\n\n for idx in tqdm(range(len(self.img_list_all))):\n res.dataset['images'].append({'id': self.img_list_all[idx]})\n prediction = predictions[idx]\n for id in range(len(prediction)):\n ann = dict()\n ann['image_id'] = self.img_list_all[idx]\n ann['category_id'] = int(prediction.get_field('labels')[id].cpu().numpy())\n bb = prediction.bbox[id].cpu().numpy()\n x1, x2, y1, y2 = bb[0], bb[2], bb[1], bb[3]\n w = x2 - x1\n h = y2 - y1\n x_c = (x1 + x2) / 2\n y_c = (y1 + y2) / 2\n ann['bbox'] = [x_c, y_c, w, h]\n ann['area'] = w * h\n ann['score'] = prediction.get_field('scores')[id].cpu().numpy()\n\n if prediction.has_field('mask'):\n image_width, image_height, _ = res.targets[idx]['record']['imgsize']\n\n masks = prediction.get_field('mask')\n # Masker is necessary only if masks haven't been already resized.\n if list(masks.shape[-2:]) != [image_height, image_width]:\n masks = masker(masks.expand(1, -1, -1, -1, -1), prediction)\n masks = masks[0]\n\n ann['segms'] = [maskUtils.encode(np.array(mask[0, :, :, np.newaxis], order=\"F\"))[0] for mask in masks]\n ann['category_id'] = int(prediction.get_field('labels')[id].cpu().numpy())\n # now only support compressed RLE format as segmentation results\n #ann['area'] = maskUtils.area(ann['segms'])\n if not 'boxes' in ann:\n ann['boxes'] = maskUtils.toBbox(ann['segms'])\n\n ann['id'] = count\n count += 1\n ann['iscrowd'] = 0\n anns.append(ann)\n\n print('DONE (t={:0.2f}s)'.format(time.time() - tic))\n res.dataset['annotations'] = anns\n res.createIndex()\n return res","def classify_images():\n\n # Load the desired image\n img_path = 'dataset/colorize_images/n02085782_919.jpg'\n img = image.load_img(img_path, target_size=(299, 299))\n x = image.img_to_array(img)\n x = np.expand_dims(x, axis=0)\n x = preprocess_input(x)\n\n model = InceptionV3(weights=\"imagenet\")\n preds = model.predict(x)\n # decode the results into a list of tuples (class, description, probability)\n # (one such list for each sample in the batch)\n print('Predicted:', decode_predictions(preds, top=3)[0])","def data_augmentation_and_vectorization(self,imlist, lb,im_labels, average_image = None):\n\t\tX,Y,X_original = [] ,[], []\n\n\t\ti = 0\n\t\tfor im in imlist:\n\t\t\tim=Image.fromarray(im,mode=self.mode)\n\t\t\t#try:\n\t\t\t#im_ini = im\n\t\t\tim_original = np.asarray(im, dtype=theano.config.floatX) / 256.\n\t\t\t#im = self.substract_average_image(im, average_image)\n\t\t\t#print 'i:{} is a: {}' .format(i,im_labels[i])\n\t\t\t#im.show()\n\t\t\tX_original.append(im_original)\n\n\t\t\t#Rotations \n\t\t\t#im_r = im.rotate(15)\n\t\t\t# im_r_2 = im.rotate(-15)\n\t\t\t# im_r_3 = im.rotate(180)\n\t\t\t#im_r.show()\n\t\t\t#im_r_2.show()\n\n\t\t\t#Filters\n\t\t\t#im_f = im_ini.filter(ImageFilter.DETAIL)\n\t\t\t#im_f = im.filter(ImageFilter.FIND_EDGES)\n\t\t\t\n\t\t\tif self.mode == 'RGB':\n\t\t\t\tim = np.asarray(im, dtype=theano.config.floatX) / 256.\n\t\t\t\t#Uncomment this if you want to use cross-correlate for 2D arrays http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.signal.correlate2d.html\n\t\t\t\t# im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t\t# im = sp.inner(im, [299, 587, 114]) / 1000.0\n\t\t\t\t# im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t\t# # normalize per http://en.wikipedia.org/wiki/Cross-correlation\n\t\t\t\t# im = (im - im.mean()) / im.std()\n\n\t\t\tif self.mode == 'L':\n\t\t\t\t# im = np.asarray(im, dtype='float64')\n\t\t\t\t# im = filters.sobel(im)\n\t\t\t\t#im = filters.roberts(im)\n\t\t\t\tim = np.asarray(im, dtype=theano.config.floatX) / 256.\n\t\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t\n\t\t\t#im = np.asarray(im, dtype=np.uint8)\n\t\t\t#print im.shape\n\t\t\t#print im.shape\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t#im = self.flaten_aux(im)\n\t\t\t#print im.shape\n\t\t\t#im = data.coins() # or any NumPy arr\n\t\t\t#print im.shape\n\t\t\t#image = data.coins() # or any NumPy array!\n\t\t\t#print im\n\t\t\t#im = filter.sobel(im)\n\t\t\t#im = filter.roberts(im)\n\n\t\t\t# im_original = sp.inner(im, [299, 587, 114]) / 1000.0\n\t\t\t# im_original = np.asarray(im_original, dtype=theano.config.floatX)\n\t\t\t# # normalize per http://en.wikipedia.org/wiki/Cross-correlation\n\t\t\t# im = (im_original - im_original.mean()) / im_original.std()\n\t\t\t#print im.shape\n\t\t\t#print edges\n\t\t\t# edges = np.asarray(edges, dtype=np.uint8)\n\t\t\t#Image.fromarray(edges,mode=self.mode).show()\n\n\t\t\t#print edges\n\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX) / 256.\n\n\t\t\t#print edges.shape\n\t\t\t# io.imshow(im)\n\t\t\t# io.show()\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t\n\t\t\t# plt.suptitle(im_labels[i], size=16)\n\t\t\t# plt.imshow(im, cmap=plt.cm.gray, interpolation='nearest')\n\t\t\t# plt.show()\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t#print im.shape\n\t\t\t#self.reconstructImage(im).show()\n\n\t\t\t#im_r = np.asarray(im_r, dtype=theano.config.floatX) / 256.\n\t\t\t# im_r_2 = np.asarray(im_r_2, dtype=theano.config.floatX) / 256.\n\t\t\t# im_r_3 = np.asarray(im_r_3, dtype=theano.config.floatX) / 256.\n\t\t\t#im_f = np.asarray(im_f, dtype=theano.config.floatX) / 256.\n\t\t\t\n\t\t\t#im = im.transpose(2, 0, 1)\n\t\t\t#X.append(np.array(im, dtype=theano.config.floatX))\n\t\t\t#X.append(np.array(im_raw, dtype=theano.config.floatX))\n\t\t\t#X.append(im)\n\t\t\tX.append(im)\n\t\t\t# if i % 100 == 0:\n\t\t\t# \tX.append(im)\n\t\t\t#X.append(im_r)\n\t\t\t# X.append(im_r_2)\n\t\t\t# X.append(im_r_3)\n\t\t\t#X.append(im_f)\n\t\t\t#X_original.append(im)\n\n\t\t\t# X.append(np.array(im_r, dtype=theano.config.floatX))\n\t\t\t# X.append(np.array(im_r_2, dtype=theano.config.floatX))\n\n\t\t\t#Uncomment this if you want to work with monochrome\n\t\t\t# im = im.convert('L')\n\t\t\t# pixels_monochrome = np.array(list(im.getdata()), dtype=np.float)\n\t\t\t\t\t\t\n\t\t\t# # scale between 0-1 to speed up computations\n\t\t\t# min_max_scaler = preprocessing.MinMaxScaler(feature_range=(0,1), copy=True)\n\t\t\t# pixels_monochrome = min_max_scaler.fit_transform(pixels_monochrome)\n\n\t\t\t# X.append(pixels_monochrome)\n\n\t\t\t#Y.append(lb.transform([im_labels[i]])[0][0])\n\t\t\t#print lb.transform([im_labels[i]])\n\t\t\t\n\t\t\tlabel = lb.transform([im_labels[i]])[0][0]\n\t\t\t#print lb.transform([im_labels[i]])\n\t\t\t# label_vector = lb.transform([im_labels[i]])[0]\n\t\t\t# label = np.where( label_vector == 1 )[0][0]\n\t\t\t# print \"Label: {}\".format(label)\n\t\t\t#print label\n\t\t\t#Y.append(label)\n\t\t\tY.append(label)\n\t\t\t#Y.append(im_labels[i])\t\n\n\t\t\t\n\t\t\t#Y.append(label)\t\n\t\t\t# Y.append(label)\t\n\t\t\t# except Exception, e:\n\t\t\t# \tprint e\n\t\t\t# \t#raise e\n\n\t\t\t# if i == 30:\n\t\t\t# \tbreak\n\n\t\t\ti += 1\n\t\t\tif self.verbose:\n\t\t\t\tsys.stdout.write(\"\\r Process: {0}/{1}\".format(i, len(imlist)))\n\t\t\t\tsys.stdout.flush()\n\t\t\n\t\t# output = open(self.data_path + 'X_original.pkl', 'wb')\n\t\t# cPickle.dump(X_original, output,protocol=-1)\n\t\t# output.close()\n\n\t\treturn X,Y","def train_one_epoch_Image_display(self):\n print('Training......')\n\n # set mode train\n self.network.train()\n\n # prepare data\n train_loss = 0\n transform = transforms.Compose([Rescale(params.rescale_size),\n RandomCrop(params.image_size),\n RandomHorizontalFlip(),\n ToTensor()\n ])\n\n\n\n dataset = Cityscapes(params.dataset_root, mode='train', transforms = transform)\n\n train_loader = DataLoader(dataset,\n batch_size=params.train_batch,\n shuffle=params.shuffle,\n num_workers=params.dataloader_workers)\n \n train_size = 1896\n if train_size % self.params.train_batch != 0:\n total_batch = train_size // self.params.train_batch + 1\n else:\n total_batch = train_size // self.params.train_batch\n recal = 0\n precision = 0\n F_one = 0\n IOU = 0\n accuracy_new = 0 \n # train through dataset\n for batch_idx, batch in enumerate(train_loader):\n self.pb.click(batch_idx, total_batch)\n image, label = batch['image'], batch['label']\n image_cuda, label_cuda = image.cuda(), label.cuda()\n\n # checkpoint split\n if self.params.should_split:\n image_cuda.requires_grad_()\n out = checkpoint_sequential(self.network, self.params.split, image_cuda)\n else:\n out = self.network(image_cuda)\n \n pred = image_cuda\n pred = pred.to(torch.device(\"cpu\"))\n pred = pred.detach()\n img_grid = pred[0]\n #img_grid = torchvision.utils.make_grid(out) \n img_grid = img_grid.numpy().transpose(1, 2, 0)*255\n cv2.imwrite(\"/content/drive/My Drive/Train_images/original%d.jpg\" % batch_idx, img_grid)\n\n \n loss = self.loss_fn(out, label_cuda)\n \n #display_image(out, label_cuda)\n TP, FP, TN, FN = confusion(out, label_cuda)\n recal = recal+TP\n precision = precision+FP\n F_one = F_one + TN\n IOU = IOU+ FN \n _,predict = torch.max(out.data,1)\n predict = predict.to(torch.device(\"cpu\"))\n predict = predict.detach()\n img = predict[0]\n img = img.numpy()*255\n #img_grid = torchvision.utils.make_grid(out) \n cv2.imwrite(\"/content/drive/My Drive/Train_images/predict_label%d.png\" % batch_idx, img)\n label = label_cuda.to(torch.device(\"cpu\"))\n label = label.detach()\n label = label[0].numpy()*255\n cv2.imwrite(\"/content/drive/My Drive/Train_images/original_label%d.png\" % batch_idx, label)\n\n \n \n\n accuracy_final = accuracy(out, label_cuda)\n accuracy_new = accuracy_new + accuracy_final\n\n \n print(\"\\t\")\n print(recal/total_batch, precision/ total_batch, F_one/ total_batch, IOU/ total_batch)\n print(accuracy_new/total_batch)","def data_augmentation(im_list, mode='standard', tag=False, params=None, im_size=224,\n filemode='local', mean_RGB=None):\n if mean_RGB is None:\n mean_RGB = np.array([107.59348955, 112.1047813, 80.9982362])\n else:\n mean_RGB = np.array(mean_RGB)\n rot_ang = [0, 90, 180, 270]\n batch = []\n if tag:\n tag_list = im_list[:, 1]\n im_list = im_list[:, 0]\n if mode == 'minimal':\n params = {'mirror': False, 'rescale': False, 'crop_size': False}\n if mode == 'standard':\n params = {'mirror': True, 'rescale': 0.3, 'zoom': 0.3, 'crop_size': 1.}\n if mode == 'test':\n params = {'mirror': True, 'rescale': 0.1, 'zoom': 0.1, 'crop_size': .9}\n for i, filename in enumerate(im_list):\n if filemode == 'local':\n im = Image.open(filename)\n im = im.convert('RGB')\n elif filemode == 'url':\n filename = BytesIO(requests.get(filename).content)\n im = Image.open(filename)\n im = im.convert('RGB')\n if params['mirror'] and np.random.random() > 0.5:\n im = im.transpose(Image.FLIP_LEFT_RIGHT)\n if params['mirror'] and tag and tag_list[i] != 'habit':\n if np.random.random() > 0.5:\n im = im.transpose(Image.FLIP_TOP_BOTTOM)\n rot = np.random.choice(rot_ang)\n if rot == 90:\n im = im.transpose(Image.ROTATE_90)\n if rot == 180:\n im = im.transpose(Image.ROTATE_180)\n if rot == 270:\n im = im.transpose(Image.ROTATE_270)\n if params['rescale']:\n rescale = params['rescale']\n new_scale = np.random.uniform(low=1.-rescale, high=1.+rescale, size=2)\n im = im.resize((im.size * new_scale).astype(int))\n if params['crop_size']:\n zoom = np.random.rand() * params['zoom']\n crop_size = params['crop_size'] * (1.-zoom)\n ly, lx = im.size\n min_side = min([ly, lx])\n if crop_size == 1:\n crop_size -= 1e-10 # avoid low=high problem of randint generator\n if ly > lx:\n rand_x = np.random.randint(low=0, high=lx*(1.-crop_size))\n rand_y = np.random.randint(low=0, high=ly-lx*crop_size)\n else:\n rand_x = np.random.randint(low=0, high=lx-ly*crop_size)\n rand_y = np.random.randint(low=0, high=ly*(1.-crop_size))\n rand_xy = np.array([rand_y, rand_x])\n im = im.crop(np.concatenate((rand_xy, rand_xy+crop_size*min_side)))\n im = im.resize((im_size, im_size))\n batch.append(np.array(im)) # shape (N, 224, 224, 3)\n\n batch = np.array(batch) - mean_RGB[None, None, None, :] # mean centering\n batch = batch.transpose(0, 3, 1, 2) # shape(N, 3, 224, 224)\n batch = batch[:, ::-1, :, :] # switch from RGB to BGR\n return batch.astype(np.float32)","def image_network_train(learn_data_path):\n\n # data selector ----------\n use_da_data = False\n increase_val = False\n print( \"\\nmode: Use Augmented data: {} | increase validation data: {}\".format(use_da_data, increase_val) )\n\n # First define original train_data only as train_dir\n train_dir = os.path.join(data_dir, \"train\")\n if (use_da_data == True) and (increase_val == False):\n # with_augmented data (no validation increase)\n train_dir = os.path.join(data_dir, \"train_with_aug\")\n validation_dir = os.path.join(data_dir, \"val\") # original validation data\n\n # pair of decreaced train_data and increased validation data\n if (increase_val == True):\n train_dir = os.path.join(data_dir, \"red_train\")\n if (use_da_data == True):\n train_dir = os.path.join(data_dir, \"red_train_with_aug\")\n validation_dir = os.path.join(data_dir, \"validation\")\n\n test_dir = os.path.join(data_dir, \"test\")\n\n print(\"\\ntrain_dir: \", train_dir)\n print(\"validation_dir: \", validation_dir)\n\n\n # calcucate the num of category\n num_category = 0\n for dirpath, dirnames, filenames in os.walk(train_dir):\n for dirname in dirnames:\n num_category += 1\n\n # All images will be resized to 299x299\n image_size = 299\n batch_size = 16\n\n # Rescale all images by 1./255 and apply image augmentation\n train_datagen = keras.preprocessing.image.ImageDataGenerator(rescale=1./255)\n validation_datagen = keras.preprocessing.image.ImageDataGenerator(rescale=1./255)\n test_datagen = keras.preprocessing.image.ImageDataGenerator(rescale=1./255)\n\n # Flow training images in batches of using train_datagen generator\n train_generator = train_datagen.flow_from_directory(\n train_dir, # Source directory for the training images\n target_size=(image_size, image_size),\n batch_size=batch_size,\n class_mode='categorical')\n\n # Flow validation images in batches of 20 using validation_datagen generator\n validation_generator = validation_datagen.flow_from_directory(\n validation_dir, # Source directory for the validation images\n target_size=(image_size, image_size),\n batch_size=batch_size,\n class_mode='categorical')\n\n # Flow validation images in batches of 20 using test_datagen generator\n test_generator = test_datagen.flow_from_directory(\n test_dir, # Source directory for the test images\n target_size=(image_size, image_size),\n batch_size=batch_size,\n class_mode='categorical')\n\n # Create the base model from the pre-trained convnets\n IMG_SHAPE = (image_size, image_size, 3)\n\n # Create the base model from the pre-trained model MobileNet V2\n base_model = keras.applications.xception.Xception(input_shape=IMG_SHAPE, include_top=False, weights='imagenet')\n\n # Freeze the convolutional base\n base_model.trainable = False\n\n # モデル\n model = keras.Sequential([\n base_model,\n keras.layers.GlobalAveragePooling2D(),\n keras.layers.Dense(num_category, activation='softmax')\n ])\n\n # Compile the model\n model.compile(optimizer=keras.optimizers.Adam(lr=0.0001),\n loss='categorical_crossentropy',\n metrics=['accuracy'])\n\n # early stopping\n es = keras.callbacks.EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)\n\n model.summary()\n\n # 更新される重みの数\n print('after', len(model.trainable_weights))\n\n # Train the model\n epochs = 30\n steps_per_epoch = train_generator.n // batch_size\n validation_steps = validation_generator.n // batch_size\n test_steps = test_generator.n // batch_size\n\n history = model.fit_generator(train_generator,\n steps_per_epoch = steps_per_epoch,\n epochs=epochs,\n workers=4,\n validation_data=validation_generator,\n validation_steps=validation_steps,\n callbacks=[es],\n class_weight={0:1.0, 1:0.4})\n\n loss, acc = model.evaluate_generator(validation_generator, steps=validation_steps)\n print('val loss: {}, val acc: {}'.format(loss, acc))\n\n # Fine tuning\n # Un-freeze the top layers of the model\n base_model.trainable = True\n\n # The nums of layers are in the base model\n print(\"Number of layers in the base model: \", len(base_model.layers))\n\n # Fine tune from this layer onwards\n fine_tune_at = 108\n\n # Freeze all the layers before the `fine_tune_at` layer\n for layer in base_model.layers[:fine_tune_at]:\n layer.trainable = False\n\n # Compile the model using a much-lower training rate\n model.compile(optimizer = keras.optimizers.Adam(lr=2e-5),\n loss='categorical_crossentropy',\n metrics=['accuracy'])\n\n model.summary()\n\n # 更新される重みの数\n print('after Fine tune', len(model.trainable_weights))\n\n # Continue Train the model\n history_fine = model.fit_generator(train_generator,\n steps_per_epoch = steps_per_epoch,\n epochs=epochs,\n workers=4,\n validation_data=validation_generator,\n validation_steps=validation_steps,\n callbacks=[es],\n class_weight={0:1.0, 1:0.4})\n\n\n # print(history_fine.history)\n model_val_acc = history_fine.history['val_accuracy'][-1]\n print('val_acc: ', model_val_acc)\n\n # save model into hdf5 file ----------\n model.save(learn_data_path + '/shen_model.h5')\n\n loss, acc = model.evaluate_generator(validation_generator, steps=validation_steps)\n print('val loss: {}, val acc: {}'.format(loss, acc))\n\n loss, acc = model.evaluate_generator(test_generator, steps=test_steps)\n print('Test loss: {}, Test acc: {}'.format(loss, acc))","def build_layers(self):\n raise NotImplementedError","def __call__(self, in_data):\n # There are five data augmentation steps\n # 1. Color augmentation\n # 2. Random expansion\n # 3. Random cropping\n # 4. Resizing with random interpolation\n # 5. Random horizontal flipping\n if self.count % 10 == 0 and self.count % self.batchsize == 0 and self.count != 0:\n self.i += 1\n i = self.i % len(self.dim)\n self.output_shape = (self.dim[i], self.dim[i])\n # print(self.count, self.i, self.output_shape)\n self.count += 1\n\n img, bbox, label = in_data\n\n # 1. Color augmentation\n img = random_distort(img, brightness_delta=32,\n contrast_low=0.5, contrast_high=1.5,\n saturation_low=0.5, saturation_high=1.5,\n hue_delta=25)\n\n # Normalize. range is [0, 1]\n img /= 255.0\n\n _, H, W = img.shape\n scale = np.random.uniform(0.25, 2)\n random_expand = np.random.uniform(0.8, 1.2, 2)\n net_h, net_w = self.output_shape\n out_h = net_h * scale # random_expand[0]\n out_w = net_w * scale # random_expand[1]\n if H > W:\n out_w = out_h * (float(W) / H) * np.random.uniform(0.8, 1.2)\n elif H < W:\n out_h = out_w * (float(H) / W) * np.random.uniform(0.8, 1.2)\n\n out_h = int(out_h)\n out_w = int(out_w)\n\n img = resize_with_random_interpolation(img, (out_h, out_w))\n bbox = transforms.resize_bbox(bbox, (H, W), (out_h, out_w))\n\n if out_h < net_h and out_w < net_w:\n img, param = expand(img, out_h=net_h, out_w=net_w,\n fill=self.value, return_param=True)\n bbox = transforms.translate_bbox(\n bbox, y_offset=param['y_offset'], x_offset=param['x_offset'])\n else:\n out_h = net_h if net_h > out_h else int(out_h * 1.05)\n out_w = net_w if net_w > out_w else int(out_w * 1.05)\n img, param = expand(img, out_h=out_h, out_w=out_w,\n fill=self.value, return_param=True)\n bbox = transforms.translate_bbox(\n bbox, y_offset=param['y_offset'], x_offset=param['x_offset'])\n\n img, param = crop_with_bbox_constraints(\n img, bbox, return_param=True,\n crop_height=net_h, crop_width=net_w)\n bbox, param = transforms.crop_bbox(\n bbox, y_slice=param['y_slice'], x_slice=param['x_slice'],\n allow_outside_center=False, return_param=True)\n label = label[param['index']]\n\n\n # 5. Random horizontal flipping # OK\n img, params = transforms.random_flip(\n img, x_random=True, return_param=True)\n bbox = transforms.flip_bbox(\n bbox, self.output_shape, x_flip=params['x_flip'])\n\n # Preparation for Yolov2 network\n bbox[:, ::2] /= self.output_shape[0] # y\n bbox[:, 1::2] /= self.output_shape[1] # x\n\n num_bbox = len(bbox)\n len_max = max(num_bbox, self.max_target)\n\n gmap = create_map_anchor_gt(bbox, self.anchors, self.output_shape,\n self.downscale, self.n_boxes, len_max)\n\n out_bbox = np.zeros((len_max, 4), dtype='f')\n out_bbox[:num_bbox] = bbox[:num_bbox]\n out_label = np.zeros((len_max), dtype='i')\n out_label[:num_bbox] = label\n\n gmap = gmap[:self.max_target]\n out_bbox = out_bbox[:self.max_target]\n out_label = out_label[:self.max_target]\n num_array = min(num_bbox, self.max_target)\n\n img = np.clip(img, 0, 1)\n return img, out_bbox, out_label, gmap, np.array([num_array], dtype='i')","def get_classification(self, image):\n if self.correct_gamma:\n if self.gamma == 1.0:\n self.gamma = 0.6\n elif self.gamma == 0.6:\n self.gamma = 1.0\n image = self.adjust_gamma(image, self.gamma)\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n image_np = np.asarray(image, dtype=\"uint8\")\n image_np_expanded = np.expand_dims(image_np, axis=0)\n\n detected = False\n\n with self.detection_graph.as_default():\n (boxes, scores, classes, num) = self.sess.run(\n [self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections],\n feed_dict={self.image_tensor: image_np_expanded})\n boxes = np.squeeze(boxes)\n classes = np.squeeze(classes).astype(np.int32)\n scores = np.squeeze(scores)\n best_scores = []\n\n for idx, classID in enumerate(classes):\n if self.MODEL_NAME == 'ssdlite_mobilenet_v2_coco_2018_05_09':\n if classID == 10: # 10 is traffic light\n if scores[idx] > 0.10: #confidence level\n best_scores.append([scores[idx], idx, classID])\n detected = True\n else: # we tuned the model to classify only traffic lights\n if scores[idx] > 0.10: # confidence level\n best_scores.append([scores[idx], idx, classID])\n detected = True\n\n tl_index = TrafficLight.UNKNOWN\n if detected:\n best_scores.sort(key=lambda tup: tup[0], reverse=True)\n\n best_score = best_scores[0]\n rospy.logdebug(\"number of TL found %d, best score: %f, color: %f\", len(best_scores), best_score[0], best_score[2])\n nbox = boxes[best_score[1]]\n\n height = image.shape[0]\n width = image.shape[1]\n\n box = np.array([nbox[0]*height, nbox[1]*width, nbox[2]*height, nbox[3]*width]).astype(int)\n box_height = box[2] - box[0]\n box_width = box[3] - box[1]\n ratio = float(box_height)/float(box_width)\n rospy.logdebug(\"ratio: %f\", ratio)\n if ratio >= 2.0 and ratio < 3.0: #started from 2.4\n tl_cropped = image[box[0]:box[2], box[1]:box[3]]\n tl_color, tl_index = self.get_color(tl_cropped)\n #color = ['RED', 'YELLOW', 'GREEN', 'UNKNOWN']\n #tl_index = best_score[2]\n #tl_color = color[tl_index]\n #augment image with detected TLs\n cv2.rectangle(image, (box[1], box[0]), (box[3], box[2]), (0, 255, 0), 2)\n font = cv2.FONT_HERSHEY_SIMPLEX\n font_color = (255, 255, 255)\n cv2.putText(image, tl_color, (box[1], box[0]), font, 2.0, font_color, lineType=cv2.LINE_AA)\n return image, tl_index","def generate_maps(dl: DatasetLoader, model, map_out: str, graph, all_classes=True, batch_size=10, mode='cv2'):\n # o_generator = get_outputs_generator(model, 'CAM')\n input = model.input\n output = model.get_layer('CAM').output\n output_predict = model.get_layer('W').output\n output_fn = K.function([input], [output])\n fn_predict = K.function([input], [output_predict])\n\n o_resizer = tf.image.resize_images\n o_dot = K.dot\n\n # plot CAMs only for the validation data:\n k = 0\n counter = 0\n img_arr = []\n with K.get_session() as sess:\n in_place = tf.placeholder(tf.float32, [None, None, None, 512])\n size_place = tf.placeholder(tf.int32, [2])\n convert_place = tf.placeholder(tf.float32, [512, len(dl.directories)])\n first_func = o_resizer(in_place, size_place, ResizeMethod.BICUBIC)\n second_func = o_dot(in_place, convert_place)\n graph.finalize()\n\n for i in range(dl.number_of_imgs_for_train, dl.number_of_imgs):\n with graph.as_default() as gr:\n if i == dl.number_of_imgs - 1:\n k = batch_size - 1\n rpath = dl.baseDirectory + \"/\" + dl.imgDataArray[i].directory + \"/\" + dl.imgDataArray[i].name\n img = cv2.imread(rpath, cv2.IMREAD_COLOR)\n # print('!!!!!!!!debug', rpath, i)\n img_arr.append(img)\n k += 1\n if k == batch_size:\n start_time = time.time()\n predict_input = np.asarray(img_arr, dtype='float32')\n predict_input = preprocess_input(predict_input)\n\n k = 0\n img_arr = []\n\n layer_outputs = output_fn([predict_input])[0]\n predictions = fn_predict([predict_input])[0]\n\n if mode == 'cv2': # model, layer_outputs, nb_classes, im_width=256):\n maps_arr = cam_generate_cv2(model, layer_outputs, dl.nb_classes)\n else:\n maps_arr = cam_generate_tf_ops(model, layer_outputs, sess, first_func, second_func, in_place,\n size_place,\n convert_place)\n\n for l, prediction in enumerate(predictions):\n inc = i - batch_size + l + 1\n outpath = map_out + \"/\" + dl.imgDataArray[inc].directory + \"/\" + dl.imgDataArray[inc].name\n # print('[DEBUG]', outpath, inc, i, batch_size, l)\n\n try:\n os.makedirs(outpath)\n except OSError:\n continue\n\n value = np.argmax(prediction)\n if all_classes:\n a = 0\n b = dl.nb_classes\n else:\n a = value\n b = value + 1\n for j in range(a, b):\n outname = outpath + \"/\" + str(j) + '.tiff'\n if mode == 'cv2':\n Image.fromarray(maps_arr[l][j]).save(outname)\n else:\n Image.fromarray(maps_arr[l, :, :, j]).save(outname)\n with open(outpath + '/resuts.json', 'w') as outfile:\n json.dump({'predicted': str(value), \"true_label\": str(dl.imgDataArray[inc].img_class)},\n outfile)\n print(\"cam(\", counter, \"/\", dl.number_of_imgs_for_test, \"completed\")\n counter += 1\n print(\"got cams in\", time.time() - start_time)","def augment():\n print(\"augmenting......\")\n path1 = '../trainp1/'\n path2 = '../trainp2/'\n # path of pair1 and pair2 similar to img & mask task for segmentation\n p = Augmentor.Pipeline(path1) # pair1\n p.ground_truth(path2) # pair2\n p.rotate(probability=0.3, max_left_rotation=3, max_right_rotation=3) \n p.flip_left_right(probability=0.2) \n p.random_distortion(0.5, 2, 2, 2)\n p.zoom(probability=0.5, min_factor=0.95, max_factor=1.05)\n p.process()","def run_all_layers(self, img): # noqa\n s1_outputs = [s1(img) for s1 in self.s1_units]\n\n # Each C1 layer pools across two S1 layers\n c1_outputs = []\n for c1, i in zip(self.c1_units, range(0, len(self.s1_units), 2)):\n c1_outputs.append(c1(s1_outputs[i:i+2]))\n\n s2_outputs = [s2(c1_outputs) for s2 in self.s2_units]\n c2_outputs = [c2(s2) for c2, s2 in zip(self.c2_units, s2_outputs)]\n\n return s1_outputs, c1_outputs, s2_outputs, c2_outputs","def get_model(summary=False):\n\timage_input=Input(shape=(220,220,5),name='image_input')\n\tbranch1_conv1=Conv2D(64, kernel_size=(3, 3), border_mode='same', input_shape=(220,220,5), activation='relu')(image_input)\n\tbranch1_conv2=Conv2D(64, kernel_size=(1, 1), border_mode='same', activation='relu')(branch1_conv1)\t\n\tbranch1_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch1_conv1)\n\tbranch2_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch1_pool1)\n\tbranch2_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch2_conv1)\t\n\tbranch2_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch2_conv2)\n\tbranch3_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch2_pool1)\n\tbranch3_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch3_conv1)\t\n\tbranch3_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch3_conv2)\n\tbranch4_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch3_pool1)\n\tbranch4_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch4_conv1)\t\n\tbranch4_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch4_conv2)\n\tbranch5_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch4_pool1)\n\tbranch5_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch5_conv1)\t\n\tbranch5_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch5_conv2)\n\tbranch6_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch5_pool1)\n\tbranch6_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch6_conv1)\t\n\tbranch6_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch6_conv2)\n\tbranch1_flat=Flatten()(branch6_pool1)\n\tdrop=Dropout(.3)(branch1_flat)\n\t# FC layers group\n\tdense1=Dense(512, activation='relu', name='fc1')(drop)\n\tdrop1=Dropout(.3)(dense1)\n\tdense2=Dense(256, activation='relu', name='fc2')(drop1)\n\tdrop3=Dropout(.3)(dense2)\n\tout=Dense(2, activation='softmax', name='fc4')(drop3)\n\tmodel=Model(inputs=image_input,outputs=out)\n\treturn model","def train(args):\n # Create the data loader\n loader = sunnerData.DataLoader(\n dataset = sunnerData.ImageDataset(\n root = [[args.train]],\n transforms = transforms.Compose([\n \n# transforms.RandomCrop(720,720)\n# transforms.RandomRotation(45)\n# transforms.RandomHorizontalFlip(), \n# transforms.ColorJitter(brightness=0.5, contrast=0.5),\n \n\n sunnerTransforms.Resize(output_size = (args.H, args.W)),\n #transforms.RandomCrop(512,512)\n sunnerTransforms.ToTensor(),\n sunnerTransforms.ToFloat(),\n # sunnerTransforms.Transpose(),\n sunnerTransforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),\n ])\n ), batch_size = args.batch_size, shuffle = True, num_workers = 2\n )\n loader = sunnerData.IterationLoader(loader, max_iter = args.n_iter)\n\n # Create the model\n model = GANomaly2D(r = args.r, device = args.device)\n model.IO(args.resume, direction = 'load')\n model.train()\n \n # Train!\n bar = tqdm(loader)\n for i, (normal_img,) in enumerate(bar):\n model.forward(normal_img)\n model.backward()\n loss_G, loss_D = model.getLoss()\n bar.set_description(\"Loss_G: \" + str(loss_G) + \" loss_D: \" + str(loss_D))\n bar.refresh()\n if i % args.record_iter == 0:\n model.eval()\n with torch.no_grad():\n z, z_ = model.forward(normal_img)\n img, img_ = model.getImg()\n visualizeEncoderDecoder(img, img_, z, z_,i)\n model.train()\n model.IO(args.det, direction = 'save')\n model.IO(args.det, direction = 'save')","def image_to_feature(image_full_path, boundingBox, encoder, features_to_use, autocrop=False):\n imgcrop = rgb_image_bounding_box(image_full_path, boundingBox, autocrop=autocrop)\n imgresize = cv2.resize(imgcrop, (128, 128))\n imgresize = imgresize / 255.\n imgresize = imgresize.astype('float32')\n encoded_image = encoder.predict(imgresize[None, :, :, :])\n # print(input_img.shape)\n grayscale = cv2.cvtColor(imgresize, cv2.COLOR_BGR2GRAY)\n fd = hog(grayscale, orientations=4, pixels_per_cell=(16, 16), cells_per_block=(1, 1), visualise=False)\n fd = fd / np.max(fd)\n encoded_image = encoded_image / np.max(encoded_image)\n hsv_img = cv2.cvtColor(imgcrop, cv2.COLOR_BGR2HSV)\n hsv_hlist = []\n num_h_elements = np.prod(hsv_img.shape[:2])\n for channel, (range, nbins) in enumerate(zip([180, 255, 255], [10, 4, 4])): # unsure if ch1 is 180 or 360\n hsv_h, bins = np.histogram(hsv_img[:, :, channel], range=(0, range), bins=nbins)\n hsv_hlist.append(hsv_h / num_h_elements)\n hsv = np.concatenate(hsv_hlist, axis=0)\n if features_to_use == \"All\":\n fv = np.concatenate((fd, hsv, encoded_image.ravel()))\n elif features_to_use == \"encoder\":\n fv = encoded_image.ravel()\n elif features_to_use == \"hog\":\n fv = fd\n elif features_to_use == \"hsv\":\n fv = hsv\n return fv","def mgcNetArchRes(outLayer, l2_val, **kwargs):\n\n def_vals = {\"input_img_rows\" : 72,\n \"input_img_cols\" : 72,\n \"channels\" : 1,\n \"nb_classes\" : 13\n } # default parameters value\n\n for k, v in def_vals.items():\n kwargs.setdefault(k, v)\n\n input_img_rows = kwargs['input_img_rows']\n input_img_cols = kwargs['input_img_cols']\n channels = kwargs['channels']\n nb_classes = kwargs['nb_classes']\n\n \n # Input: 72 x 72 x 1\n img_shape = layers.Input(shape = (input_img_rows, input_img_cols, channels))\n\n # Layer 1\n #------------------------\n conv1 = layers.Conv2D(filters=32, kernel_size=(2, 2), padding='same', kernel_regularizer=regularizers.l2(l2_val))(img_shape)\n conv1 = layers.Activation('relu')(conv1)\n conv1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)\n conv1 = layers.Dropout(0.4)(conv1)\n \n conv1 = residual_block(img_shape, 32, _strides=(1, 1), _project_shortcut=False)\n\n # Layer 2\n #------------------------\n conv2 = residual_block(conv1, 32, _strides=(1, 1), _project_shortcut=False)\n\n # Layer 3\n #------------------------\n conv3 = residual_block(conv2, 32, _strides=(1, 1), _project_shortcut=False)\n \n # Layer 4\n # -----------------------\n #residual = residual_block(conv3, 64, _strides=(1, 1), _project_shortcut=False)\n\n # Layer 5\n #------------------------\n output = layers.Conv2D(filters=128, kernel_size=(2,2), padding='same', kernel_regularizer=regularizers.l2(l2_val))(conv3) # skip layer 4\n output = layers.Activation('relu')(output)\n output = layers.Conv2D(filters=64, kernel_size=(2,2), padding='same', activation='relu', strides = 2)(output) \n output = layers.Dropout(0.4)(output)\n\n\n \n # FC Layer\n #------------------------\n outputmlp = layers.Flatten()(output)\n outputmlp = layers.Dense(64, activation = 'relu')(outputmlp)\n outputmlp = layers.Dropout(0.5)(outputmlp)\n\n predictionsMlp = layers.Dense(nb_classes, activation='softmax')(outputmlp)\n \n \n # global averaging\n weight_decay=1E-4\n concat_axis = 1\n \n x = BatchNormalization(axis=concat_axis,\n gamma_regularizer=regularizers.l2(weight_decay),\n beta_regularizer=regularizers.l2(weight_decay))(output)\n x = Activation('relu')(x)\n x = layers.Dropout(0.4)(x)\n x = GlobalAveragePooling2D(data_format=K.image_data_format())(x)\n \n predictionsGloAvg = layers.Dense(nb_classes,\n activation='softmax',\n kernel_regularizer=regularizers.l2(weight_decay),\n bias_regularizer=regularizers.l2(weight_decay))(x)\n \n if outLayer == \"gloAvg\":\n predictions = predictionsGloAvg\n elif outLayer == \"mlp\":\n predictions = predictionsMlp\n \n # prediction model\n model = Model(img_shape, predictions, name = 'resblock')\n\n return model","def mgcNetArchMax(outLayer, l2_val, **kwargs):\n\n def_vals = {\"input_img_rows\" : 72,\n \"input_img_cols\" : 72,\n \"channels\" : 1,\n \"nb_classes\" : 13\n } # default parameters value\n\n for k, v in def_vals.items():\n kwargs.setdefault(k, v)\n\n input_img_rows = kwargs['input_img_rows']\n input_img_cols = kwargs['input_img_cols']\n channels = kwargs['channels']\n nb_classes = kwargs['nb_classes']\n\n \n # Input: 72 x 72 x 1\n img_shape = layers.Input(shape = (input_img_rows, input_img_cols, channels))\n\n # Layer 1\n #------------------------\n conv1 = layers.Conv2D(filters=32, kernel_size=(2, 2), padding='same', kernel_regularizer=regularizers.l2(l2_val))(img_shape)\n conv1 = layers.Activation('relu')(conv1)\n conv1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)\n conv1 = layers.Dropout(0.4)(conv1)\n\n # Layer 2\n #------------------------\n conv2 = layers.Conv2D(filters=64, kernel_size=(2,2), padding='same', kernel_regularizer=regularizers.l2(l2_val))(conv1)\n conv2 = layers.Activation('relu')(conv2) \n conv2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)\n conv2 = layers.Dropout(0.4)(conv2)\n\n # Layer 3\n #------------------------\n conv3 = layers.Conv2D(filters=128, kernel_size=(2,2), padding='same', kernel_regularizer=regularizers.l2(l2_val))(conv2)\n conv3 = layers.Activation('relu')(conv3) \n conv3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)\n conv3 = layers.Dropout(0.4)(conv3)\n\n # Layer 4\n #------------------------\n conv4 = layers.Conv2D(filters=256, kernel_size=(2,2), padding='same', dilation_rate = (2, 2), kernel_regularizer=regularizers.l2(l2_val))(conv3)\n conv4 = layers.Activation('relu')(conv4)\n conv4 = layers.MaxPooling2D(pool_size=(2, 2))(conv4)\n conv4 = layers.Dropout(0.4)(conv4)\n\n # Layer 5\n #------------------------\n output = layers.Conv2D(filters=128, kernel_size=(2,2), padding='same', kernel_regularizer=regularizers.l2(l2_val))(conv3) # skip layer 4\n output = layers.Activation('relu')(output) \n output = layers.MaxPooling2D(pool_size=(2, 2))(output)\n output = layers.Dropout(0.4)(output)\n\n\n \n # FC Layer\n #------------------------\n outputmlp = layers.Flatten()(output)\n outputmlp = layers.Dense(64, activation = 'relu')(outputmlp)\n outputmlp = layers.Dropout(0.5)(outputmlp)\n\n predictionsMlp = layers.Dense(nb_classes, activation='softmax')(outputmlp)\n \n \n # global averaging\n weight_decay=1E-4\n concat_axis = 1\n \n x = BatchNormalization(axis=concat_axis,\n gamma_regularizer=regularizers.l2(weight_decay),\n beta_regularizer=regularizers.l2(weight_decay))(output)\n x = Activation('relu')(x)\n x = layers.Dropout(0.4)(x)\n x = GlobalAveragePooling2D(data_format=K.image_data_format())(x)\n \n predictionsGloAvg = layers.Dense(nb_classes,\n activation='softmax',\n kernel_regularizer=regularizers.l2(weight_decay),\n bias_regularizer=regularizers.l2(weight_decay))(x)\n \n if outLayer == \"gloAvg\":\n predictions = predictionsGloAvg\n elif outLayer == \"mlp\":\n predictions = predictionsMlp\n \n # prediction model\n model = Model(img_shape, predictions, name = 'cnn_max')\n\n return model","def get_classification(self, image):\n\n image_np_expanded = np.expand_dims(image, axis=0)\n\n # Perform network inference\n with self.detection_graph.as_default():\n (boxes, scores, classes, num) = self.sess.run(\n [self.detection_boxes, self.detection_scores,\n self.detection_classes, self.num_detections],\n feed_dict={self.image_tensor: image_np_expanded})\n\n boxes = np.squeeze(boxes)\n scores = np.squeeze(scores)\n classes = np.squeeze(classes).astype(np.int32)\n\n if self.RUNNING_ON_CARLA == True:\n for i in range(boxes.shape[0]):\n if scores is None or scores[i] > .05:\n if classes[i] == 10:\n classname = self.category_index[classes[i]]['name']\n print(classname, scores[i])\n\n # Extract image from best bounding box and pass through light classifier\n ymin, xmin, ymax, xmax = boxes[i]\n im_height, im_width, im_depth = image.shape\n (left, right, top, bottom) = (xmin * im_width, xmax * im_width, ymin * im_height, ymax * im_height)\n tf_image_cropped = image[int(top):int(bottom), int(left):int(right), :]\n\n PILImage = Image.fromarray(tf_image_cropped)\n resized_img = PILImage.resize((85, 256), Image.ANTIALIAS)\n image_np_resized = self.load_image_into_numpy_array(resized_img)\n x = np.expand_dims(image_np_resized, axis=0)\n x = np.vstack([x])\n\n #model = load_model('tf_classifier_1.h5')\n #model.compile(loss='categorical_crossentropy',\n # optimizer='adam',\n # metrics=['accuracy'])\n classes = self.keras_model.predict_classes(x, batch_size=1)\n print(classes)\n\n if classes[0] == 0:\n self.current_light = TrafficLight.GREEN\n elif classes[0] == 2:\n self.current_light = TrafficLight.YELLOW\n else:\n self.current_light = TrafficLight.RED\n\n break\n\n else:\n # Check the detections. If it has a good score\n # then set the current light to the detected label. The\n # first one is always the best (they are returned sorted \n # in score order).\n # Note that we have trained for 14 categories, including\n # left/right arrows etc. Here we are only looking for \n # standard red, yellow and green light and ignore others.\n for i in range(boxes.shape[0]):\n if scores is None or scores[i] > .05:\n classname = self.category_index[classes[i]]['name']\n print(classname, scores[i])\n\n if classname == 'Green':\n self.current_light = TrafficLight.GREEN\n elif classname == 'Yellow':\n self.current_light = TrafficLight.YELLOW\n elif classname == 'Red':\n self.current_light = TrafficLight.RED\n else:\n self.current_light = TrafficLight.UNKNOWN\n\n break\n\n return self.current_light","def build_cnn(input_var=None):\n\n # input layer\n network = lasagne.layers.InputLayer(\n shape=(\n None,\n 1,\n 128,\n 129\n ),\n input_var=input_var\n )\n\n # conv\n network = lasagne.layers.Conv2DLayer(\n lasagne.layers.batch_norm(network), # Batch norm on incoming\n num_filters=32, # Number of convolution filters to use\n filter_size=(5, 5),\n stride=(1, 1), # Stride fo (1,1)\n pad='same', # Keep output size same as input\n nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\n W=lasagne.init.GlorotUniform() # W initialization\n )\n\n # conv\n #network = lasagne.layers.Conv2DLayer(\n #lasagne.layers.batch_norm(network), # Batch norm on incoming\n #num_filters=32, # Number of convolution filters to use\n #filter_size=(5, 5),\n #stride=(1, 1), # Stride fo (1,1)\n #pad='same', # Keep output size same as input\n #nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\n #W=lasagne.init.GlorotUniform() # W initialization\n #)\n\n # pool (2x2 max pool)\n network = lasagne.layers.MaxPool2DLayer(\n network, pool_size=(2, 2)\n )\n\n # conv\n network = lasagne.layers.Conv2DLayer(\n lasagne.layers.batch_norm(network), # Batch norm on incoming\n num_filters=32, # Number of convolution filters to use\n filter_size=(3, 3),\n stride=(1, 1), # Stride fo (1,1)\n pad='same', # Keep output size same as input\n nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\n W=lasagne.init.GlorotUniform() # W initialization\n )\n\n # conv\n #network = lasagne.layers.Conv2DLayer(\n #lasagne.layers.batch_norm(network), # Batch norm on incoming\n #num_filters=32, # Number of convolution filters to use\n #filter_size=(3, 3),\n #stride=(1, 1), # Stride fo (1,1)\n #pad='same', # Keep output size same as input\n #nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\n #W=lasagne.init.GlorotUniform() # W initialization\n #)\n\n # pool (2x2 max pool)\n network = lasagne.layers.MaxPool2DLayer(\n network, pool_size=(2, 2)\n )\n\n # Fully-connected layer of 256 units with 50% dropout on its inputs\n network = lasagne.layers.DenseLayer(\n lasagne.layers.dropout(network, p=.5),\n num_units=256,\n nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\n W=lasagne.init.HeUniform() # W initialization\n )\n\n # Finally add a 1-unit softmax output layer\n network = lasagne.layers.DenseLayer(\n network,\n num_units=1,\n nonlinearity=lasagne.nonlinearities.sigmoid\n )\n\n return network","def extract_anisotropy_features (Parameters, image, mask=None):\n \n data_inputs = {}\n \n Ka, Kb, Kc = Parameters.kA, Parameters.kB, Parameters.kC\n \n \n h, w, channels = image.shape\n \n if channels == 2:\n channel_types = [\"Para\", \"Perp\"]\n elif channels == 3:\n channel_types = [\"Open\", \"Para\", \"Perp\"]\n \n \n for index, channel in enumerate(channel_types):\n \n data_inputs[channel] = np.sum(image[:,:, index])/np.count_nonzero(image[:,:, index])\n\n\n #Additional parameters\n para_value = data_inputs['Para']\n perp_value = data_inputs['Perp']\n data_inputs['AniAvg'] = (para_value - perp_value)/(para_value + 2*perp_value)\n \n #With corrections\n data_inputs['Ix'] = Ix = ((Ka+Kb)*perp_value - (Ka+Kc)*para_value)/(Ka*Kb + Kb*Kb - Ka*Kc - Kc*Kc)\n data_inputs['Iy'] = Iy = (Kb*para_value - Kc*perp_value)/(Ka*Kb + Kb*Kb - Ka*Kc - Kc*Kc)\n data_inputs['AniAvg'] = (Ix - Iy)/(Ix + 2*Iy)\n \n\n \n return (data_inputs)","def build(self, mode, config):\n assert mode in ['training', 'inference']\n\n # Image size must be dividable by 2 multiple times\n h, w = config.IMAGE_SHAPE[:2]\n if h / 2**6 != int(h / 2**6) or w / 2**6 != int(w / 2**6):\n raise Exception(\"Image size must be dividable by 2 at least 6 times \"\n \"to avoid fractions when downscaling and upscaling.\"\n \"For example, use 256, 320, 384, 448, 512, ... etc. \")\n\n # Inputs\n input_image = KL.Input(\n shape=[None, None, 3], name=\"input_image\")\n input_image_meta = KL.Input(shape=[config.IMAGE_META_SIZE],\n name=\"input_image_meta\")\n if mode == \"training\":\n pass\n elif mode == \"inference\":\n # Anchors in normalized coordinates\n input_anchors = KL.Input(shape=[None, 4], name=\"input_anchors\")\n\n # Build the shared convolutional layers.\n # Bottom-up Layers\n # Returns a list of the last layers of each stage, 5 in total.\n # Don't create the thead (stage 5), so we pick the 4th item in the list.\n _, C2, C3, C4, C5 = resnet_graph(input_image, config.BACKBONE,\n stage5=True, train_bn=config.TRAIN_BN)\n # Top-down Layers\n # TODO: add assert to varify feature map sizes match what's in config\n P5 = KL.Conv2D(256, (1, 1), name='fpn_c5p5')(C5)\n P4 = KL.Add(name=\"fpn_p4add\")([\n KL.UpSampling2D(size=(2, 2), name=\"fpn_p5upsampled\")(P5),\n KL.Conv2D(256, (1, 1), name='fpn_c4p4')(C4)])\n P3 = KL.Add(name=\"fpn_p3add\")([\n KL.UpSampling2D(size=(2, 2), name=\"fpn_p4upsampled\")(P4),\n KL.Conv2D(256, (1, 1), name='fpn_c3p3')(C3)])\n P2 = KL.Add(name=\"fpn_p2add\")([\n KL.UpSampling2D(size=(2, 2), name=\"fpn_p3upsampled\")(P3),\n KL.Conv2D(256, (1, 1), name='fpn_c2p2')(C2)])\n # Attach 3x3 conv to all P layers to get the final feature maps.\n P2 = KL.Conv2D(256, (3, 3), padding=\"SAME\", name=\"fpn_p2\")(P2)\n P3 = KL.Conv2D(256, (3, 3), padding=\"SAME\", name=\"fpn_p3\")(P3)\n P4 = KL.Conv2D(256, (3, 3), padding=\"SAME\", name=\"fpn_p4\")(P4)\n P5 = KL.Conv2D(256, (3, 3), padding=\"SAME\", name=\"fpn_p5\")(P5)\n # P6 is used for the 5th anchor scale in RPN. Generated by\n # subsampling from P5 with stride of 2.\n P6 = KL.MaxPooling2D(pool_size=(1, 1), strides=2, name=\"fpn_p6\")(P5)\n\n # Note that P6 is used in RPN, but not in the classifier heads.\n rpn_feature_maps = [P2, P3, P4, P5, P6]\n mrcnn_feature_maps = [P2, P3, P4, P5]\n\n # Anchors\n if mode == \"training\":\n anchors = self.get_anchors(config.IMAGE_SHAPE)\n # Duplicate across the batch dimension because Keras requires it\n # TODO: can this be optimized to avoid duplicating the anchors?\n anchors = np.broadcast_to(anchors, (config.BATCH_SIZE,) + anchors.shape)\n # A hack to get around Keras's bad support for constants\n anchors = KL.Lambda(lambda x: tf.Variable(anchors), name=\"anchors\")(input_image)\n else:\n anchors = input_anchors\n\n # RPN Model\n rpn = build_rpn_model(config.RPN_ANCHOR_STRIDE,\n len(config.RPN_ANCHOR_RATIOS), 256)\n # Loop through pyramid layers\n layer_outputs = [] # list of lists\n for p in rpn_feature_maps:\n layer_outputs.append(rpn([p]))\n # Concatenate layer outputs\n # Convert from list of lists of level outputs to list of lists\n # of outputs across levels.\n # e.g. [[a1, b1, c1], [a2, b2, c2]] => [[a1, a2], [b1, b2], [c1, c2]]\n output_names = [\"rpn_class_logits\", \"rpn_class\", \"rpn_bbox\"]\n outputs = list(zip(*layer_outputs))\n outputs = [KL.Concatenate(axis=1, name=n)(list(o))\n for o, n in zip(outputs, output_names)]\n\n rpn_class_logits, rpn_class, rpn_bbox = outputs\n\n # Generate proposals\n # Proposals are [batch, N, (y1, x1, y2, x2)] in normalized coordinates\n # and zero padded.\n proposal_count = config.POST_NMS_ROIS_TRAINING if mode == \"training\"\\\n else config.POST_NMS_ROIS_INFERENCE\n rpn_rois = ProposalLayer(\n proposal_count=proposal_count,\n nms_threshold=config.RPN_NMS_THRESHOLD,\n name=\"ROI\",\n config=config)([rpn_class, rpn_bbox, anchors])\n\n if mode == \"training\":\n pass\n else:\n # Network Heads\n # Proposal classifier and BBox regressor heads\n mrcnn_class_logits, mrcnn_class, mrcnn_bbox =\\\n fpn_classifier_graph(rpn_rois, mrcnn_feature_maps, input_image_meta,\n config.POOL_SIZE, config.NUM_CLASSES,\n train_bn=config.TRAIN_BN)\n\n # Detections\n # output is [batch, num_detections, (y1, x1, y2, x2, class_id, score)] in \n # normalized coordinates\n detections = DetectionLayer(config, name=\"mrcnn_detection\")(\n [rpn_rois, mrcnn_class, mrcnn_bbox, input_image_meta])\n\n # Create masks for detections\n detection_boxes = KL.Lambda(lambda x: x[..., :4])(detections)\n mrcnn_mask = build_fpn_mask_graph(detection_boxes, mrcnn_feature_maps,\n input_image_meta,\n config.MASK_POOL_SIZE,\n config.NUM_CLASSES,\n train_bn=config.TRAIN_BN)\n\n model = KM.Model([input_image, input_image_meta, input_anchors],\n [detections, mrcnn_class, mrcnn_bbox,\n mrcnn_mask, rpn_rois, rpn_class, rpn_bbox],\n name='mask_rcnn')\n\n return model","def __call__(\n self,\n image: np.ndarray,\n f_keep_pixels: float = 0,\n f_keep_colored_pixels: float = 0,\n ) -> np.ndarray:\n # Store shape\n h, w, c = image.shape\n\n img_np = image\n\n # Apply transformations\n image: torch.Tensor = self.transform(Image.fromarray(image))\n image = image.to(self.device)\n\n # Copy the numpy array because it's not writeable otherwise\n # Bring into shape [1,1,h,w]\n image.unsqueeze_(0)\n\n # Inference\n result = self.model.networks.g_b_to_a.forward(image).detach()\n\n # From [-1,1] to [0,256]\n result = tensor2im(result, to_rgb=False)\n\n # Resize to the size the input image has\n result = cv2.resize(result, dsize=(w, h), interpolation=cv2.INTER_LINEAR)\n\n if f_keep_pixels > 0:\n grey_img = cv2.cvtColor(img_np, cv2.COLOR_BGR2GRAY)\n colored_pxls = f_keep_pixels * np.ones((h, w))\n\n result = (1 - f_keep_pixels) * result + f_keep_pixels * grey_img\n\n if f_keep_colored_pixels > 0:\n grey_img = cv2.cvtColor(img_np, cv2.COLOR_BGR2GRAY)\n colored_pxls = f_keep_colored_pixels * np.ones((h, w))\n colored_pxls[img_np[:, :, 0] == img_np[:, :, 1]] = 0\n\n result = (\n np.ones_like(colored_pxls) - colored_pxls\n ) * result + colored_pxls * grey_img\n\n return result.astype(np.uint8)","def _recognition_network(self):\n last_input = tf_build_architecture(self.architecture,\n batch_in=self.x_shaped,\n scope_prefix=\"recognize\",\n variables_collection=self.training_scope,\n data_format=self.data_format)\n\n last_input = tf_ensure_flat(last_input)\n\n # The hidden layers are ready - now build the last two, first reshaping the last layer, if needed\n z_mean = tf_dense_layer(\"latent_mean\", last_input,\n params={ 'size':self.output_size, 'func': None },\n variables_collection=self.training_scope)\n\n z_log_sigma_sq = tf_dense_layer(\"latent_log_sigma_sq\", last_input,\n params={ 'size': self.output_size, 'func': None },\n variables_collection=self.training_scope)\n return z_mean, z_log_sigma_sq","def _part_generate_repr(img, steps, params, featsel, filt_l, legacy=True, debug=False):\n\n assert img.ndim == 2 or img.ndim == 3, \"must be gray or RGB\"\n\n if 'preproc_resize' in steps:\n img = _preproc_resize(img, params['preproc']['max_edge'], legacy)\n orig_imga = img.copy()\n if debug:\n print(\"orig_imga, mean {}, std {}\".format(orig_imga.mean(), orig_imga.std()))\n # convert image into gray scale, 2 dim array.\n response = img\n # this is the established way to deal with images for legacy behavior.\n if legacy:\n response = img.astype(np.float32) / 255.0\n\n if response.ndim == 3:\n response = 0.2989 * response[:, :, 0] + 0.5870 * response[:, :, 1] + 0.1140 * response[:, :, 2]\n\n assert response.ndim == 2, \"must be two channels!\"\n # in case we still have float64 dtype, in the case of non legacy\n response = response.astype(np.float32, copy=True)\n assert response.dtype == np.float32\n if debug:\n print(\"imga0, mean {}, std {}\".format(response.mean(), response.std()))\n\n if 'preproc_lowpass' in steps:\n response = _preproc_lowpass(response, params['preproc']['lsum_ksize'], legacy)\n imga0 = response.copy()\n if debug:\n print(\"imga0 normalized, mean {}, std {}\".format(imga0.mean(), imga0.std()))\n\n if 'normin' in steps:\n response = _normin(response, params['normin'], legacy)\n imga1 = response.copy()\n if debug:\n print(\"imga1, shape{}, mean {}, std {}\".format(imga1.shape, imga1.mean(), imga1.std()))\n\n if 'filter' in steps:\n response = _filter(response, filt_l, legacy, mode=params['filter']['mode'])\n else:\n response = response[:, :, np.newaxis]\n # make sure it's 3d.\n assert response.ndim == 3, \"must have a 3d response array\"\n imga2 = response.copy()\n if debug:\n print(\"imga2, shape {}, mean {}, std {}\".format(imga2.shape, imga2.mean(), imga2.std()))\n\n if 'activ' in steps:\n # 'type': 'clamp', # can also be `square`, `exp`, `recsquare`, `rec`\n response = _activ(response, params['activ'])\n imga3 = response.copy()\n if debug:\n print(\"imga3, shape {}, mean {}, std {}\".format(imga3.shape, imga3.mean(), imga3.std()))\n\n if 'normout' in steps:\n response = _normin(response, params['normout'], legacy)\n imga4 = response.copy()\n if debug:\n print(\"imga4, shape {}, mean {}, std {}\".format(imga4.shape, imga4.mean(), imga4.std()))\n\n if 'dimr' in steps:\n response = _dimr(response, params['dimr']['lsum_ksize'], params['dimr']['outshape'], legacy)\n if debug:\n print(\"output, shape {}, mean {}, std {}\".format(response.shape, response.mean(), response.std()))\n images = {'imga0': imga0,\n 'imga1': imga1,\n 'imga2': imga2,\n 'imga3': imga3,\n 'imga4': imga4,\n 'orig_imga': orig_imga}\n\n # handle additional features.\n # pure legacy functions.\n fvector = handle_feature_selection(response, images, featsel)\n return fvector","def main():\n labels, data = load_image_data()\n print(labels.shape, data.shape)","def arch(self, nn) -> 'final node of the tensor flow graph (y_conv)':\n\n print(self)\n\n # first conv. layer \n # 5x5 filter, 1 input channel, 32 output channels\n W_conv1 = nn.weight_variable([5, 5, 1, 32])\n b_conv1 = nn.bias_variable([32])\n stride1 = 1\n h_conv1 = tf.nn.relu(nn.conv2d(nn.x_image, W_conv1, stride1, 'VALID') + b_conv1) \n # outputs a 24x24x32 image\n \n # first pooling layer (2x2) \n h_pool1 = nn.max_pool_2x2(h_conv1) \n # outputs a 12x12x32 image\n\n # second conv. layer \n # 3x3 filter, 32 input channel, 32 output channels\n W_conv2 = nn.weight_variable([3, 3, 32, 32])\n b_conv2 = nn.bias_variable([32])\n stride2 = 1\n h_conv2 = tf.nn.relu(nn.conv2d(h_pool1, W_conv2, stride2, 'VALID') + b_conv2)\n # outputs a 10x10x32 image\n\n # third conv. layer\n # 3x3 filter, 32 input channel, 32 output channels\n W_conv3 = nn.weight_variable([3, 3, 32, 32])\n b_conv3 = nn.bias_variable([32])\n stride3 = 1\n h_conv3 = tf.nn.relu(nn.conv2d(h_conv2, W_conv3, stride3, 'VALID') + b_conv3)\n # outputs a 8x8x32 image\n\n # reshape (flatten) output\n h_conv3_flat = tf.reshape(h_conv3, [-1, 8*8*32])\n\n # first fully connected layer\n W_fc1 = nn.weight_variable([8 * 8 * 32, 1024])\n b_fc1 = nn.bias_variable([1024])\n h_fc1 = tf.nn.relu(tf.matmul(h_conv3_flat, W_fc1) + b_fc1)\n\n # dropout\n h_fc1_drop = tf.nn.dropout(h_fc1, nn.keep_prob)\n\n # second (final) fully connected layer (softmax)\n W_fc2 = nn.weight_variable([1024, 10])\n b_fc2 = nn.bias_variable([10])\n y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)\n\n return y_conv","def network_process(images, exposures, gains):\n\t\t\n\t# Getting the images\n\timage1 = images[2]\n\timage2 = images[1]\n\timage3 = images[0]\n\t\n\t# Resizing\n\timage1 = cv2.resize(image1, (image_width, image_height))\n\timage2 = cv2.resize(image2, (image_width, image_height))\n\timage3 = cv2.resize(image3, (image_width, image_height))\n\n\t# Convert images to tensors for pytorch\n\timage1 = tensor(image1)\n\timage2 = tensor(image2)\n\timage3 = tensor(image3)\n\n\t# print(\"Image 1: \", image1)\n\n\t# Get exposure values\n\texposure1 = exposures[2]\n\texposure2 = exposures[1]\n\texposure3 = exposures[0]\n\n\tgain1 = gains[2]\n\tgain2 = gains[1]\n\tgain3 = gains[0]\n\n\t# Setting 75us and 30ms as the lower and upper limits of exposure respectively\n\tadjusted_exp1 = ((exposure1-75)/(30000-75))*(1)\n\tadjusted_exp2 = ((exposure2-75)/(30000-75))*(1)\n\tadjusted_exp3 = ((exposure3-75)/(30000-75))*(1)\n\n\t# Setting 0 dB and 30 dB as the lower and upper limits of gain respectively\n\tadjusted_gain1 = (gain1/30)*(1)\n\tadjusted_gain2 = (gain2/30)*(1)\n\tadjusted_gain3 = (gain3/30)*(1)\n\n\t# Create a single channel for the exposure and gain values\n\tones = torch.ones((1, image_height, image_width))\n\texposure_1 = ones*adjusted_exp1\n\texposure_2 = ones*adjusted_exp2\n\texposure_3 = ones*adjusted_exp3\n\n\tgain_1 = ones*adjusted_gain1\n\tgain_2 = ones*adjusted_gain2\n\tgain_3 = ones*adjusted_gain3\n\n\tparameter_1 = torch.cat((exposure_1, gain_1), 0)\n\tparameter_2 = torch.cat((exposure_2, gain_2), 0)\n\tparameter_3 = torch.cat((exposure_3, gain_3), 0)\n\n\tnew_img1 = torch.cat((image1, parameter_1), 0)\n\tnew_img2 = torch.cat((image2, parameter_2), 0)\n\tnew_img3 = torch.cat((image3, parameter_3), 0)\n\n\tim1_im2 = torch.cat((new_img1, new_img2), 0)\n\tcombined_images = torch.cat((im1_im2, new_img3),0)\n\tfinal_images = combined_images.unsqueeze(0).to(device)\n\n\toutput = model.forward(final_images)\n\t\n\toutput_exposure = int(((output[:,0]-0)*29925)/1 + 75)\n\toutput_gain = float(((output[:,1]-0)*30)/1 + 0)\n\n\treturn output_exposure, output_gain","def demo(image, name):\n\n # Log.set_log_max_depth(5)\n\n image = normalise(image.astype(np.float32))\n # noisy = add_noise(image, intensity=None, variance=0.1, sap=0, clip=False)\n noisy = random_noise(image, mode=\"gaussian\", var=0.1, seed=0, clip=False)\n noisier = random_noise(noisy, mode=\"gaussian\", var=0.1, seed=100, clip=False)\n\n generator = StandardFeatureGenerator(\n include_corner_features=True,\n include_scale_one=True,\n include_fine_features=True,\n include_spatial_features=True,\n )\n regressor = CBRegressor(\n patience=16, loss='l1', learning_rate=0.002, max_num_estimators=4096\n )\n\n it = ImageTranslatorFGR(feature_generator=generator, regressor=regressor)\n\n it.train(noisy, noisy, jinv=True)\n n2s_denoised = it.translate(noisy)\n\n it.exclude_center_feature = False\n it.train(noisier, noisy, jinv=False)\n denoised = it.translate(noisy)\n denoised_corrected = 2 * denoised - noisy\n\n # denoised2 = it.translate(it.translate(it.translate(denoised)))\n denoised2 = it.translate(denoised)\n\n image = numpy.clip(image, 0, 1)\n noisy = numpy.clip(noisy, 0, 1)\n n2s_denoised = numpy.clip(n2s_denoised, 0, 1)\n denoised_corrected = numpy.clip(denoised_corrected, 0, 1)\n denoised2 = numpy.clip(denoised2, 0, 1)\n\n psnr_noisy = psnr(image, noisy)\n ssim_noisy = ssim(image, noisy)\n\n psnr_n2s_denoised = psnr(image, n2s_denoised)\n ssim_n2s_denoised = ssim(image, n2s_denoised)\n\n psnr_denoised = psnr(image, denoised)\n ssim_denoised = ssim(image, denoised)\n\n psnr_denoised_corrected = psnr(image, denoised_corrected)\n ssim_denoised_corrected = ssim(image, denoised_corrected)\n\n psnr_denoised2 = psnr(image, denoised2)\n ssim_denoised2 = ssim(image, denoised2)\n\n print(\"noisy :\", psnr_noisy, ssim_noisy)\n print(\n \"denoised (classic_denoisers) :\",\n psnr_n2s_denoised,\n ssim_n2s_denoised,\n )\n print(\"denoised (noiser2noise) :\", psnr_denoised, ssim_denoised)\n print(\n \"denoised (noiser2noise corrected) :\",\n psnr_denoised_corrected,\n ssim_denoised_corrected,\n )\n print(\"denoised (x2) :\", psnr_denoised2, ssim_denoised2)\n\n Log.enable_output = False\n denoised_images = []\n for i in range(1, 32):\n psnr_denoised = psnr(image, numpy.clip(denoised, 0, 1))\n ssim_denoised = ssim(image, numpy.clip(denoised, 0, 1))\n psnr_sslos = psnr(numpy.clip(n2s_denoised, 0, 1), numpy.clip(denoised, 0, 1))\n ssim_sslos = ssim(numpy.clip(n2s_denoised, 0, 1), numpy.clip(denoised, 0, 1))\n print(f\"x{i} :\", psnr_sslos, ssim_sslos, psnr_denoised, ssim_denoised)\n\n denoised_images.append(numpy.clip(denoised, 0, 1))\n denoised = it.translate(denoised)\n\n import napari\n\n with napari.gui_qt():\n viewer = napari.Viewer()\n viewer.add_image(image, name='image')\n viewer.add_image(noisy, name='noisy')\n viewer.add_image(noisier, name='noisier')\n viewer.add_image(n2s_denoised, name='denoised (classic_denoisers)')\n viewer.add_image(denoised, name='denoised (noiser3noise)')\n viewer.add_image(denoised_corrected, name='denoised (noiser3noise corrected)')\n viewer.add_image(numpy.stack(denoised_images), name=f'denoised images')","def data_augmentation(image, aug):\n if (aug == \"random_crop\") and (random.randint(0,1)):\n image = random_crop(image) \n if (aug == \"random_rotation\") and (random.randint(0,1)): \n image = random_rotation(image) \n if (aug == \"random_flip\") and (random.randint(0,1)): \n image = random_flip(image)\n if (aug == \"affine_transformation\") and (random.randint(0,1)): \n image = affine_transformation(image)\n if (aug == \"random_gaussian_noise\") and (random.randint(0,1)): \n image = random_gaussian_noise(image)\n if (aug == \"random_erasing\") and (random.randint(0,1)): \n image = random_erasing(image) \n return image","def test_model_sample(net, data_loader):\n net.eval()\n array = []\n with torch.no_grad():\n for data in data_loader:\n X = data['X']\n output = net(X)\n output = ToPILImage()(output)\n array.append(output)\n return array","def forward_pass(X,architecture):\n \n architecture['layer1'][0] = X\n kernel_shape1 = architecture['layer1'][7]\n stride1 = architecture['layer1'][8]\n if kernel_shape1 is not None and not isinstance(kernel_shape1,int):\n X_input_1_im2col,imX = im2col(X,kernel_shape1,stride1,im_needed = False, shape_specified = True)\n architecture['layer1'][4] = X_input_1_im2col\n else:\n architecture['layer1'][4] = None\n\n for layer in range(len(architecture)): # Feedforward from the first till the second last layer\n X_input,X_output,weightsi,biasi,X_input_1_im2col,imi,output_shapei,kernel_shapei,stridei,operationi,imx = architecture['layer{}'.format(layer+1)]\n\n if operationi == 'conv_bn_relu':\n conv_output = relu(BatchNorm(torch.t(X_input_1_im2col).mm(weightsi) + biasi))\n conv_output = torch.reshape(conv_output,output_shapei)\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\n if operationi__1 == 'maxpool':\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\n else:\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\n # resetting input im2col of next layer as the im2col of the output of this layer\n else:\n architecture['layer{}'.format(layer+2)][4] = None\n elif operationi == 'conv_relu':\n conv_output = relu(torch.t(X_input_1_im2col).mm(weightsi) + biasi)\n conv_output = torch.reshape(conv_output,output_shapei)\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\n if operationi__1 == 'maxpool':\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\n else:\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\n # resetting input im2col of next layer as the im2col of the output of this layer\n else:\n architecture['layer{}'.format(layer+2)][4] = None\n elif operationi == 'conv_bn_sigmoid':\n conv_output = sigmoid(BatchNorm(torch.t(X_input_1_im2col).mm(weightsi) + biasi))\n conv_output = torch.reshape(conv_output,output_shapei)\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\n if operationi__1 == 'maxpool':\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\n else:\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\n # resetting input im2col of next layer as the im2col of the output of this layer\n else:\n architecture['layer{}'.format(layer+2)][4] = None\n elif operationi == 'conv_sigmoid':\n conv_output = sigmoid(torch.t(X_input_1_im2col).mm(weightsi) + biasi)\n conv_output = torch.reshape(conv_output,output_shapei)\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\n if operationi__1 == 'maxpool':\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\n else:\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\n # resetting input im2col of next layer as the im2col of the output of this layer\n else:\n architecture['layer{}'.format(layer+2)][4] = None\n elif operationi == 'maxpool':\n maxpool_output = maxpool(X_input,kernel_shapei,stridei)\n\n maxpool_output = torch.reshape(maxpool_output,output_shapei)\n\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = maxpool_output\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\n architecture['layer{}'.format(layer+2)][4],imX = im2col(maxpool_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\n else:\n architecture['layer{}'.format(layer+2)][4] = None\n elif operationi == 'flatten_dense_relu':\n # kernel_shapei in this case refers to the output channels: stride for dense layer will be None\n output = flatten_and_dense(X_input,kernel_shapei,weightsi,biasi,activation = 'relu',initialise_weights = False)\n architecture['layer{}'.format(layer+1)][1] = output\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = output\n elif operationi == 'flatten_dense_none':\n # kernel_shapei in this case refers to the output channels: stride for dense layer will be None\n output = flatten_and_dense(X_input,kernel_shapei,weightsi,biasi,activation = 'none',initialise_weights = False)\n architecture['layer{}'.format(layer+1)][1] = output\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = output\n elif operationi == 'flatten_dense_sigmoid':\n # kernel_shapei in this case refers to the output channels: stride for dense layer will be None\n output = flatten_and_dense(X_input,kernel_shapei,weightsi,biasi,activation = 'sigmoid',initialise_weights = False)\n architecture['layer{}'.format(layer+1)][1] = output\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = output\n elif operationi == 'softmax':\n Xin = architecture['layer{}'.format(layer+1)][0]\n output = softmax(Xin).squeeze()\n architecture['layer{}'.format(layer+1)][1] = output\n if layer == len(architecture) - 1:\n y_pred = architecture['layer{}'.format(len(architecture))][1]\n \n return y_pred","def visualize_saliency_of_output(FLAGS, model, input_images=[]):\n if len(input_images) == 0:\n # use predefined images\n img_dir='/esat/opal/kkelchte/docker_home/pilot_data/visualization_images'\n input_images=sorted([img_dir+'/'+f for f in os.listdir(img_dir)])\n\n print(\"[tools.py]: extracting saliency maps of {0} in {1}\".format([os.path.basename(i) for i in input_images], os.path.dirname(input_images[0])))\n \n \n inputs = load_images(input_images, model.input_size[1:])\n\n print 'shape: ',inputs.shape\n\n if 'nfc' in FLAGS.network:\n inputs = np.concatenate([inputs]*FLAGS.n_frames, axis=-1)\n \n # extract deconvolution\n import tf_cnnvis\n\n # layers = ['c']\n # layers=['MobilenetV1_1/control/Conv2d_1c_1x1/Conv2D']\n # layers=['MobilenetV1_1/control/Conv2d_1c_1x1/Conv2D','MobilenetV1_1/AvgPool_1a/AvgPool']\n\n # layers = [str(i.name) for i in model.sess.graph.get_operations() if 'outputs' in i.name and not 'activations' in i.name and not 'gradients' in i.name]\n layers = [model.endpoints['eval']['outputs'].name[:-2]] #cut out :0 in the end to change name from tensor to operation name\n # layers = ['outputs']\n \n # results = tf_cnnvis.activation_visualization(sess_graph_path = model.sess, \n # value_feed_dict = {model.inputs : inputs}, \n # layers=layers)\n results = tf_cnnvis.deconv_visualization(sess_graph_path = model.sess, \n value_feed_dict = {model.inputs : inputs}, \n layers=layers)\n\n # Normalize deconvolution within 0:1 range\n num_rows=0\n clean_results={} \n # Loop over layers\n for k in results.keys():\n clean_results[k]=[]\n # Loop over channels\n for c in range(len(results[k])):\n num_rows+=1\n clean_results[k].append(np.zeros((results[k][c].shape[0:3])))\n # Loop over images\n for i in range(results[k][c].shape[0]):\n clean_results[k][c][i]=deprocess_image(results[k][c][i],one_channel=True)\n if num_rows > 6:\n print(\"[tools.py]: There are too many columns to create a proper image.\")\n return\n\n # create one combined image with each input image on each column\n fig, axes = plt.subplots(num_rows+1,min(len(input_images),5),figsize=(23, 4*(2*len(results.keys())+1)))\n # fig, axes = plt.subplots(num_columns+1,min(len(input_images),5),figsize=(23, 4*(2*len(results.keys())+1)))\n # add original images in first row\n for i in range(axes.shape[1]):\n axes[0, i].set_title(os.path.basename(input_images[i]).split('.')[0])\n axes[0, i].imshow(matplotlibprove(inputs[i]), cmap='inferno')\n axes[0, i].axis('off')\n \n # experts=np.asarray([[k]*(FLAGS.action_quantity if FLAGS.discrete else 1) for v in sorted(model.factor_offsets.values()) for k in model.factor_offsets.keys() if model.factor_offsets[k]==v]).flatten()\n\n # add deconvolutions over the columns\n row_index = 1\n for k in results.keys(): # go over layers\n for c in range(len(results[k])): # add each channel in 2 new column\n for i in range(axes.shape[1]): # fill row going over input images\n # axes[row_index, i].set_title(k.split('/')[1]+'/'+k.split('/')[2]+'_'+str(c))\n axes[row_index, i].set_title(k+'_'+str(c))\n # axes[row_index, i].set_title(experts[c])\n \n axes[row_index, i].imshow(np.concatenate((inputs[i],np.expand_dims(clean_results[k][c][i],axis=2)), axis=2))\n axes[row_index, i].axis('off')\n # row_index+=2\n row_index+=1\n # plt.show()\n plt.savefig(FLAGS.summary_dir+FLAGS.log_tag+'/saliency_maps.jpg',bbox_inches='tight')","def example():\n accShape, accTexture, accFinal = train_and_eval_all_models()\n print(f'Accuracy -- only shape: {accShape}; only texture: {accTexture}; combined: {accFinal}.')","def forward(self, img, return_loss=True, **kwargs):\n return self.architecture(img, return_loss=return_loss, **kwargs)","def load_image(nom):\n print(\"load_image : [\", nom, \"]\")\n fic = gdal.Open(nom)\n print(fic)\n return fic.ReadAsArray(), fic.GetGeoTransform()","def _get_logits(images,\n model_options,\n outputs_to_num_classes,\n weight_decay=0.0001,\n reuse=tf.AUTO_REUSE,\n is_training=False,\n fine_tune_batch_norm=False):\n features, end_points = _extract_features(\n images,\n model_options,\n weight_decay=weight_decay,\n reuse=reuse,\n is_training=is_training,\n fine_tune_batch_norm=fine_tune_batch_norm)\n\n # TODO: CHECK\n DEBUG_VARS.aspp_result = features\n if model_options.decoder_output_stride is not None:\n decoder_height = scale_dimension(model_options.crop_size[0],\n 1.0 / model_options.decoder_output_stride)\n decoder_width = scale_dimension(model_options.crop_size[1],\n 1.0 / model_options.decoder_output_stride)\n features = refine_by_decoder(\n features,\n end_points,\n decoder_height=decoder_height,\n decoder_width=decoder_width,\n decoder_use_separable_conv=model_options.decoder_use_separable_conv,\n model_variant=model_options.model_variant,\n weight_decay=weight_decay,\n reuse=reuse,\n is_training=is_training,\n fine_tune_batch_norm=fine_tune_batch_norm)\n\n outputs_to_logits = {}\n for output in sorted(outputs_to_num_classes):\n outputs_to_logits[output] = _get_branch_logits(\n features,\n outputs_to_num_classes[output],\n model_options.atrous_rates,\n aspp_with_batch_norm=model_options.aspp_with_batch_norm,\n kernel_size=model_options.logits_kernel_size,\n weight_decay=weight_decay,\n reuse=reuse,\n scope_suffix=output)\n\n return outputs_to_logits","def build(self):\n input_shape_img = (None, None, 3)\n img_input = Input(shape=input_shape_img)\n roi_input = Input(shape=(None, 4))\n shared_layers = self.cnn_model.nn_base(img_input, trainable=True)\n num_anchors = len(self.C.anchor_scales) * len(self.C.anchor_ratios)\n \n output_region_proposal = self.region_proposal_net(shared_layers, num_anchors)\n output_classifier = self.classifier(shared_layers,\n self.cnn_model.classifier_layers, \n roi_input, self.C.num_roi, \n num_class=len(self.class_count), trainable=True)\n \n self.model_region_proposal = Model(img_input, output_region_proposal[:2])\n self.model_classifier = Model([img_input, roi_input], output_classifier)\n self.model_all = Model([img_input, roi_input], output_region_proposal[:2] + output_classifier)\n\n optimizer = Adam(lr=1e-5)\n self.model_region_proposal.compile(optimizer=optimizer, \n loss=[losses.rpn_loss_cls(num_anchors), \n losses.rpn_loss_regr(num_anchors)])\n self.model_classifier.compile(optimizer=optimizer, \n loss=[losses.class_loss_cls, \n losses.class_loss_regr(len(self.class_count)-1)], \n metrics={'dense_class_{}'.format(len(self.class_count)): 'accuracy'})\n self.model_all.compile(optimizer='sgd', loss='mae')\n\n # print(self.model_all.summary())\n plot_model(self.model_region_proposal, show_shapes=True, to_file='./frcnn/images/region_proposal.png')\n plot_model(self.model_classifier, show_shapes=True, to_file='./frcnn/images/classifier.png')\n plot_model(self.model_all, show_shapes=True, to_file='./frcnn/images/model_all.png')","def encode(self, img):\n with tf.variable_scope('encoder'):\n #conv1 = self.conv_layer(\n # img, [5, 5], [3, 32], stride=2, initializer_type=1, name='conv1')\n #conv2 = self.conv_layer(\n # conv1, [5, 5], [32, 32], stride=2, initializer_type=1, name='conv2')\n conv3 = self.conv_layer(\n img, [5, 5], [self.in_channels, 64], stride=2, initializer_type=1, name='conv3')\n #conv4 = self.conv_bn_layer(\n conv4 = self.conv_layer(\n conv3, [5, 5], [64, 128], stride=2, #is_training=self.is_training,\n initializer_type=1, name='conv4')\n #conv5 = self.conv_bn_layer(\n conv5 = self.conv_layer(\n conv4, [5, 5], [128, 256], stride=2, #is_training=self.is_training,\n initializer_type=1, name='conv5')\n shape = conv5.get_shape().as_list()\n feature_map_size = shape[1]*shape[2]*shape[3]\n conv5_flat = tf.reshape(\n conv5, [-1, feature_map_size], 'conv5_flat')\n #fc6 = self.fc_bn_layer(conv5_flat, 1024, is_training=self.is_training,\n fc6 = self.fc_layer(conv5_flat, 1024,\n initializer_type=1, name='fc6')\n #fc7 = self.fc_layer(fc6, 1024, initializer_type=1, name='fc7')\n return fc6, shape","def compute_img(self):\r\n self.load_img()\r\n self.check_shape()\r\n self.convert_img()\r\n self.img_computed = True","def my_hom_cnn_model_fn(features, labels, mode):\n # Input Layer\n # Reshape X to 4-D tensor: [batch_size, width, height, channels]\n\n #HOM Images are 128x128, and have two channels\n input_layer = tf.reshape(features[\"x\"], [-1, pSize, pSize, 2])\n\n # Convolutional Layer #1\n # Computes 32 features using a 3x3 filter with ReLU activation.\n # Padding is added to preserve width and height.\n conv1 = tf.layers.conv2d(inputs=input_layer, filters=64,kernel_size=[3, 3], padding=\"same\",activation=tf.nn.relu) #None\n conv2 = tf.layers.conv2d(inputs=conv1, filters=64, kernel_size=[3, 3], padding=\"same\", activation=tf.nn.relu)\n pool1 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)\n\n conv3 = tf.layers.conv2d(inputs=pool1, filters=64, kernel_size=[3, 3], padding=\"same\",activation=tf.nn.relu)\n conv4 = tf.layers.conv2d(inputs=conv3,filters=64,kernel_size=[3, 3],padding=\"same\",activation=tf.nn.relu)\n pool2 = tf.layers.max_pooling2d(inputs=conv4, pool_size=[2, 2], strides=2)\n\n conv5 = tf.layers.conv2d(inputs=pool2, filters=128, kernel_size=[3, 3], padding=\"same\",activation=tf.nn.relu)\n conv6 = tf.layers.conv2d(inputs=conv5,filters=128,kernel_size=[3, 3],padding=\"same\",activation=tf.nn.relu)\n pool3 = tf.layers.max_pooling2d(inputs=conv6, pool_size=[2, 2], strides=2)\n\n conv7 = tf.layers.conv2d(inputs=pool3, filters=128, kernel_size=[3, 3], padding=\"same\",activation=tf.nn.relu)\n conv8 = tf.layers.conv2d(inputs=conv7,filters=128,kernel_size=[3, 3],padding=\"same\",activation=tf.nn.relu)\n\n # Dense Layer\n # Densely connected layer with 1024 neurons\n conv2_flat = tf.reshape(conv8, [-1, 128 * 128 * 2])\n # Add dropout operation; 0.5 probability that element will be kept\n dropout = tf.layers.dropout(inputs=conv2_flat, rate=0.5, training=mode == tf.estimator.ModeKeys.TRAIN)\n\n fully_connect = tf.layers.dense(inputs=dropout, units=1024, activation=None) #activation=None\n predictions = tf.layers.dense(inputs=fully_connect, units=8, activation=None)\n\n #predictions\n if mode == tf.estimator.ModeKeys.PREDICT:\n return tf.estimator.EstimatorSpec(mode=mode, predictions = predictions)\n \n loss = tf.losses.mean_squared_error(labels=labels, predictions = predictions)\n \n #loss = tf.nn.softmax_cross_entropy_with_logits(labels=labels, logits=predictions, name=\"softmax_tensor\")\n\n # Configure the Training Op (for TRAIN mode)\n if mode == tf.estimator.ModeKeys.TRAIN:\n optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)\n train_op = optimizer.minimize(loss=loss, global_step=tf.train.get_global_step())\n return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)\n\n # Add evaluation metrics (for EVAL mode)\n #eval_metric_ops = {\"accuracy\": tf.metrics.accuracy(labels=labels, predictions=predictions[\"coord\"])}#predictions=predictions[\"classes\"])}\n \n if mode == tf.estimator.ModeKeys.EVAL:\n eval_metric_ops = {\n \"mean_square_error\": tf.metrics.mean_squared_error(labels=labels, predictions = predictions)}#predictions=predictions[\"classes\"])}\n\n return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops, predictions = predictions)","def process(bayer_images, red_gains, blue_gains, cam2rgbs):\n bayer_images.shape.assert_is_compatible_with((None, None, None, 4))\n with tf.name_scope(None, 'process'):\n # White balance.\n bayer_images = apply_gains(bayer_images, red_gains, blue_gains)\n # Demosaic.\n bayer_images = tf.clip_by_value(bayer_images, 0.0, 1.0)\n images = demosaic(bayer_images)\n # Color correction.\n images = apply_ccms(images, cam2rgbs)\n # Gamma compression.\n images = tf.clip_by_value(images, 0.0, 1.0)\n images = gamma_compression(images)\n return images","def loadRes(self, predictions, type='boxes'):\n print('Loading and preparing results...')\n res = Car3D(self.cfg, self.dataset_dir, self.list_flag, self.transforms, self.training)\n res.dataset = dict()\n res.dataset['categories'] = copy.deepcopy(self.category_to_id_map)\n res.dataset['images'] = []\n anns = []\n count = 1\n tic = time.time()\n\n for idx in tqdm(range(len(self.img_list_all))):\n res.dataset['images'].append({'id': self.img_list_all[idx]})\n prediction = predictions[idx]\n if type == 'boxes':\n for id in range(len(prediction)):\n ann = dict()\n ann['image_id'] = self.img_list_all[idx]\n ann['category_id'] = int(prediction.get_field('labels')[id].numpy())\n bb = prediction.bbox[id].numpy()\n x1, x2, y1, y2 = bb[0], bb[2], bb[1], bb[3]\n w = x2 - x1\n h = y2 - y1\n x_c = (x1 + x2) / 2\n y_c = (y1 + y2) / 2\n ann['bbox'] = [x_c, y_c, w, h]\n ann['area'] = w * h\n ann['id'] = count\n ann['iscrowd'] = 0\n ann['score'] = prediction.get_field('scores')[id].numpy()\n\n count += 1\n anns.append(ann)\n elif type == 'segms':\n masks = prediction.get_field(\"mask\")\n masks = self.masker([masks], [prediction])[0]\n\n for id in range(len(prediction)):\n ann = dict()\n ann['image_id'] = self.img_list_all[idx]\n ann['score'] = prediction.get_field('scores')[id].numpy()\n binary_mask = masks[id, 0]\n fortran_binary_mask = np.asfortranarray(binary_mask)\n ann['segms'] = maskUtils.encode(fortran_binary_mask)\n ann['category_id'] = int(prediction.get_field('labels')[id].numpy())\n # now only support compressed RLE format as segmentation results\n ann['area'] = maskUtils.area(ann['segms'])\n if not 'boxes' in ann:\n ann['boxes'] = maskUtils.toBbox(ann['segms'])\n ann['id'] = count\n count += 1\n ann['iscrowd'] = 0\n anns.append(ann)\n\n print('DONE (t={:0.2f}s)'.format(time.time() - tic))\n res.dataset['annotations'] = anns\n res.createIndex()\n #res.eval_class = []\n return res","def create_inputs_norb(path, is_train: bool,batch_size,epochs):\n\n # Create batched dataset\n dataset = input_fn(path, is_train,batch_size=batch_size, epochs=epochs)\n\n # Create one-shot iterator\n iterator = tf.compat.v1.data.make_one_shot_iterator(dataset)\n\n img, lab, cat, elv, azi, lit = iterator.get_next()\n\n output_dict = {'image': img,\n 'label': lab,\n 'category': cat,\n 'elevation': elv,\n 'azimuth': azi,\n 'lighting': lit}\n\n return output_dict","def get_classification(self, image):\n # return TrafficLight.RED\n # TODO implement light color prediction\n # creating an image object \n img_np = np.array(image) \n\n # convert np array to tensor\n input_tensor = tf.convert_to_tensor(img_np)\n\n # The model expects a batch of images, so add an axis with `tf.newaxis`.\n input_tensor = input_tensor[tf.newaxis, ...]\n\n\n detections = self.loaded(input_tensor)\n\n num_detections = int(detections.pop('num_detections'))\n\n # detection_classes should be ints.\n detections_dict = {key: value[0, :num_detections].numpy() for key, value in detections.items()}\n\n\n # detection_classes should be ints.\n detections_dict['detection_classes'] = detections_dict['detection_classes'].astype(np.int64)\n\n label_id_offset = 1\n\n # DEBUG - can do it in a cleaner way :0\n tl_classes = {3: 'green', 2: 'red'}\n top_classes_prediction = list(detections_dict['detection_classes']+label_id_offset)[:5] \n #print(top_classes_prediction)\n for i in range(len(top_classes_prediction)):\n if top_classes_prediction[i] == 2:\n top_classes_prediction[i] = 'green'\n elif top_classes_prediction[i] == 3:\n top_classes_prediction[i] = 'red'\n\n\n #print(\"--------->\", image_path, \"<-----------\")\n #print( top_classes_prediction ) \n #print(detections_dict['detection_scores'][:5], '\\n' )\n\n # basic red tl logic\n if top_classes_prediction[0] == 'red' and detections_dict['detection_scores'][0] >= 0.60:\n #print(\"-------------> RED TRAFFIC LIGHT <----------------\\n\")\n self.current_light = TrafficLight.RED\n #rospy.logwarn( \"----------------- Taffic light is RED !!! -------------------- \" )\n self.display_predictions_scores( top_classes_prediction, detections_dict['detection_scores'] )\n else:\n #print(\"No red traffic is detected\\n\")\n self.current_light = TrafficLight.GREEN\n #rospy.logwarn( \"----------------- You're good to go !!! --------: {0} - {1} \".format(top_classes_prediction[0], detections_dict['detection_scores'][0]) )\n self.display_predictions_scores( top_classes_prediction, detections_dict['detection_scores'] )\n\n return self.current_light","def inception_network():\n X = K.Input(shape=(224, 224, 3))\n initializer = K.initializers.he_normal(seed=None)\n conv_1 = K.layers.Conv2D(filters=64, kernel_size=7,\n padding='same', strides=2,\n kernel_initializer=initializer,\n activation='relu')(X)\n max_pool_1 = K.layers.MaxPooling2D(pool_size=3, strides=2,\n padding='same')(conv_1)\n\n conv_2 = K.layers.Conv2D(filters=64, padding='same',\n kernel_size=1, activation='relu',\n kernel_initializer=initializer)(max_pool_1)\n conv2_1 = K.layers.Conv2D(filters=192, padding='same',\n kernel_size=3, activation='relu',\n kernel_initializer=initializer)(conv_2)\n max_pool_2 = K.layers.MaxPooling2D(pool_size=3, strides=2,\n padding='same')(conv2_1)\n\n incep_3a = inception_block(max_pool_2, [64, 96, 128, 16, 32, 32])\n incep_3b = inception_block(incep_3a, [128, 128, 192, 32, 96, 64])\n max_pool_3 = K.layers.MaxPooling2D(pool_size=3, strides=2,\n padding='same')(incep_3b)\n\n incep_4a = inception_block(max_pool_3, [192, 96, 208, 16, 48, 64])\n incep_4b = inception_block(incep_4a, [160, 112, 224, 24, 64, 64])\n incep_4c = inception_block(incep_4b, [128, 128, 256, 24, 64, 64])\n incep_4d = inception_block(incep_4c, [112, 144, 288, 32, 64, 64])\n incep_4e = inception_block(incep_4d, [256, 160, 320, 32, 128, 128])\n max_pool_4 = K.layers.MaxPooling2D(pool_size=3, strides=2,\n padding='same')(incep_4e)\n\n incep_5a = inception_block(max_pool_4, [256, 160, 320, 32, 128, 128])\n incep_5b = inception_block(incep_5a, [384, 192, 384, 48, 128, 128])\n avg_pool = K.layers.AveragePooling2D(pool_size=7, strides=None)(incep_5b)\n\n drop_out = K.layers.Dropout(0.4)(avg_pool)\n dense = K.layers.Dense(units=1000, activation='softmax',\n kernel_initializer=initializer)(drop_out)\n return K.models.Model(inputs=X, outputs=dense)","def data_augmentation(image_data, mask_data, rotate=False, vertical_flip=False, horizontal_flip=False):\n aug_images = []\n aug_masks = []\n\n for _ in range(len(image_data)):\n if rotate:\n rotation = A.RandomRotate90(p=1)\n rotated_data = rotation(image=image_data[_], mask=mask_data[_])\n rotated_image = rotated_data['image']\n rotated_mask = rotated_data['mask']\n aug_images.append(rotated_image)\n aug_masks.append(rotated_mask)\n\n if vertical_flip:\n flip_v = A.VerticalFlip(p=1)\n vertical_data = flip_v(image=image_data[_], mask=mask_data[_])\n vertical_image = vertical_data['image']\n vertical_mask = vertical_data['mask']\n aug_images.append(vertical_image)\n aug_masks.append(vertical_mask)\n\n if horizontal_flip:\n flip_h = A.HorizontalFlip(p=1)\n horizontal_data = flip_h(image=image_data[_], mask=mask_data[_])\n horizontal_image = horizontal_data['image']\n horizontal_mask = horizontal_data['mask']\n aug_images.append(horizontal_image)\n aug_masks.append(horizontal_mask)\n\n nd_images = make_ndarray(aug_images)\n nd_masks = make_ndarray(aug_masks)\n #nd_images = np.zeros((len(aug_images), IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS), dtype=np.float32)\n #nd_masks = np.zeros((len(aug_masks), IMG_HEIGHT, IMG_WIDTH), dtype=np.float32)\n\n #for _ in range(len(aug_images)): # Load into ndarray\n # nd_images[_] = aug_images[_]\n # nd_masks[_] = aug_masks[_] # load mask without channel variable\n\n return nd_images, nd_masks","def create(self):\n \n \"\"\" A solo prepressing reduction network in the head \"\"\"\n print(\"pre_reduction\")\n with tf.name_scope('pre_reduction'):\n conv1 = NW.conv(self.X, 7, 7, 64, 2, 2, name='conv1')\n pool1 = NW.max_pool(conv1, 3, 3, 2, 2, name='pool1')\n norm1 = NW.lrn(pool1, 2, 2e-05, 0.75, name='norm1')\n reduction2 = NW.conv(norm1, 1, 1, 64, 1, 1, name='reduction2')\n conv2 = NW.conv(reduction2, 3, 3, 192, 1, 1,name='conv2')\n norm2 = NW.lrn(conv2, 2, 2e-05, 0.75, name='norm2')\n pool2 = NW.max_pool(norm2, 3, 3, 2, 2, name='pool2')\n \n \"\"\" 1st inception layer group \"\"\"\n print(\"icp1\")\n with tf.name_scope('icp1'):\n # branch 0\n icp1_out0 = NW.conv(pool2, 1, 1, 64, 1, 1, name='icp1_out0')\n # branch 1\n icp1_reduction1 = NW.conv(pool2, 1, 1, 96, 1, 1, name='icp1_reduction1')\n icp1_out1 = NW.conv(icp1_reduction1, 3, 3, 128, 1, 1, name='icp1_out1')\n # branch 2\n icp1_reduction2 = NW.conv(pool2, 1, 1, 16, 1, 1, name='icp1_reduction2')\n icp1_out2 = NW.conv(icp1_reduction2, 5, 5, 32, 1, 1, name='icp1_out2')\n # branch 3\n icp1_pool = NW.max_pool(pool2, 3, 3, 1, 1, name='icp1_pool')\n icp1_out3 = NW.conv(icp1_pool, 1, 1, 32, 1, 1, name='icp1_out3')\n # concat\n icp2_in = NW.concat([icp1_out0,\n icp1_out1,\n icp1_out2,\n icp1_out3], 3, 'icp2_in')\n\n \"\"\" 2nd inception layer group \"\"\"\n print(\"icp2\")\n with tf.name_scope('icp2'):\n # branch 0\n icp2_out0 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_out0')\n # branch 1\n icp2_reduction1 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_reduction1')\n icp2_out1 = NW.conv(icp2_reduction1, 3, 3, 192, 1, 1, name='icp2_out1')\n # branch 2\n icp2_reduction2 = NW.conv(icp2_in, 1, 1, 32, 1, 1, name='icp2_reduction2')\n icp2_out2 = NW.conv(icp2_reduction2, 5, 5, 96, 1, 1, name='icp2_out2')\n # branch 3\n icp2_pool = NW.max_pool(icp2_in, 3, 3, 1, 1, name='icp2_pool')\n icp2_out3 = NW.conv(icp2_pool, 1, 1, 64, 1, 1, name='icp2_out3')\n # concat\n icp2_out = NW.concat([icp2_out0,\n icp2_out1,\n icp2_out2,\n icp2_out3], 3, 'icp2_out')\n \n \"\"\" 3rd inception layer group \"\"\"\n print(\"icp3\")\n with tf.name_scope('icp3'):\n icp3_in = NW.max_pool(icp2_out, 3, 3, 2, 2, name='icp3_in')\n # branch 0\n icp3_out0 = NW.conv(icp3_in, 1, 1, 192, 1, 1, name='icp3_out0')\n # branch 1\n icp3_reduction1 = NW.conv(icp3_in, 1, 1, 96, 1, 1, name='icp3_reduction1')\n icp3_out1 = NW.conv(icp3_reduction1, 3, 3, 208, 1, 1, name='icp3_out1')\n # branch 2\n icp3_reduction2 = NW.conv(icp3_in, 1, 1, 16, 1, 1, name='icp3_reduction2')\n icp3_out2 = NW.conv(icp3_reduction2, 5, 5, 48, 1, 1, name='icp3_out2')\n # branch 3\n icp3_pool = NW.max_pool(icp3_in, 3, 3, 1, 1, name='icp3_pool')\n icp3_out3 = NW.conv(icp3_pool, 1, 1, 64, 1, 1, name='icp3_out3')\n # concat\n icp3_out = NW.concat([icp3_out0,\n icp3_out1,\n icp3_out2,\n icp3_out3], 3, 'icp3_out')\n \n \"\"\" 1st classify branch \"\"\"\n with tf.name_scope('cls1'):\n cls1_pool = NW.avg_pool(icp3_out, 5, 5, 3, 3, padding='VALID', name='cls1_pool')\n cls1_reduction_pose = NW.conv(cls1_pool, 1, 1, 128, 1, 1, name='cls1_reduction_pose')\n cls1_fc1_pose = NW.fc(cls1_reduction_pose, 1024, name='cls1_fc1_pose')\n cls1_fc_pose_xy = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_xy')\n cls1_fc_pose_ab = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_ab')\n self.layers[\"cls1_fc_pose_xy\"] = cls1_fc_pose_xy\n self.layers[\"cls1_fc_pose_ab\"] = cls1_fc_pose_ab\n \n \"\"\" 4st inception layer group \"\"\"\n print(\"icp4\")\n with tf.name_scope('icp4'):\n # branch 0\n icp4_out0 = NW.conv(icp3_out, 1, 1, 160, 1, 1, name='icp4_out0')\n # branch 1\n icp4_reduction1 = NW.conv(icp3_out, 1, 1, 112, 1, 1, name='icp4_reduction1')\n icp4_out1 = NW.conv(icp4_reduction1, 3, 3, 224, 1, 1, name='icp4_out1')\n # branch 2\n icp4_reduction2 = NW.conv(icp3_out, 1, 1, 24, 1, 1, name='icp4_reduction2')\n icp4_out2 = NW.conv(icp4_reduction2, 5, 5, 64, 1, 1, name='icp4_out2')\n # branch 3\n icp4_pool = NW.max_pool(icp3_out, 3, 3, 1, 1, name='icp4_pool')\n icp4_out3 = NW.conv(icp4_pool, 1, 1, 64, 1, 1, name='icp4_out3')\n # concat\n icp4_out = NW.concat([icp4_out0,\n icp4_out1,\n icp4_out2,\n icp4_out3],3, name='icp4_out')\n\n \"\"\" 5st inception layer group \"\"\"\n print(\"icp5\")\n with tf.name_scope('icp5'):\n # branch 0\n icp5_out0 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_out0')\n # branch 1\n icp5_reduction1 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_reduction1')\n icp5_out1 = NW.conv(icp5_reduction1, 3, 3, 256, 1, 1, name='icp5_out1')\n # branch 2\n icp5_reduction2 = NW.conv(icp4_out,1, 1, 24, 1, 1, name='icp5_reduction2')\n icp5_out2 = NW.conv(icp5_reduction2, 5, 5, 64, 1, 1, name='icp5_out2')\n # branch 3\n icp5_pool = NW.max_pool(icp4_out,3, 3, 1, 1, name='icp5_pool')\n icp5_out3 = NW.conv(icp5_pool, 1, 1, 64, 1, 1, name='icp5_out3')\n # concat\n icp5_out = NW.concat([icp5_out0, \n icp5_out1, \n icp5_out2, \n icp5_out3], 3, name='icp5_out')\n \n \"\"\" 6st inception layer group \"\"\"\n print(\"icp6\")\n with tf.name_scope('icp6'):\n # branch 0\n icp6_out0 = NW.conv(icp5_out, 1, 1, 112, 1, 1, name='icp6_out0')\n # branch 1\n icp6_reduction1 = NW.conv(icp5_out, 1, 1, 144, 1, 1, name='icp6_reduction1')\n icp6_out1 = NW.conv(icp6_reduction1, 3, 3, 288, 1, 1, name='icp6_out1')\n # branch 2\n icp6_reduction2 = NW.conv(icp5_out, 1, 1, 32, 1, 1, name='icp6_reduction2')\n icp6_out2 = NW.conv(icp6_reduction2, 5, 5, 64, 1, 1, name='icp6_out2')\n # branch 3\n icp6_pool = NW.max_pool(icp5_out,3, 3, 1, 1, name='icp6_pool')\n icp6_out3 = NW.conv(icp6_pool, 1, 1, 64, 1, 1, name='icp6_out3')\n # concat\n icp6_out = NW.concat([icp6_out0,\n icp6_out1,\n icp6_out2,\n icp6_out3], 3, name='icp6_out')\n\n \"\"\" 2nd classify branch \"\"\"\n with tf.name_scope('cls2'):\n cls2_pool = NW.avg_pool(icp6_out, 5, 5, 3, 3, padding='VALID', name='cls2_pool')\n cls2_reduction_pose = NW.conv(cls2_pool, 1, 1, 128, 1, 1, name='cls2_reduction_pose')\n cls2_fc1 = NW.fc(cls2_reduction_pose, 1024, name='cls2_fc1')\n cls2_fc_pose_xy = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_xy')\n cls2_fc_pose_ab = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_ab')\n self.layers[\"cls2_fc_pose_xy\"] = cls2_fc_pose_xy\n self.layers[\"cls2_fc_pose_ab\"] = cls2_fc_pose_ab\n\n \"\"\" 7st inception layer group \"\"\"\n print(\"icp7\")\n with tf.name_scope('icp7'):\n # branch 0\n icp7_out0 = NW.conv(icp6_out, 1, 1, 256, 1, 1, name='icp7_out0')\n # branch 1\n icp7_reduction1 = NW.conv(icp6_out, 1, 1, 160, 1, 1, name='icp7_reduction1')\n icp7_out1 = NW.conv(icp7_reduction1, 3, 3, 320, 1, 1, name='icp7_out1')\n # branch 2\n icp7_reduction2 = NW.conv(icp6_out, 1, 1, 32, 1, 1, name='icp7_reduction2')\n icp7_out2 = NW.conv(icp7_reduction2, 5, 5, 128, 1, 1, name='icp7_out2')\n # branch 3\n icp7_pool = NW.max_pool(icp6_out, 3, 3, 1, 1, name='icp7_pool')\n icp7_out3 = NW.conv(icp7_pool, 1, 1, 128, 1, 1, name='icp7_out3')\n # concat\n icp7_out = NW.concat([icp7_out0,\n icp7_out1,\n icp7_out2,\n icp7_out3], 3, name='icp7_out')\n\n \"\"\" 8st inception layer group \"\"\"\n print(\"icp8\")\n with tf.name_scope('icp8'):\n icp8_in = NW.max_pool(icp7_out, 3, 3, 2, 2, name='icp8_in')\n # branch 0\n icp8_out0 = NW.conv(icp8_in, 1, 1, 256, 1, 1, name='icp8_out0')\n # branch 1\n icp8_reduction1 = NW.conv(icp8_in, 1, 1, 160, 1, 1, name='icp8_reduction1')\n icp8_out1 = NW.conv(icp8_reduction1, 3, 3, 320, 1, 1, name='icp8_out1')\n # branch 2\n icp8_reduction2 = NW.conv(icp8_in, 1, 1, 32, 1, 1, name='icp8_reduction2')\n icp8_out2 = NW.conv(icp8_reduction2, 5, 5, 128, 1, 1, name='icp8_out2')\n # branch 3\n icp8_pool = NW.max_pool(icp8_in, 3, 3, 1, 1, name='icp8_pool')\n icp8_out3 = NW.conv(icp8_pool, 1, 1, 128, 1, 1, name='icp8_out3')\n # concat\n icp8_out = NW.concat([icp8_out0,\n icp8_out1,\n icp8_out2,\n icp8_out3], 3, name='icp8_out')\n \n \"\"\" 9st inception layer group \"\"\"\n print(\"icp9\")\n with tf.name_scope('icp9'):\n # branch 0\n icp9_out0 = NW.conv(icp8_out, 1, 1, 384, 1, 1, name='icp9_out0')\n # branch 1\n icp9_reduction1 = NW.conv(icp8_out, 1, 1, 192, 1, 1, name='icp9_reduction1')\n icp9_out1 = NW.conv(icp9_reduction1, 3, 3, 384, 1, 1, name='icp9_out1')\n # branch 2\n icp9_reduction2 = NW.conv(icp8_out, 1, 1, 48, 1, 1, name='icp9_reduction2')\n icp9_out2 = NW.conv(icp9_reduction2, 5, 5, 128, 1, 1, name='icp9_out2')\n # branch 3\n icp9_pool = NW.max_pool(icp8_out, 3, 3, 1, 1, name='icp9_pool')\n icp9_out3 = NW.conv(icp9_pool, 1, 1, 128, 1, 1, name='icp9_out3')\n # concat\n icp9_out = NW.concat([icp9_out0,\n icp9_out1,\n icp9_out2,\n icp9_out3], 3, name='icp9_out')\n\n \"\"\" 3rd classify branch \"\"\"\n with tf.name_scope('cls3'):\n cls3_pool = NW.avg_pool(icp9_out, 7, 7, 1, 1, padding='VALID', name='cls3_pool')\n cls3_fc1_pose = NW.fc(cls3_pool, 2048, name='cls3_fc1_pose')\n cls3_fc_pose_xy = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_xy')\n cls3_fc_pose_ab = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_ab')\n self.layers[\"cls3_fc_pose_xy\"] = cls3_fc_pose_xy\n self.layers[\"cls3_fc_pose_ab\"] = cls3_fc_pose_ab","def main():\n feature_extraction_model = \"HOG\"\n # feature_extraction_models = [\"CM\", \"HOG\"]\n feature_extraction_model_1 = \"CM\"\n dimension_reduction_model = \"PCA\"\n k_value = 10\n dim_k_value = 40\n # K_value = 20\n # lab_folder = \"Dataset3/Labelled/Set1\"\n # unlab_folder = \"Dataset3/Unlabelled/Set 2\"\n lab_folder = get_input_folder(\"Labelled Folder\")\n unlab_folder = get_input_folder(\"Classify\")\n start = time.time()\n # ================================================================================================================\n # labelled Images\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\n folder_metadata=lab_folder,\n metadata_collection=\"labelled\")\n obj_feat_lab = dim_red.get_object_feature_matrix()\n features_list_lab = np.array(obj_feat_lab['featureVector'].tolist())\n images_list_lab = np.array(obj_feat_lab['imageId'])\n # filtering the labelled set\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\n\n # unlabelled images\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\n folder_metadata=unlab_folder,\n metadata_collection=\"unlabelled\")\n obj_feat_unlab = dim_red.get_object_feature_matrix()\n features_list_unlab = np.array(obj_feat_unlab['featureVector'].tolist())\n images_list_unlab = np.array(obj_feat_unlab['imageId'])\n\n # ================================================================================================================\n # labelled Images\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\n folder_metadata=lab_folder,\n metadata_collection=\"labelled\")\n obj_feat_lab_1 = dim_red.get_object_feature_matrix()\n features_list_lab_1 = np.array(obj_feat_lab_1['featureVector'].tolist())\n # images_list_lab = np.array(obj_feat_lab_1['imageId'])\n # filtering the labelled set\n\n\n # unlabelled images\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\n folder_metadata=unlab_folder,\n metadata_collection=\"unlabelled\")\n obj_feat_unlab_1 = dim_red.get_object_feature_matrix()\n features_list_unlab_1 = np.array(obj_feat_unlab_1['featureVector'].tolist())\n # images_list_unlab = np.array(obj_feat_unlab['imageId'])\n features_list_lab = np.concatenate((features_list_lab, features_list_lab_1), axis=1)\n features_list_unlab = np.concatenate((features_list_unlab, features_list_unlab_1), axis=1)\n\n # ================================================================================================================\n\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\n features_list = np.concatenate((features_list_lab, features_list_unlab))\n images_list = np.concatenate((images_list_lab, images_list_unlab))\n images_list = list(images_list)\n # Finding Similarity Matrix\n cos_sim = cosine_similarity(features_list)\n sim_graph = np.empty((0, len(cos_sim)))\n for row in cos_sim:\n k_largest = np.argsort(-np.array(row))[1:k_value + 1]\n sim_graph_row = [d if i in k_largest else 0 for i, d in enumerate(row)]\n sim_graph = np.append(sim_graph, np.array([sim_graph_row]), axis=0)\n\n row_sums = sim_graph.sum(axis=1)\n sim_graph = sim_graph / row_sums[:, np.newaxis]\n idx = 0\n results_dorsal = ppr(sim_graph, images_list, dorsal_list)\n results_palmar = ppr(sim_graph, images_list, palmar_list)\n final_results = {}\n\n for img in images_list_unlab:\n if results_dorsal[img] < results_palmar[img]:\n final_results[img] = \"dorsal\"\n else:\n final_results[img] = \"palmar\"\n\n actual_labels = fetch_actual_labels(images_list_unlab)\n print(\"Classification\")\n no_correct = 0\n correctly_classified = []\n incorrectly_classified = []\n print(\"| ImageId | Prediction | Actual |\")\n for r in final_results:\n print(\"| {} | {} | {} |\".format(r, final_results[r], actual_labels[r]))\n if final_results[r] == actual_labels[r]:\n correctly_classified.append(r)\n no_correct += 1\n else:\n incorrectly_classified.append(r)\n\n print(\"Correctly classified: {}\\n\".format(correctly_classified))\n print(\"InCorrectly classified: {}\\n\".format(incorrectly_classified))\n\n print(\"Classification Accuracy: {}%\".format(no_correct / len(images_list_unlab) * 100))\n print(\"Execution time: {} seconds\".format(time.time() - start))","def data_tf(img):\n img = crop.process(img)\n img = random_contrast.process(img)\n img = random_brightness.process(img)\n img = random_color.process(img)\n img = random_sharpness.process(img)\n if img.size[1] >= 32:\n img = compress.process(img)\n img = adjust_resolution.process(img)\n img = blur.process(img)\n img = exposure.process(img)\n # img = rotate.process(img)\n img = salt.process(img)\n img = inverse_color(img)\n img = stretch.process(img)\n return img","def mgcNetArch(self, **kwargs):\n\n def_vals = {\"input_img_rows\" : self.input_img_rows,\n \"input_img_cols\" : self.input_img_cols,\n \"channels\" : self.channels,\n \"nb_classes\" : self.nb_classes,\n \"outLayer\" : 'gloAvg', \n \"l2_val\" : 0.00, \n \"net_architr\" : 'cnn_max', \n \"block_typex\" : 'basic', \n \"block_repeatx\" : [1, 1]\n }\n\n\n for k, v in def_vals.items():\n kwargs.setdefault(k, v)\n\n _input_img_rows = kwargs['input_img_rows']\n _input_img_cols = kwargs['input_img_cols']\n _channels = kwargs['channels']\n _nb_classes = kwargs['nb_classes']\n _outLayer = kwargs['outLayer']\n _l2_val = kwargs['l2_val']\n _net_architr = kwargs['net_architr']\n _block_typex = kwargs['block_typex']\n _block_repeatx = kwargs['block_repeatx']\n \n \n params = {\"input_img_rows\" : _input_img_rows,\n \"input_img_cols\" : _input_img_cols,\n \"channels\" : _channels,\n \"nb_classes\" : _nb_classes\n }\n \n print(_net_architr)\n if _net_architr == 'cnn_max':\n model = mgcNetArchMax(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n elif _net_architr == 'cnn_stride':\n model = mgcNetArchStride2(outLayer = _outLayer, l2_val = _l2_val, **params)\n\n elif _net_architr == 'cnn_stride_mini':\n model = mgcNetArchStride2Mini(outLayer = _outLayer, l2_val = _l2_val, **params)\n\n elif _net_architr == 'common_cnn':\n model = mgcNetArchCommonCnn(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n elif _net_architr == 'net_in_net':\n model = mgcNetArchNin(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n elif _net_architr == 'resnet':\n model = mgcResnet(block_type = _block_typex, block_repeat = _block_repeatx, **params)\n \n elif _net_architr == 'resblock':\n model = mgcNetArchRes(outLayer = _outLayer, l2_val = _l2_val, **params)\n\n elif _net_architr == 'skipconnect':\n model = mgcNetArchSkip(outLayer = _outLayer, l2_val = _l2_val, **params)\n elif _net_architr == 'skipconnect_mini':\n model = mgcNetArchSkipMini(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n self.model = model\n self.plot_model = SVG(model_to_dot(model, show_shapes = True).create(prog='dot', format='svg'))\n #self.model_summary = model.summary() \n \n return self","def image_model_fn(self, features, labels, mode):\n col_count, row_count = self.metadata_.get_matrix_size(0)\n sequence_size = self.metadata_.get_sequence_size()\n output_dim = self.metadata_.get_output_size()\n\n # Input Layer\n input_layer = features[\"x\"]\n # Transpose X to 4-D tensor: [batch_size, row_count, col_count, sequence_size]\n # Normally the last axis should be channels instead of time axis, but they\n # are both equal to 1 for images\n hidden_layer = tf.transpose(input_layer, [0, 2, 3, 1])\n # At begining number of filters = 32\n num_filters = 32\n while True:\n hidden_layer = tf.layers.conv2d(\n inputs=hidden_layer,\n filters=num_filters,\n kernel_size=[3, 3],\n strides=(1, 1),\n padding=\"same\",\n activation=tf.nn.relu)\n hidden_layer = tf.layers.max_pooling2d(inputs=hidden_layer, pool_size=[2, 2], strides=2)\n num_rows = hidden_layer.shape[1]\n num_columns = hidden_layer.shape[2]\n num_filters *= 2 # Double number of filters each time\n if num_rows == 1 or num_columns == 1:\n break\n hidden_layer = tf.layers.flatten(hidden_layer)\n hidden_layer = tf.layers.dense(inputs=hidden_layer, units=1024, activation=tf.nn.relu)\n hidden_layer = tf.layers.dropout(\n inputs=hidden_layer, rate=0.5, training=mode == tf.estimator.ModeKeys.TRAIN)\n logits = tf.layers.dense(inputs=hidden_layer, units=output_dim)\n sigmoid_tensor = tf.nn.sigmoid(logits, name=\"sigmoid_tensor\")\n\n predictions = {\n # Generate predictions (for PREDICT and EVAL mode)\n \"classes\": tf.argmax(input=logits, axis=1),\n # Add `sigmoid_tensor` to the graph. It is used for PREDICT and by the\n # `logging_hook`.\n \"probabilities\": sigmoid_tensor\n }\n if mode == tf.estimator.ModeKeys.PREDICT:\n return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)\n\n # Calculate Loss (for both TRAIN and EVAL modes)\n # For multi-label classification, a correct loss is sigmoid cross entropy\n loss = sigmoid_cross_entropy_with_logits(labels=labels, logits=logits)\n\n # Configure the Training Op (for TRAIN mode)\n if mode == tf.estimator.ModeKeys.TRAIN:\n optimizer = tf.train.AdamOptimizer()\n train_op = optimizer.minimize(\n loss=loss,\n global_step=tf.train.get_global_step())\n return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)\n\n # Add evaluation metrics (for EVAL mode)\n eval_metric_ops = {\n \"accuracy\": tf.metrics.accuracy(\n labels=labels, predictions=predictions[\"classes\"])}\n return tf.estimator.EstimatorSpec(\n mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)","def combine_images(args):\n\n # Read all images into a cube (TODO: think about the RAM)\n with fits.open(args.input[0]) as im0:\n lx, ly = im0[0].data.shape\n ref_hdr = im0[0].header\n\n headers = [fits.open(im_name)[0].header for im_name in args.input]\n cube = numpy.ma.zeros((len(args.input), lx, ly))\n cube.mask = numpy.zeros_like(cube.data)\n for ii, im_name in enumerate(args.input):\n with astroim.Astroim(im_name) as im:\n cube.data[ii, :,:] = im.chips[0].data\n if im.chips[0].mask is not None:\n cube.mask[ii,:,:] = im.chips[0].mask\n\n # Scale images\n scale_functions = {\"median\": numpy.ma.median,\n \"mean\": numpy.ma.mean,\n \"mode\": scipy.stats.mstats.mode,\n \"none\": lambda x: 1}\n for ii, im_name in enumerate(args.input):\n func = scale_functions[args.scale.lower()]\n cube[ii,:,:] /= func(cube[ii,:,:])\n\n\n # Reproject all images to the ref_hdr\n for ii, _ in enumerate(args.input):\n if ii == 0:\n continue\n cube.data[ii,:,:], footprint = reproject_interp((cube.data[ii,:,:], headers[ii]), ref_hdr)\n cube.mask[ii,:,:], footprint = reproject_interp((cube.mask[ii,:,:], headers[ii]), ref_hdr)\n #whr = numpy.isnan(cube.data[ii,:,:])\n #cube.mask[ii,:,:][whr] = True\n\n # Do average\n average_functions = {\"median\": numpy.ma.median, \"mean\": numpy.ma.mean, \"sum\": numpy.ma.sum}\n func = average_functions[args.average.lower()]\n final_image = func(cube, axis=0)\n ref_hdr[\"NCOMBINE\"] = len(args.input)\n\n mask_name = utilities.replace_extension(args.output, \".fits.msk\")\n mask_name_header = utilities.replace_extension(os.path.basename(args.output), \".fits.msk\")\n ref_hdr[\"MASK\"] = mask_name_header\n fits.writeto(args.output, final_image.data, ref_hdr, clobber=True )\n fits.writeto(mask_name, numpy.array(final_image.mask, dtype=int), clobber=True)\n\n return args.output","def enhance(img, window=30):\n hp = highPassFilter(img, window=window)\n tmp = grayscale(img) + laplacian(img)\n return tmp","def image_model_predict(input_ms_image_filename, input_pan_image_filename, pan_img_height_size, pan_img_width_size, \r\n fitted_model, write, output_filename):\r\n \r\n with rasterio.open(input_ms_image_filename) as f:\r\n metadata = f.profile\r\n ms_img = np.transpose(f.read(tuple(np.arange(metadata['count']) + 1)), [1, 2, 0])\r\n \r\n with rasterio.open(input_pan_image_filename) as g:\r\n metadata_pan = g.profile\r\n pan_img = g.read(1)\r\n \r\n pan_img = np.expand_dims(pan_img, axis = 2)\r\n \r\n ms_to_pan_ratio = metadata['transform'][0] / metadata_pan['transform'][0]\r\n \r\n class_layer = np.zeros((pan_img.shape[0], pan_img.shape[1]))\r\n \r\n img_pan_holder = []\r\n img_ms_holder = []\r\n \r\n for i in range(0, pan_img.shape[0] - pan_img_height_size, int(ms_to_pan_ratio)):\r\n for j in range(0, pan_img.shape[1] - pan_img_width_size, int(ms_to_pan_ratio)):\r\n img_pan_iter = pan_img[i : i + pan_img_height_size, j : j + pan_img_width_size, 0]\r\n img_pan_holder.append(img_pan_iter)\r\n \r\n for i in range(0, int(ms_img.shape[0] - (pan_img_height_size / ms_to_pan_ratio)), int(ms_to_pan_ratio)):\r\n for j in range(0, int(pan_img.shape[1] - (pan_img_width_size / ms_to_pan_ratio)), int(ms_to_pan_ratio)):\r\n img_ms_iter = ms_img[i : int(i + (pan_img_height_size / ms_to_pan_ratio)), \r\n j : int(j + (pan_img_width_size / ms_to_pan_ratio)), \r\n 0 : metadata['count']]\r\n img_ms_holder.append(img_ms_iter)\r\n \r\n img_pan_array = np.concatenate(img_pan_holder, axis = 0)\r\n img_ms_array = np.concatenate(img_ms_holder, axis = 0)\r\n \r\n pred_array = np.argmax(fitted_model.predict([img_ms_array, img_pan_array]), axis = 1)\r\n \r\n n = 0 \r\n for i in range(int(pan_img_height_size / 2), pan_img.shape[0] - int(pan_img_height_size / 2), int(ms_to_pan_ratio)):\r\n for j in range(int(pan_img_width_size / 2), pan_img.shape[1] - int(pan_img_width_size / 2), int(ms_to_pan_ratio)):\r\n class_layer[i, j] = pred_array[n]\r\n n += 1\r\n \r\n if write:\r\n with rasterio.open(output_filename, 'w', **metadata_pan) as dst:\r\n dst.write(class_layer)\r\n \r\n return class_layer","def build_resnet101(self):\n use_batch_norm = self.use_batch_norm\n\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\n is_train = tf.placeholder(tf.bool)\n\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\n conv1_feats = nonlinear(conv1_feats, 'relu')\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\n\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\n \n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128) \n temp = res3a_feats\n for i in range(1, 4):\n temp = self.basic_block2(temp, 'res3b'+str(i), 'bn3b'+str(i), is_train, use_batch_norm, 128)\n res3b3_feats = temp\n \n res4a_feats = self.basic_block(res3b3_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\n temp = res4a_feats\n for i in range(1, 23):\n temp = self.basic_block2(temp, 'res4b'+str(i), 'bn4b'+str(i), is_train, use_batch_norm, 256)\n res4b22_feats = temp\n\n res5a_feats = self.basic_block(res4b22_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\n\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\n self.conv_feats = res5c_feats_flat\n self.conv_feat_shape = [49, 2048]\n self.num_ctx = 49 \n self.dim_ctx = 2048\n\n self.imgs = imgs\n self.is_train = is_train","def train(images, labels, fold, model_type, batch_size=32, num_epochs=5):\n num_classes = len(np.unique(labels))\n (X_train, y_train), (X_val, y_val), (X_test, y_test) = reformatInput(images, labels, fold)\n X_train = X_train.astype(\"float32\", casting='unsafe')\n X_val = X_val.astype(\"float32\", casting='unsafe')\n X_test = X_test.astype(\"float32\", casting='unsafe')\n # Prepare Theano variables for inputs and targets\n input_var = T.TensorType('floatX', ((False,) * 5))()\n target_var = T.ivector('targets')\n # Create neural network model (depending on first command line parameter)\n print(\"Building model and compiling functions...\")\n # Building the appropriate model\n if model_type == '1dconv':\n network = build_convpool_conv1d(input_var, num_classes)\n elif model_type == 'maxpool':\n network = build_convpool_max(input_var, num_classes)\n elif model_type == 'lstm':\n network = build_convpool_lstm(input_var, num_classes, 100)\n elif model_type == 'mix':\n network = build_convpool_mix(input_var, num_classes, 100)\n elif model_type == 'cnn':\n input_var = T.tensor4('inputs')\n network, _ = build_cnn(input_var)\n network = DenseLayer(lasagne.layers.dropout(network, p=.5),\n num_units=256,\n nonlinearity=lasagne.nonlinearities.rectify)\n network = DenseLayer(lasagne.layers.dropout(network, p=.5),\n num_units=num_classes,\n nonlinearity=lasagne.nonlinearities.softmax)\n else:\n raise ValueError(\"Model not supported ['1dconv', 'maxpool', 'lstm', 'mix', 'cnn']\")\n # Create a loss expression for training, i.e., a scalar objective we want\n # to minimize (for our multi-class problem, it is the cross-entropy loss):\n prediction = lasagne.layers.get_output(network)\n loss = lasagne.objectives.categorical_crossentropy(prediction, target_var)\n loss = loss.mean()\n params = lasagne.layers.get_all_params(network, trainable=True)\n updates = lasagne.updates.adam(loss, params, learning_rate=0.001)\n # Create a loss expression for validation/testing. The crucial difference\n # here is that we do a deterministic forward pass through the network,\n # disabling dropout layers.\n test_prediction = lasagne.layers.get_output(network, deterministic=True)\n test_loss = lasagne.objectives.categorical_crossentropy(test_prediction,\n target_var)\n test_loss = test_loss.mean()\n # As a bonus, also create an expression for the classification accuracy:\n test_acc = T.mean(T.eq(T.argmax(test_prediction, axis=1), target_var),\n dtype=theano.config.floatX)\n # Compile a function performing a training step on a mini-batch (by giving\n # the updates dictionary) and returning the corresponding training loss:\n train_fn = theano.function([input_var, target_var], loss, updates=updates)\n # Compile a second function computing the validation loss and accuracy:\n val_fn = theano.function([input_var, target_var], [test_loss, test_acc])\n # Finally, launch the training loop.\n print(\"Starting training...\")\n best_validation_accu = 0\n # We iterate over epochs:\n for epoch in range(num_epochs):\n # In each epoch, we do a full pass over the training data:\n train_err = 0\n train_batches = 0\n start_time = time.time()\n for batch in iterate_minibatches(X_train, y_train, batch_size, shuffle=False):\n inputs, targets = batch\n train_err += train_fn(inputs, targets)\n train_batches += 1\n # And a full pass over the validation data:\n val_err = 0\n val_acc = 0\n val_batches = 0\n for batch in iterate_minibatches(X_val, y_val, batch_size, shuffle=False):\n inputs, targets = batch\n err, acc = val_fn(inputs, targets)\n val_err += err\n val_acc += acc\n val_batches += 1\n av_train_err = train_err / train_batches\n av_val_err = val_err / val_batches\n av_val_acc = val_acc / val_batches\n # Then we print the results for this epoch:\n print(\"Epoch {} of {} took {:.3f}s\".format(\n epoch + 1, num_epochs, time.time() - start_time))\n print(\" training loss:\\t\\t{:.6f}\".format(av_train_err))\n print(\" validation loss:\\t\\t{:.6f}\".format(av_val_err))\n print(\" validation accuracy:\\t\\t{:.2f} %\".format(av_val_acc * 100))\n if av_val_acc > best_validation_accu:\n best_validation_accu = av_val_acc\n # After training, we compute and print the test error:\n test_err = 0\n test_acc = 0\n test_batches = 0\n for batch in iterate_minibatches(X_test, y_test, batch_size, shuffle=False):\n inputs, targets = batch\n err, acc = val_fn(inputs, targets)\n test_err += err\n test_acc += acc\n test_batches += 1\n av_test_err = test_err / test_batches\n av_test_acc = test_acc / test_batches\n print(\"Final results:\")\n print(\" test loss:\\t\\t\\t{:.6f}\".format(av_test_err))\n print(\" test accuracy:\\t\\t{:.2f} %\".format(av_test_acc * 100))\n # Dump the network weights to a file like this:\n np.savez('weights_lasg_{0}'.format(model_type), *lasagne.layers.get_all_param_values(network))\n print('-'*50)\n print(\"Best validation accuracy:\\t\\t{:.2f} %\".format(best_validation_accu * 100))\n print(\"Best test accuracy:\\t\\t{:.2f} %\".format(av_test_acc * 100))","def model(input_shape, output_dim, num_hidden_units,num_hidden_units_2, num_code_units, filter_size, batch_size=BATCH_SIZE):\n shape = tuple([None]+list(input_shape[1:]))\n print(shape)\n l_in = lasagne.layers.InputLayer(shape=shape)\n\n print(\"Input shape: \",lasagne.layers.get_output_shape(l_in))\n\n # print(shaped_units)\n # shaped_units = shaped_units[0]\n shaped_units = 2800\n\n # print(shape)\n\n l_conv2D_1 = lasagne.layers.Conv2DLayer(\n l_in, \n num_filters=8,\n filter_size=filter_size, \n stride=(1, 1), \n border_mode=\"valid\", \n untie_biases=False, \n nonlinearity=None,\n )\n\n print(\"Conv 2D shape: \",lasagne.layers.get_output_shape(l_conv2D_1))\n\n l_reshape_1 = lasagne.layers.ReshapeLayer(\n l_conv2D_1,\n shape=(([0], -1))\n )\n\n print(\"Reshape 1 shape: \", lasagne.layers.get_output_shape(l_reshape_1))\n\n l_hidden_1 = lasagne.layers.DenseLayer(\n l_reshape_1,\n num_units= num_hidden_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Hidden 1 shape: \", lasagne.layers.get_output_shape(l_hidden_1))\n\n l_code_layer = lasagne.layers.DenseLayer(\n l_hidden_1,\n num_units=num_code_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Code layer shape: \",lasagne.layers.get_output_shape(l_code_layer))\n\n l_hidden_2 = lasagne.layers.DenseLayer(\n l_code_layer,\n num_units=num_hidden_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Hidden 2 shape: \",lasagne.layers.get_output_shape(l_hidden_2))\n\n l_hidden_3 = lasagne.layers.DenseLayer(\n l_hidden_2,\n num_units=shaped_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Hidden 3 shape: \",lasagne.layers.get_output_shape(l_hidden_3))\n\n l_reshape_2 = lasagne.layers.ReshapeLayer(\n l_hidden_3,\n shape=(([0],8,7,50))\n )\n\n print(\"Reshape 2 shape: \",lasagne.layers.get_output_shape(l_reshape_2))\n\n l_out = lasagne.layers.Conv2DLayer(\n l_reshape_2, \n num_filters=1,\n filter_size=filter_size, \n stride=(1, 1), \n border_mode=\"valid\", \n untie_biases=False, \n nonlinearity=None,\n )\n\n # print(\"Deconv shape: \",lasagne.layers.get_output_shape(l_deconv2D_1))\n\n print(\"Output shape: \",lasagne.layers.get_output_shape(l_out))\n\n return l_out","def forward_train(self, img, img_metas, **kwargs):\n labels = {}\n labels['trans_inv'] = kwargs['trans_inv']\n labels['intrinsic_param'] = kwargs['intrinsic_param']\n labels['joint_root'] = kwargs['joint_root']\n labels['depth_factor'] = kwargs['depth_factor']\n labels['target_uvd_29'] = kwargs['target_uvd_29']\n labels['target_xyz_24'] = kwargs['target_xyz_24']\n labels['target_weight_24'] = kwargs['target_weight_24']\n labels['target_weight_29'] = kwargs['target_weight_29']\n labels['target_xyz_17'] = kwargs['target_xyz_17']\n labels['target_weight_17'] = kwargs['target_weight_17']\n labels['target_theta'] = kwargs['target_theta']\n labels['target_beta'] = kwargs['target_beta']\n labels['target_smpl_weight'] = kwargs['target_smpl_weight']\n labels['target_theta_weight'] = kwargs['target_theta_weight']\n labels['target_twist'] = kwargs['target_twist']\n labels['target_twist_weight'] = kwargs['target_twist_weight']\n # flip_output = kwargs.pop('is_flipped', None)\n\n for k, _ in labels.items():\n labels[k] = labels[k].cuda()\n\n trans_inv = labels.pop('trans_inv')\n intrinsic_param = labels.pop('intrinsic_param')\n joint_root = labels.pop('joint_root')\n depth_factor = labels.pop('depth_factor')\n\n if self.backbone is not None:\n img = img.cuda().requires_grad_()\n features = self.backbone(img)\n features = features[0]\n else:\n features = img['features']\n\n if self.neck is not None:\n features = self.neck(features)\n\n predictions = self.head(features, trans_inv, intrinsic_param,\n joint_root, depth_factor, self.smpl)\n\n losses = self.compute_losses(predictions, labels)\n\n return losses","def construct_from_anatomy(self, anet, architecture):\n # construct conv layer for input -> LGNd\n self.area_channels['input'] = INPUT_SIZE[0]\n self.area_size['input'] = INPUT_SIZE[1]\n \n out_sigma = 1\n out_channels = np.floor(anet.find_layer('LGNd','').num/out_sigma/INPUT_SIZE[1]/INPUT_SIZE[2])\n architecture.set_num_channels('LGNd', '', out_channels)\n self.area_channels['LGNd'] = out_channels\n \n out_size = INPUT_SIZE[1] * out_sigma\n self.area_size['LGNd'] = out_size\n \n convlayer = ConvLayer('input', 'LGNd',\n ConvParam(in_channels=INPUT_SIZE[0], \n out_channels=out_channels,\n gsh=INPUT_GSH,\n gsw=INPUT_GSW, out_sigma=out_sigma),\n out_size)\n self.layers.append(convlayer)\n \n # construct conv layers for all other connections\n G, _ = anet.make_graph()\n Gtop = nx.topological_sort(G)\n root = next(Gtop) # get root of graph\n for i, e in enumerate(nx.edge_bfs(G, root)):\n \n in_layer_name = e[0].area+e[0].depth\n out_layer_name = e[1].area+e[1].depth\n print('constructing layer %s: %s to %s'%(i, in_layer_name, out_layer_name))\n \n in_conv_layer = self.find_conv_target_area(in_layer_name)\n in_size = in_conv_layer.out_size\n in_channels = in_conv_layer.params.out_channels\n \n out_anat_layer = anet.find_layer(e[1].area, e[1].depth)\n \n out_sigma = get_out_sigma(e[0].area, e[0].depth, e[1].area, e[1].depth)\n out_size = in_size * out_sigma\n self.area_size[e[1].area+e[1].depth] = out_size\n\n if SUBFIELDS:\n pixel_area = calculate_pixel_area_with_visual_field(architecture, e[1].area, e[1].depth)\n out_channels = np.floor(out_anat_layer.num / pixel_area)\n else:\n out_channels = np.floor(out_anat_layer.num/out_size**2)\n\n architecture.set_num_channels(e[1].area, e[1].depth, out_channels)\n self.area_channels[e[1].area+e[1].depth] = out_channels\n \n convlayer = ConvLayer(in_layer_name, out_layer_name, \n ConvParam(in_channels=in_channels, \n out_channels=out_channels,\n gsh=architecture.get_kernel_peak_probability(e[0].area, e[0].depth, e[1].area, e[1].depth),\n gsw=architecture.get_kernel_width_pixels(e[0].area, e[0].depth, e[1].area, e[1].depth), out_sigma=out_sigma),\n out_size)\n \n self.layers.append(convlayer)","def forward_train(self, img, img_metas, **kwargs):","def train(trial_num, image_num, filter_num, filter_size, input_size, channel_num, pooling_rate, left_upper_padding, right_lower_padding):\n\n input_batch_num = 1\n batch_num = 2\n\n init_filters = np.array(np.random.normal(size=filter_num * channel_num *\n filter_size*filter_size), dtype=\"float32\")\n #init_filters = np.array([1.0] * filter_num * channel_num * filter_size * filter_size, dtype=\"float32\")\n init_filters = 0.01 * init_filters.reshape(filter_num, channel_num*filter_size*filter_size)\n\n init_hbias = np.array([-0.1] * filter_num, dtype=\"float32\").reshape(filter_num, 1)\n\n init_vbias = np.array([0.0] * channel_num, dtype=\"float32\").reshape(channel_num, 1)\n\n libnvcrbm = __import__(\"nvcrbm\")\n cur_filters = libnvcrbm.init(filter_num, filter_size, \n input_batch_num, input_size, channel_num,\n pooling_rate, left_upper_padding, right_lower_padding,\n init_filters, init_hbias, init_vbias)\n\n imgs = cPickle.load(open(\"../data/kyoto_large_train.pkl\", \"r\"))\n img_size = imgs[0].shape[0]\n\n for trial_idx in xrange(trial_num):\n for img_idx in xrange(image_num):\n for batch_idx in xrange(batch_num):\n row_idx = np.arange(0, input_size) + np.random.random_integers(img_size - 2 * filter_size - input_size) + filter_size - 1\n col_idx = np.arange(0, input_size) + np.random.random_integers(img_size - 2 * filter_size - input_size) + filter_size - 1\n #row_idx = np.arange(0, input_size) + 200\n #col_idx = np.arange(0, input_size) + 200\n\n batch_data = imgs[img_idx][row_idx][:,col_idx]\n batch_data = batch_data - batch_data.mean()\n batch_data = np.asarray(batch_data.reshape(1, input_size * input_size), dtype=\"float32\")\n \n libnvcrbm.run_batch(trial_idx, img_idx, batch_idx, batch_data)\n\n libnvcrbm.print_result()\n cur_filters = libnvcrbm.get_gpu_filters()\n dump_filter_image(cur_filters, \"../data/kyoto/filters/trial_%d.png\" % trial_idx)\n\n first_layer = {}\n first_layer[\"filters\"] = cur_filters\n first_layer[\"bias\"] = libnvcrbm.get_gpu_hbias()\n cPickle.dump(first_layer, open(\"../data/first_layer.dat\", \"w+\"))","def build_model(self):\n\n # If center crop is valid, output dimensions will be the image dimensions.\n\n if self.is_crop:\n image_dims = [self.output_height, self.output_width, self.c_dim]\n else:\n # Otherwise, input dimensions will not be changed.\n image_dims = [self.input_height, self.input_width, self.c_dim]\n self.image_dims = image_dims\n\n # GAN latent variable.\n self.z = tf.placeholder(tf.float32, [FLAGS.batch_size + FLAGS.cs_batch_size, self.z_dim], name='z')\n\n if not FLAGS.just_cs: # If we are not training only on measurements (non-compressed data is present).\n self.inputs = tf.placeholder(tf.float32, [\n FLAGS.batch_size + FLAGS.cs_batch_size] + image_dims, name='real_images')\n self.sample_inputs = tf.placeholder(tf.float32, [self.sample_num] + image_dims, name='sample_inputs')\n\n if self.cs_learning: # If not DCGAN.\n # Load the A (sampling) matrix.\n if self.superres_learning:\n self.A_val = get_A_superres()\n FLAGS.cs_num_measurements = self.A_val.shape[1]\n elif self.inpaint_learning:\n self.A_val = get_A_inpaint()\n FLAGS.cs_num_measurements = self.A_val.shape[1]\n else:\n # Use the same A matrix for all of the experiments.\n A_path = os.path.join(FLAGS.sampling_mat_dir,\n '{}_w{}_h{}_m{}_a{}.pckl'.format(FLAGS.dataset, FLAGS.output_width,\n FLAGS.output_height, FLAGS.cs_num_measurements,\n FLAGS.a_ind))\n if os.path.exists(A_path):\n with open(A_path, 'r') as f:\n self.A_val = cPickle.load(f)\n else:\n raise RuntimeError('[!] No A matrix was found at {}. Run the following command first:\\n'\n 'python main.py --cfg <config> --generate_A'.format(A_path))\n\n self.A = tf.constant(self.A_val, dtype=tf.float32)\n\n # Batch size for compressed measurements.\n cs_bsize = FLAGS.cs_batch_size\n if self.cs_m_and_orig:\n # In algorithm 2, we use the compressed original samples to\n # train the discriminator of the measurements too.\n cs_bsize = cs_bsize + FLAGS.batch_size\n\n if self.cs_m_and_orig:\n print('[#] Solving for both the measurements and original inputs.')\n # Placeholder for original samples.\n self.orig_inputs = tf.placeholder(tf.float32, [\n FLAGS.batch_size] + image_dims, name='real_images')\n elif FLAGS.just_cs:\n print('[#] Solving for just the measurements, not the original inputs.')\n\n # Placeholder for compressed measurements.\n self.xs_target = tf.placeholder(tf.float32, [cs_bsize] + self.image_dims, name='target_xs')\n # Compute y_batch on GPU.\n self.y_batch = tf.matmul(tf.reshape(self.xs_target, [cs_bsize, -1]), self.A) + \\\n FLAGS.cs_noise_std * tf.random_normal([cs_bsize, FLAGS.cs_num_measurements])\n\n if FLAGS.just_cs: # If we are in only compressed measurements mode, the inputs are y_batches.\n self.inputs = self.y_batch\n\n # Batch normalization (deals with poor initialization helps gradient flow).\n self.d_bn1 = batch_norm(name='d_bn1')\n self.d_bn2 = batch_norm(name='d_bn2')\n self.d_bn3 = batch_norm(name='d_bn3')\n self.g_bn0 = batch_norm(name='g_bn0')\n self.g_bn1 = batch_norm(name='g_bn1')\n self.g_bn2 = batch_norm(name='g_bn2')\n self.g_bn3 = batch_norm(name='g_bn3')\n\n # Generator network.\n self.G = self.generator(self.z, batch_size=FLAGS.cs_batch_size + FLAGS.batch_size)\n\n # Discriminator network outputs.\n self.D, self.D_logits = self.discriminator(self.inputs, batch_size=FLAGS.cs_batch_size + FLAGS.batch_size)\n\n def sigmoid_cross_entropy_with_logits(x, y):\n return tf.nn.sigmoid_cross_entropy_with_logits(logits=x, labels=y)\n\n # If both compressed measurements and original images are used.\n if self.cs_m_and_orig:\n measured_generator_output = tf.matmul(\n tf.reshape(self.G, [FLAGS.cs_batch_size + FLAGS.batch_size, FLAGS.n_inputs]), self.A)\n self.D_, self.D_logits_ = self.discriminator(measured_generator_output, reuse=True,\n batch_size=FLAGS.cs_batch_size + FLAGS.batch_size)\n # Create disciriminator for original inputs.\n self.D_orig, self.D_logits_orig = self.discriminator(self.orig_inputs, reuse=False,\n batch_size=FLAGS.batch_size, orig=True)\n # Give the generator to the original inputs discriminator.\n self.D_orig_, self.D_logits_orig_ = self.discriminator(self.G, reuse=True,\n batch_size=FLAGS.cs_batch_size + FLAGS.batch_size,\n orig=True)\n\n # Losses and summaries.\n self.d_loss_orig_real = tf.reduce_mean(\n sigmoid_cross_entropy_with_logits(self.D_logits_orig, tf.ones_like(self.D_orig)))\n\n self.d_loss_orig_fake = tf.reduce_mean(\n sigmoid_cross_entropy_with_logits(self.D_logits_orig_, tf.zeros_like(self.D_orig_)))\n\n self.d_loss_orig_sum = scalar_summary(\"d_loss_orig_sum\", self.d_loss_orig_real + self.d_loss_orig_fake)\n\n self.g_loss_orig = tf.reduce_mean(\n sigmoid_cross_entropy_with_logits(self.D_logits_orig_, tf.ones_like(self.D_orig_)))\n\n # If only compressed measurements are used.\n elif FLAGS.just_cs:\n # The measurements on the output of the generator.\n measured_generator_output = tf.matmul(\n tf.reshape(self.G, [FLAGS.cs_batch_size + FLAGS.batch_size, FLAGS.n_inputs]), self.A)\n\n self.D_, self.D_logits_ = self.discriminator(measured_generator_output, reuse=True,\n batch_size=FLAGS.cs_batch_size + FLAGS.batch_size)\n\n # If only original images are used.\n else:\n self.D_, self.D_logits_ = self.discriminator(self.G, reuse=True,\n batch_size=FLAGS.cs_batch_size + FLAGS.batch_size)\n\n # Losses and summaries.\n self.d_loss_real = tf.reduce_mean(sigmoid_cross_entropy_with_logits(self.D_logits, tf.ones_like(self.D)))\n self.d_loss_fake = tf.reduce_mean(sigmoid_cross_entropy_with_logits(self.D_logits_, tf.zeros_like(self.D_)))\n\n self.g_loss = tf.reduce_mean(sigmoid_cross_entropy_with_logits(self.D_logits_, tf.ones_like(self.D_)))\n\n self.d_loss_real_sum = scalar_summary(\"d_loss_real\", self.d_loss_real)\n self.d_loss_fake_sum = scalar_summary(\"d_loss_fake\", self.d_loss_fake)\n\n self.d_loss = self.d_loss_real + self.d_loss_fake\n\n # If both compressed measurements and original images are used, add the two losses.\n if self.cs_m_and_orig:\n self.g_loss = self.g_loss + self.g_loss_orig\n self.d_loss = self.d_loss + self.d_loss_orig_real + self.d_loss_orig_fake\n\n self.g_loss_sum = scalar_summary(\"g_loss\", self.g_loss)\n self.d_loss_sum = scalar_summary(\"d_loss\", self.d_loss)\n\n t_vars = tf.global_variables()\n\n # Gather variables.\n self.d_vars = [var for var in t_vars if 'disc' in var.name]\n self.g_vars = [var for var in t_vars if 'generator' in var.name]\n self.other_vars = [var for var in tf.global_variables() if 'save_' in var.name]\n\n self.save_var_names = self.d_vars + self.g_vars + self.other_vars\n\n # Build the Compressed Sensing estimator.\n if self.cs_learning:\n self.cs_grad_estimator()\n\n # Keep all checkpoints.\n if self.keep_all:\n self.saver = tf.train.Saver(self.save_var_names, max_to_keep=None)\n else:\n self.saver = tf.train.Saver(self.save_var_names)","def _build(self, generation):\n with tf.variable_scope ('discriminator') as scope:\n \n image_unflatten = unflatten_layer ( self.images )\n gen_unflatten = unflatten_layer ( generation )\n\n # Conv Layer 1 - image\n conv1_out_image, params = conv_2d_layer (\n input = image_unflatten,\n neurons = CONV_1_N,\n filter_size = CONV_1_FILT,\n name = 'conv_1_img',\n visualize = True ) \n pool1_out_img = max_pool_2d_layer ( input = conv1_out_image, name = 'pool_1_img')\n lrn1_out_img = local_response_normalization_layer (pool1_out_img, name = 'lrn_1_img' ) \n \n # Conv Layer 1 - gen\n conv1_out_gen, params = conv_2d_layer (\n input = gen_unflatten,\n neurons = CONV_1_N,\n filter_size = CONV_1_FILT,\n params = params,\n name = 'conv_1_gen',\n visualize = False )\n\n pool1_out_gen = max_pool_2d_layer ( input = conv1_out_gen, name = 'pool_1_gen')\n lrn1_out_gen = local_response_normalization_layer (pool1_out_gen, name = 'lrn_1_gen' ) \n process_params(params, name = self.name)\n c1_params = params\n\n\n\n\n\n # Conv Layer 2 - image\n conv2_out_image, params = conv_2d_layer (\n input = lrn1_out_img,\n neurons = CONV_2_N,\n filter_size = CONV_2_FILT,\n name = 'conv_2_img' )\n\n pool2_out_img = max_pool_2d_layer ( input = conv2_out_image, name = 'pool_2_img')\n lrn2_out_img = local_response_normalization_layer (pool2_out_img, name = 'lrn_2_img' ) \n\n\n # Conv Layer 2 - gen\n conv2_out_gen, params = conv_2d_layer (\n input = lrn1_out_gen,\n neurons = CONV_2_N,\n filter_size = CONV_2_FILT,\n params = params,\n name = 'conv_2_gen' )\n\n pool2_out_gen = max_pool_2d_layer ( input = conv2_out_gen, name = 'pool_2_gen')\n lrn2_out_gen = local_response_normalization_layer (pool2_out_gen, name = 'lrn_2_gen' ) \n process_params(params, name = self.name)\n c2_params = params\n\n # Dropout Layer\n flat_gen = flatten_layer(lrn2_out_gen)\n flat_img = flatten_layer(lrn2_out_img)\n\n flat_gen_dropout = dropout_layer ( input = flat_gen,\n prob = self.dropout_prob,\n name = 'dropout_1_gen') \n\n flat_img_dropout = dropout_layer ( input = flat_img,\n prob = self.dropout_prob,\n name = 'dropout_1_img') \n\n\n\n # Dot Product Layer 1 -img\n fc1_out_img, params = dot_product_layer ( input = flat_img_dropout,\n neurons = HIDDEN_1,\n name = 'image_disc_dot_1')\n # Dot Product Layer 1 - gen\n fc1_out_gen, params = dot_product_layer ( input = flat_gen_dropout,\n params = params,\n neurons = HIDDEN_2,\n name = 'gen_disc_dot_1')\n\n process_params(params, name = self.name)\n d1_params = params\n \n ##\n fc1_out_gen_dropout = dropout_layer ( input = fc1_out_gen,\n prob = self.dropout_prob,\n name = 'dropout_2_gen') \n fc1_out_img_dropout = dropout_layer ( input = fc1_out_img,\n prob = self.dropout_prob,\n name = 'dropout_2_img')\n\n # Dot Product Layer 2 -img\n fc2_out_img, params = dot_product_layer ( input = fc1_out_img_dropout,\n neurons = HIDDEN_2,\n name = 'image_disc_dot_2')\n # Dot Product Layer 2 - gen\n fc2_out_gen, params = dot_product_layer ( input = fc1_out_gen_dropout,\n params = params,\n neurons = HIDDEN_2,\n name = 'gen_disc_dot_2')\n process_params(params, name = self.name)\n d2_params = params\n\n ##\n fc2_out_gen_dropout = dropout_layer ( input = fc2_out_gen,\n prob = self.dropout_prob,\n name = 'dropout_3_gen') \n fc2_out_img_dropout = dropout_layer ( input = fc2_out_img,\n prob = self.dropout_prob,\n name = 'dropout_3_img')\n\n # Dot Product Layer 1 -img\n self.real, params = dot_product_layer ( input = fc2_out_img_dropout,\n neurons = 1,\n activation = 'sigmoid',\n name = 'real')\n # Dot Product Layer 1 -gen\n self.fake, params = dot_product_layer ( input = fc2_out_gen_dropout,\n params = params,\n neurons = 1,\n activation = 'sigmoid',\n name = 'fake')\n\n process_params(params, name = self.name)\n d3_params = params\n self.params = [c1_params, c2_params, d1_params, d2_params, d3_params] \n\n\n with tf.variable_scope (self.name + '_objectives') as scope: \n with tf.variable_scope( self.name + 'discriminator_obj') as scope: \n # discriminator_obj = - 0.5 * tf.reduce_mean(log(self.real)) - \\\n # 0.5 * tf.reduce_mean(log(1-self.fake))\n discriminator_obj = 0.5 * tf.reduce_mean ((self.real-1)**2) + \\\n 0.5 * tf.reduce_mean ((self.fake)**2)\n tf.summary.scalar('discriminator_obj', discriminator_obj)\n tf.add_to_collection( self.name + '_objectives', discriminator_obj ) \n\n with tf.variable_scope (self.name + '_probabilites') as scope: \n tf.summary.scalar('fake_probability', tf.reduce_mean(self.fake))\n tf.summary.scalar('real_probability', tf.reduce_mean(self.real))\n \n self._cook_optimizer( \n lr = DIS_GAN_LR, \n optimizer = DIS_GAN_OPTIMIZER,\n l1_coeff = DIS_GAN_L1_COEFF,\n l2_coeff = DIS_GAN_WEIGHT_DECAY_COEFF)","def _build(self):\n self.autoencoder = autoencoder(\n images = self.images,\n name = 'autoencoder')\n # self.hash = self.autoencoder.hash\n self.z = tf.placeholder(tf.float32, shape = [None, CODEWORD_LENGTH], \n name = 'z-layer') \n with tf.variable_scope('latent_space') as scope:\n for i in range(CODEWORD_LENGTH):\n tf.summary.histogram('z_' + str(i) ,self.z[:,i]) \n tf.summary.histogram('codeword_' + str(i), self.autoencoder.codeword[:,i])\n self.generator = gan_generator( z = self.z,\n input_params = self.autoencoder.params,\n name = 'gan_generator')\n self.discriminator = gan_discriminator ( images = self.images,\n generation = self.generator.generation,\n name = 'gan_discriminator' )\n self.generator.cook(fake = self.discriminator.fake)\n mean_z, var_z = tf.nn.moments(self.z, axes=[0])\n mean_codeword, var_codeword = tf.nn.moments(self.autoencoder.codeword, axes = [0])\n\n with tf.variable_scope ('divergence') as scope:\n tf.summary.scalar( tensor = tf.nn.l2_loss(mean_z-mean_codeword), name = 'mean divergence')\n tf.summary.scalar( tensor = tf.nn.l2_loss(var_z-var_codeword), name = 'variance divergence')\n # divergence = self.hash ","def init():\n ########################\n # OPTIONS\n ########################\n # Debugging tools\n global TIMER # displays time of every major step\n TIMER = True\n global MONITOR # displays monitoring infos\n MONITOR = False\n \n global directories\n directories = {'1Face': 'data/1Face/',\n '2Faces': 'data/2Faces/',\n '3Faces': 'data/3Faces/',\n 'test': 'data/test/'}\n \n # Opt. swicthes\n global maxfinder # to find the max dim. amongst the pictures\n maxfinder = False\n global ML_mode\n ML_mode = {'CNN_Train': False,\n 'CNN_Pred' : True,\n 'Sampler': True}\n \n # Global variables\n global num_pics\n num_pics = {'1Face': 0,\n '2Faces': 0,\n '3Faces': 0}\n global labels\n labels = {'1Face': 0,\n '2Faces': 1,\n '3Faces': 2}\n global num_data\n num_data = 0\n global splitsize # Fraction of data to build the training set\n splitsize = 0.7 \n global maxheight # Resize the pictures to a power of 2 for CNN (2^8 here)\n maxheight = 128\n global maxwidth\n maxwidth = 128\n global TreshEdge # Number of consecutive black pixels to define an edge\n TreshEdge = 2\n global TreshFace # Number of white pixels to define a face (or large edge)\n TreshFace = maxheight/16","def classify_lenet5(batch_size=500, output_size=20):\n\n rng = numpy.random.RandomState(23455)\n\n\n # start-snippet-1\n x = T.matrix('x') # the data is presented as rasterized images\n ######################\n # BUILD ACTUAL MODEL #\n ######################\n print '... building the model'\n\n # Reshape matrix of rasterized images of shape (batch_size, 28 * 28)\n # to a 4D tensor, compatible with our LeNetConvPoolLayer\n # (28, 28) is the size of MNIST images.\n layer0_input = x.reshape((batch_size, 1, 37, 23))\n\n # Construct the first convolutional pooling layer:\n # filtering reduces the image size to (28-5+1 , 28-5+1) = (24, 24)\n # maxpooling reduces this further to (24/2, 24/2) = (12, 12)\n # 4D output tensor is thus of shape (batch_size, nkerns[0], 12, 12)\n layer0 = LeNetConvPoolLayer(\n rng,\n input=layer0_input,\n image_shape=(batch_size, 1, 37, 23),\n filter_shape=(20, 1, 4, 2),\n poolsize=(2, 2),\n )\n\n # layer1 = LeNetConvPoolLayer(\n # rng,\n # input=layer0.output,\n # image_shape=(batch_size, 20, 17, 11),\n # filter_shape=(50, 20, 4, 2),\n # poolsize=(2, 2),\n # )\n #\n # layer4 = LeNetConvPoolLayer(\n # rng,\n # input=layer1.output,\n # image_shape=(batch_size, 50, 7, 5),\n # filter_shape=(100, 50, 4, 2),\n # poolsize=(2, 2),\n # )\n\n layer2_input = layer0.output.flatten(2)\n\n # construct a fully-connected sigmoidal layer\n layer2 = HiddenLayer(\n rng,\n input=layer2_input,\n n_in=3740,\n n_out=output_size,\n activation=T.tanh,\n use_bias=True\n )\n\n # layer5 = HiddenLayer(\n # rng,\n # input=layer2.output,\n # n_in=200,\n # n_out=output_size,\n # activation=T.tanh,\n # use_bias=True\n # )\n\n # classify the values of the fully-connected sigmoidal layer\n layer3 = LogisticRegression(input=layer2.output, n_in=output_size, n_out=2)\n\n model_params = pickle.load(open('../model/cnn_dist_'+str(output_size)+'.pkl'))\n #\n layer0.W = theano.shared(\n value=numpy.array(\n model_params[2].get_value(True),\n dtype=theano.config.floatX\n ),\n name='W',\n borrow=True\n )\n\n layer0.b = theano.shared(\n value=numpy.array(\n model_params[3].get_value(True),\n dtype=theano.config.floatX\n ),\n name='b',\n borrow=True\n )\n\n # layer1.W = theano.shared(\n # value=numpy.array(\n # model_params[-4].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='W',\n # borrow=True\n # )\n #\n # layer1.b = theano.shared(\n # value=numpy.array(\n # model_params[-3].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='b',\n # borrow=True\n # )\n #\n # layer4.W = theano.shared(\n # value=numpy.array(\n # model_params[-6].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='W',\n # borrow=True\n # )\n #\n # layer4.b = theano.shared(\n # value=numpy.array(\n # model_params[-5].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='b',\n # borrow=True\n # )\n\n layer2.W = theano.shared(\n value=numpy.array(\n model_params[0].get_value(True),\n dtype=theano.config.floatX\n ),\n name='W',\n borrow=True\n )\n\n layer2.b = theano.shared(\n value=numpy.array(\n model_params[1].get_value(True),\n dtype=theano.config.floatX\n ),\n name='b',\n borrow=True\n )\n\n # layer5.W = theano.shared(\n # value=numpy.array(\n # model_params[-10].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='W',\n # borrow=True\n # )\n #\n # layer5.b = theano.shared(\n # value=numpy.array(\n # model_params[-9].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='b',\n # borrow=True\n # )\n\n layer3.W = theano.shared(\n value=numpy.array(\n model_params[4].get_value(True),\n dtype=theano.config.floatX\n ),\n name='W',\n borrow=True\n )\n\n layer3.b = theano.shared(\n value=numpy.array(\n model_params[5].get_value(True),\n dtype=theano.config.floatX\n ),\n name='b',\n borrow=True\n )\n\n # params = layer3.params + layer5.params + layer2.params + layer4.params + layer1.params + layer0.params\n\n datasets = load_data(None)\n\n sets = ['train', 'dev', 'test']\n dimension = [20000, 20000, 20000]\n for k in range(3):\n if k == 0:\n classify_set_x, classify_set_y, classify_set_z, classify_set_m, classify_set_c, classify_set_b= datasets[k]\n else:\n classify_set_x, classify_set_y, classify_set_z= datasets[k]\n\n # compute number of minibatches for training, validation and testing\n n_classify_batches = classify_set_x.get_value(borrow=True).shape[0]\n n_classify_batches /= batch_size\n\n # allocate symbolic variables for the data\n index = T.lscalar() # index to a [mini]batch\n classify = theano.function(\n [index],\n layer2.output,\n givens={\n x: classify_set_x[index * batch_size: (index + 1) * batch_size],\n }\n )\n\n r = []\n\n for i in xrange(n_classify_batches):\n m = classify(i)\n r.extend(m)\n r = np.array(r)\n print r.shape\n r = np.append(r, np.reshape(classify_set_y.eval(),(dimension[k], 1)), 1)\n numpy.savetxt('../extractedInformation/cnn_dist_'+str(output_size)+'/'+sets[k]+'.csv', r, delimiter=\",\")","def build_model():\n mdl = Sequential()\n\n # normalization\n mdl.add(Lambda(lambda x: x/128. - 1, input_shape=IMAGE_SHAPE, name=\"input\"))\n\n # trim image\n mdl.add(Lambda(lambda x: x[:, 10:-10, :, :]))\n\n # convolutions\n mdl.add(Convolution2D(24, 5, 5, subsample=(2, 2), border_mode='same',))\n mdl.add(MaxPooling2D(pool_size=(2, 2)))\n mdl.add((Dropout(0.5)))\n mdl.add(Activation('relu'))\n\n mdl.add(Convolution2D(36, 5, 5, subsample=(2, 2), border_mode='same',))\n mdl.add(MaxPooling2D(pool_size=(2, 2)))\n mdl.add((Dropout(0.5)))\n mdl.add(Activation('relu'))\n\n mdl.add(Convolution2D(48, 5, 5, subsample=(2, 2), border_mode='same',))\n mdl.add(MaxPooling2D(pool_size=(2, 2)))\n mdl.add((Dropout(0.5)))\n mdl.add(Activation('relu'))\n\n mdl.add(Convolution2D(64, 3, 3, subsample=(1, 1), border_mode='same',))\n mdl.add((Dropout(0.5)))\n mdl.add(Activation('relu'))\n\n mdl.add(Convolution2D(64, 3, 3, subsample=(1, 1), border_mode='same',))\n mdl.add((Dropout(0.5)))\n mdl.add(Activation('relu'))\n\n mdl.add(Flatten())\n\n mdl.add(Dense(128, activation='relu'))\n mdl.add(Dense(64, activation='relu'))\n mdl.add(Dense(1, name=\"output\"))\n\n mdl.summary()\n\n return mdl","def prep_input(im, acc=4):\n mask = cs.cartesian_mask(im.shape, acc, sample_n=8)\n im_und, k_und = cs.undersample(im, mask, centred=False, norm='ortho')\n im_gnd_l = to_lasagne_format(im)\n im_und_l = to_lasagne_format(im_und)\n k_und_l = to_lasagne_format(k_und)\n mask_l = to_lasagne_format(mask, mask=True)\n\n return im_und_l, k_und_l, mask_l, im_gnd_l","def image_inference(self, model_name: str, input_data):\n exec_net, image_input, image_info_input, (n, c, h, w), postprocessor = self.model_loading.load_model(model_name)\n cap, visualizer, tracker, presenter = self.image_visualizer.visualizer(input_data,model_name)\n\n while cap.isOpened():\n ret, frame = cap.read()\n if not ret:\n break\n # Resize the image to keep the same aspect ratio and to fit it to a window of a target size.\n scale_x = scale_y = min(h / frame.shape[0], w / frame.shape[1])\n input_image = cv2.resize(frame, None, fx=scale_x, fy=scale_y)\n\n input_image_size = input_image.shape[:2]\n input_image = np.pad(input_image, ((0, h - input_image_size[0]),\n (0, w - input_image_size[1]),\n (0, 0)),\n mode='constant', constant_values=0)\n # Change data layout from HWC to CHW.\n input_image = input_image.transpose((2, 0, 1))\n input_image = input_image.reshape((n, c, h, w)).astype(np.float32)\n input_image_info = np.asarray([[input_image_size[0], input_image_size[1], 1]], dtype=np.float32)\n # Run the net.\n feed_dict = {image_input: input_image}\n if image_info_input:\n feed_dict[image_info_input] = input_image_info\n outputs = exec_net.infer(feed_dict)\n # Parse detection results of the current request\n scores, classes, boxes, masks = postprocessor(\n outputs, scale_x, scale_y, *frame.shape[:2], h, w, 0.5)\n os.remove(input_data.filename)\n class_labels = self.fetch_labels.get_labels(model_name)\n\n t = 0\n for key2 in [class_labels[i] for i in classes]:\n x1 = str(boxes[t][0])\n y1 = str(boxes[t][1])\n x2 = str(boxes[t][2])\n y2 = str(boxes[t][3])\n\n if key2 in self.prediction.keys():\n value_init = self.prediction.get(key2)\n self.prediction[key2] = x1, y1, x2, y2\n value = value_init, self.prediction.get(key2)\n self.prediction[key2] = value\n\n else:\n self.prediction[key2] = x1, y1, x2, y2\n\n t = t + 1\n\n with open('./final_json.json', 'w') as file:\n json.dump(self.prediction, file)\n\n with open('./final_json.json','r') as file:\n json_object = json.load(file)\n\n return json_object\n cv2.destroyAllWindows()\n cap.release()"],"string":"[\n \"def inference(self, image_rgb):\\n s = image_rgb.get_shape().as_list()\\n with tf.name_scope('image-preprocessing'):\\n MEAN = [103.939, 116.779, 123.68]\\n assert s[1:] == [227, 227, 3]\\n red, green, blue = tf.split(image_rgb, 3, 3)\\n bgr = tf.concat([\\n blue - MEAN[0],\\n green - MEAN[1],\\n red - MEAN[2],\\n ], 3)\\n\\n # 1st Layer: Conv (w ReLu) -> Pool -> Lrn\\n conv1 = conv(bgr, 11, 11, 96, 4, 4, padding='VALID', name='conv1')\\n pool1 = max_pool(conv1, 3, 3, 2, 2, padding='VALID', name='pool1')\\n norm1 = lrn(pool1, 2, 2e-05, 0.75, name='norm1')\\n\\n # 2nd Layer: Conv (w ReLu) -> Pool -> Lrn\\n conv2 = conv(norm1, 5, 5, 256, 1, 1, name='conv2', groups=2)\\n pool2 = max_pool(conv2, 3, 3, 2, 2, padding='VALID', name='pool2')\\n norm2 = lrn(pool2, 2, 2e-05, 0.75, name='norm2')\\n\\n # 3rd Layer: Conv (w ReLu)\\n conv3 = conv(norm2, 3, 3, 384, 1, 1, name='conv3')\\n\\n # 4th Layer: Conv (w ReLu)\\n conv4 = conv(conv3, 3, 3, 384, 1, 1, name='conv4', groups=2)\\n\\n # 5th Layer: Conv (w ReLu) -> Pool\\n conv5 = conv(conv4, 3, 3, 256, 1, 1, name='conv5', groups=2)\\n pool5 = max_pool(conv5, 3, 3, 2, 2, padding='VALID', name='pool5')\\n\\n # 6th Layer: Flatten -> FC (w ReLu) -> Dropout\\n flattened = tf.reshape(pool5, [-1, 6*6*256])\\n fc6 = fc(flattened, 6*6*256, 4096, name='fc6')\\n dropout6 = dropout(fc6, self.KEEP_PROB)\\n\\n # 7th Layer: FC (w ReLu) -> Dropout\\n fc7 = fc(dropout6, 4096, 4096, name='fc7')\\n dropout7 = dropout(fc7, self.KEEP_PROB)\\n\\n # 8th Layer: FC and return unscaled activations (for tf.nn.softmax_cross_entropy_with_logits)\\n score_imagenet_classes = fc(dropout7, 4096, 1000, relu=False, name='fc8')\\n\\n # New score layer for the new task (network is shared up to this point)\\n score_retrained = fc(dropout7, 4096, self.NUM_CLASSES, relu=False, name='fc8_new')\\n\\n return score_imagenet_classes, score_retrained\",\n \"def _get_data(self, image_name, one_hot=True, preproc_type=-1):\\n preproc_type = self.config['preprocessing']['type'] \\\\\\n if preproc_type is -1 else preproc_type\\n\\n filetype = {'rgb': 'png', 'depth': 'png', 'labels': 'npy'}\\n rgb_filename, depth_filename, groundtruth_filename = (\\n path.join(self.base_path, '{}/Stereo_Right/Omni_{}/{}.{}'\\n .format(pref, self.config['direction'],\\n image_name, filetype[modality]))\\n for pref, modality in zip(['RGB', 'Depth', 'GT/LABELS_NPY'],\\n ['rgb', 'depth', 'labels']))\\n\\n blob = {}\\n blob['rgb'] = cv2.imread(rgb_filename)\\n blob['depth'] = cv2.imread(depth_filename, cv2.IMREAD_ANYDEPTH)\\n blob['labels'] = np.load(groundtruth_filename)\\n\\n if preproc_type == 'online':\\n scale = self.config['preprocessing'].get('scale')\\n crop = self.config['preprocessing'].get('crop')\\n hflip = self.config['preprocessing'].get('hflip')\\n vflip = self.config['preprocessing'].get('vflip')\\n gamma = self.config['preprocessing'].get('gamma')\\n\\n if scale and crop:\\n h, w, _ = blob['rgb'].shape\\n min_scale = crop / float(min(h, w))\\n k = random.uniform(max(min_scale, scale[0]), scale[1])\\n blob['rgb'] = cv2.resize(blob['rgb'], None, fx=k, fy=k)\\n blob['depth'] = cv2.resize(blob['depth'], None, fx=k, fy=k,\\n interpolation=cv2.INTER_NEAREST)\\n blob['labels'] = cv2.resize(blob['labels'], None, fx=k, fy=k,\\n interpolation=cv2.INTER_NEAREST)\\n\\n if crop:\\n h, w, _ = blob['rgb'].shape\\n h_c = random.randint(0, h - crop)\\n w_c = random.randint(0, w - crop)\\n for m in ['rgb', 'depth', 'labels']:\\n blob[m] = blob[m][h_c:h_c+crop, w_c:w_c+crop, ...]\\n\\n if hflip and np.random.choice([0, 1]):\\n for m in ['rgb', 'depth', 'labels']:\\n blob[m] = np.flip(blob[m], axis=0)\\n\\n if vflip and np.random.choice([0, 1]):\\n for m in ['rgb', 'depth', 'labels']:\\n blob[m] = np.flip(blob[m], axis=1)\\n\\n if gamma:\\n k = random.uniform(gamma[0], gamma[1])\\n lut = np.array([((i / 255.0) ** (1/k)) * 255\\n for i in np.arange(0, 256)]).astype(\\\"uint8\\\")\\n blob['rgb'] = lut[blob['rgb']]\\n\\n force_multiple = self.config['preprocessing'].get('force_multiple')\\n if force_multiple:\\n h, w, _ = blob['rgb'].shape\\n h_c, w_c = [d - (d % force_multiple) for d in [h, w]]\\n if h_c != h or w_c != w:\\n for m in ['rgb', 'depth', 'labels']:\\n blob[m] = blob[m][:h_c, :w_c, ...]\\n\\n blob['depth'] = np.expand_dims(blob['depth'], 3)\\n blob['labels'] = np.asarray(self.label_lookup)[blob['labels']]\\n\\n if one_hot:\\n blob['labels'] = np.array(self.one_hot_lookup ==\\n blob['labels'][:, :, None]).astype(int)\\n return blob\",\n \"def get_all_layers(self, img): # noqa\\n s1_out, c1_out, s2_out, c2_out = self.run_all_layers(img)\\n return (\\n [s1.cpu().detach().numpy() for s1 in s1_out],\\n [c1.cpu().detach().numpy() for c1 in c1_out],\\n [[s2_.cpu().detach().numpy() for s2_ in s2] for s2 in s2_out],\\n [c2.cpu().detach().numpy() for c2 in c2_out],\\n )\",\n \"def run(input_path, output_path):\\n\\n if not os.path.isdir(output_path):\\n os.makedirs(output_path)\\n\\n path = glob(os.path.join(input_path, '*.*'))\\n\\n model = load_model('model/AgLLNet.h5')\\n\\n for i in tqdm(range(len(path))):\\n\\n # data load\\n img_A_path = path[i]\\n img_A = imageio.imread(img_A_path) / 255.\\n\\n if len(img_A.shape) < 3:\\n img_A = img_A[:, :, np.newaxis]\\n img_A = np.concatenate((img_A, img_A, img_A), axis=2)\\n\\n img_A = img_A[:, :, :3]\\n W = img_A.shape[0]\\n H = img_A.shape[1]\\n w = math.ceil(W / (2**7)) * 2**7\\n h = math.ceil(H / (2**7)) * 2**7\\n img_A = cv2.resize(img_A, (h, w), interpolation=cv2.INTER_LANCZOS4)\\n img_A = img_A[np.newaxis, :]\\n\\n # forward pass\\n out_pred = model.predict(img_A)\\n\\n enhance_B = out_pred[0, :, :, 4:7]\\n enhance_B = cv2.resize(enhance_B, (H, W), interpolation=cv2.INTER_LANCZOS4)\\n enhance_B = np.clip(enhance_B, 0.0, 1.0)\\n\\n # output\\n filename = os.path.join(\\n output_path,\\n os.path.splitext(os.path.basename(img_A_path))[0])\\n\\n imageio.imwrite(filename + '.png', (enhance_B * 255.).astype(np.uint8))\",\n \"def define(self, optimizer = Adam(lr=1e-5)): \\n \\n self.optimizer = optimizer\\n\\n model = Sequential()\\n\\n #Layer 1\\n model.add(Conv2D( filters = 96, \\n kernel_size = (11,11), \\n strides = 4, \\n padding = 'same', \\n activation = 'relu', \\n input_shape = (224, 224, 3), \\n kernel_initializer = 'he_normal'))\\n model.add(MaxPooling2D( pool_size = (3,3), \\n strides = (2,2), \\n padding= 'same', \\n data_format = None)) # overlapping pooling\\n #Layer 2\\n model.add(Conv2D( filters = 256, \\n kernel_size = (5,5), \\n strides = 1, \\n padding = 'same', \\n activation = 'relu', \\n kernel_initializer = 'he_normal'))\\n model.add(MaxPooling2D( pool_size = (3,3), \\n strides = (2,2), \\n padding= 'same', \\n data_format = None)) \\n #Layer 3\\n model.add(Conv2D( filters = 384, \\n kernel_size = (3,3), \\n strides = 1, padding = 'same', \\n activation = 'relu', kernel_initializer = 'he_normal'))\\n #Layer 4\\n model.add(Conv2D( filters = 384, \\n kernel_size = (3,3), \\n strides = 1, padding = 'same', \\n activation = 'relu', \\n kernel_initializer = 'he_normal'))\\n #Layer 5\\n model.add(Conv2D( filters = 256, \\n kernel_size = (3,3), \\n strides = 1, padding = 'same', \\n activation = 'relu', \\n kernel_initializer = 'he_normal'))\\n #Layer 6\\n model.add(MaxPooling2D( pool_size = (3,3), \\n strides = (2,2), \\n padding= 'same', \\n data_format = None))\\n \\n #Layer 7\\n model.add(Flatten())\\n \\n #Layer 8\\n model.add(Dense( units = 4096, activation = 'relu'))\\n model.add(Dense( units = 1024, activation = 'relu'))\\n model.add(Dense( units = 512, activation = 'relu'))\\n model.add(Dense( units = 256, activation = 'relu'))\\n model.add(Dense( units = 128, activation = 'relu'))\\n \\n #Layer end\\n model.add(Dense( units = 3, activation = 'softmax'))\\n model.summary()\\n \\n self.model = model\",\n \"def load_images(self, target = \\\"standard\\\", path=OMNIGLOT_DATAPATH):\\n X = []\\n Y = []\\n folderName = {}\\n if target == \\\"standard\\\":\\n trainFolders = [\\\"images_background\\\"]\\n testFolders = [\\\"images_evaluation\\\"]\\n elif target == \\\"minimal\\\":\\n trainFolders = [\\\"images_background_small1\\\", \\\"images_background_small2\\\"]\\n testFolders = [\\\"images_evaluation\\\"]\\n \\n if self.train:\\n for trainFolder in trainFolders:\\n folderPath = os.path.join(path, trainFolder)\\n imgAllCount = 0 # this is counted for the whole images in all alphabet\\n chaAllCount = 0 # this is counted for the whole characters in all alphabet\\n\\n for alphabet in sorted(os.listdir(folderPath)):\\n alphabetPath = os.path.join(folderPath, alphabet)\\n folderName[alphabet] = {'totalChar': 0, 'charIndex': [], 'totalImg': 0, 'imgIndex': []}\\n \\n imgAlphabetCount = 0 # this is counted for the number of images in this alphabet\\n chaAlphabetCount = 0 # this is counted for the number of character in this alphabet\\n\\n folderName[alphabet]['charIndex'].append(chaAllCount)\\n folderName[alphabet]['imgIndex'].append(imgAllCount)\\n \\n for letter in sorted(os.listdir(alphabetPath)):\\n letterPath = os.path.join(alphabetPath, letter)\\n \\n for letterImage in os.listdir(letterPath):\\n imagePath = os.path.join(letterPath, letterImage)\\n image = mpimg.imread(imagePath)\\n X.append(image)\\n Y.append(chaAllCount)\\n \\n imgAlphabetCount += 1\\n imgAllCount += 1\\n\\n chaAlphabetCount += 1\\n chaAllCount += 1\\n \\n folderName[alphabet]['totalChar'] = chaAlphabetCount\\n folderName[alphabet]['totalImg'] = imgAlphabetCount\\n folderName[alphabet]['charIndex'].append(chaAllCount-1)\\n folderName[alphabet]['imgIndex'].append(imgAllCount-1)\\n \\n X = np.stack(X) \\n X = X.reshape(-1, IMAGES_PER_CHARACTER, X.shape[1], X.shape[2])\\n return X, np.stack(Y), folderName\",\n \"def get_augmentation_sequence():\\n # Macro to apply something with 50% chance\\n sometimes = lambda aug: iaa.Sometimes(0.5, aug) # 50%\\n rarely = lambda aug: iaa.Sometimes(0.1, aug) # 10%\\n\\n # Augmentation applied to every image\\n # Augmentors sampled one value per channel\\n aug_sequence = iaa.Sequential(\\n [\\n # apply the following augmenters to most images\\n iaa.Fliplr(0.5), # horizontally flip 50% of all images\\n iaa.Flipud(0.5), # vertically flip 50% of all images\\n\\n # crop images by -0.25% to 0.25% of their height/width\\n # positive values crop the image, negative pad\\n sometimes(iaa.CropAndPad(\\n percent=(-0.25, 0.25),\\n pad_mode=['constant', 'edge'], # pad with constant value of the edge value\\n pad_cval=(0, 0) # if mode is constant, use a cval between 0 and 0 to ensure mask background is preserved\\n )),\\n sometimes(iaa.Affine(\\n scale={\\\"x\\\": (0.8, 1.2), \\\"y\\\": (0.8, 1.2)}, # scale images to 80-120% of their size, individually per axis\\n translate_percent={\\\"x\\\": (-0.2, 0.2), \\\"y\\\": (-0.2, 0.2)}, # translate by -20 to +20 percent (per axis)\\n rotate=(-45, 45), # rotate by -45 to +45 degrees\\n shear=(-16, 16), # shear by -16 to +16 degrees\\n order=[0, 1], # use nearest neighbour or bilinear interpolation (fast)\\n cval=(0, 0), # if mode is constant, use a cval between 0 and 0 to ensure mask background is preserved\\n mode='constant' # ia.ALL # use any of scikit-image's warping modes (see 2nd image from the top for examples)\\n )),\\n # rarely(iaa.Superpixels(p_replace=(0, 1.0), n_segments=(20, 200))),\\n iaa.GaussianBlur((0, 3.0)),\\n iaa.Add((-10, 10), per_channel=0.7), # change brightness of images (by -10 to 10 of original value)\\n iaa.AddToHueAndSaturation((-20, 20)),\\n # sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.1)))\\n ],\\n random_order=True\\n )\\n\\n return aug_sequence\",\n \"def _build(self):\\n with tf.variable_scope (self.name + '_architecutre') as scope:\\n images_square = unflatten_layer ( self.images )\\n visualize_images(images_square)\\n\\n # Conv Layer 1\\n conv1_out, params = conv_2d_layer ( input = images_square,\\n neurons = CONV_1_N,\\n filter_size = CONV_1_FILT,\\n name = 'enc_conv_1',\\n visualize = True )\\n process_params(params, name = self.name)\\n e1_params = params\\n pool1_out = max_pool_2d_layer ( input = conv1_out, name = 'enc_pool_1')\\n # lrn1_out = local_response_normalization_layer (pool1_out, name = 'lrn_1' )\\n\\n # Conv Layer 2\\n conv2_out, params = conv_2d_layer ( input = pool1_out,\\n neurons = CONV_2_N,\\n filter_size = CONV_2_FILT,\\n name = 'enc_conv_2' )\\n process_params(params, name = self.name)\\n e2_params = params\\n pool2_out = max_pool_2d_layer ( input = conv2_out, name = 'enc_pool_2')\\n # lrn2_out = local_response_normalization_layer (pool2_out, name = 'lrn_2' )\\n\\n flattened = flatten_layer(pool2_out)\\n\\n # Dropout Layer 1 \\n flattened_dropout = dropout_layer ( input = flattened,\\n prob = self.dropout_prob,\\n name = 'enc_dropout_1') \\n\\n # Dot Product Layer 1\\n fc1_out, params = dot_product_layer ( input = flattened_dropout,\\n neurons = HIDDEN_1,\\n name = 'enc_dot_1')\\n process_params(params, name = self.name)\\n e3_params = params \\n\\n # Dropout Layer 2 \\n fc1_out_dropout = dropout_layer ( input = fc1_out,\\n prob = self.dropout_prob,\\n name = 'enc_dropout_2')\\n # Dot Product Layer 2\\n fc2_out, params = dot_product_layer ( input = fc1_out_dropout, \\n neurons = HIDDEN_2,\\n name = 'enc_dot_2')\\n process_params(params, name = self.name)\\n e4_params = params \\n\\n # Dropout Layer 3 \\n fc2_out_dropout = dropout_layer ( input = fc2_out,\\n prob = self.dropout_prob,\\n name = 'enc_dropout_3')\\n \\n # Dot Product Layer 2\\n self.codeword, params = dot_product_layer ( input = fc2_out_dropout, \\n neurons = CODEWORD_LENGTH,\\n activation = CODE_ACTIVATION,\\n name = 'enc_dot_2')\\n process_params(params, name = self.name)\\n process_codeword_normalization_regularizer(self.codeword, \\n coeff = AUTOENCODER_CODEWORD_COEFF,\\n name = self.name)\\n e5_params = params \\n # tf.summary.histogram('codewords', self.codeword)\\n # self.hash = threshold_layer ( input = self.codeword,\\n # name = 'hash')\\n # process_hash_regularizer(self.codeword, coeff = AUTOENCODER_HASH_COEFF,\\n # name = self.name)\\n\\n # Decoder ... \\n decoder_1_out, params = dot_product_layer ( input = self.codeword, \\n neurons = HIDDEN_2,\\n params = [tf.transpose(e5_params[0]), None],\\n name = 'decoder_dot_1')\\n d1_params = params\\n process_params([params[1]], name = self.name)\\n \\n dec_1_out_dropout = dropout_layer ( input = decoder_1_out,\\n prob = self.dropout_prob,\\n name = 'dec_dropout_1')\\n\\n decoder_2_out, params = dot_product_layer ( input = dec_1_out_dropout, \\n neurons = HIDDEN_1,\\n params = [tf.transpose(e4_params[0]), None],\\n name = 'decoder_dot_2')\\n d2_params = params\\n process_params([params[1]], name = self.name)\\n \\n # dropout 2\\n dec_2_out_dropout = dropout_layer ( input = decoder_2_out,\\n prob = self.dropout_prob,\\n name = 'dec_dropout_2')\\n\\n decoder_3_out, params = dot_product_layer ( input = dec_2_out_dropout, \\n neurons = 1250,\\n params = [tf.transpose(e3_params[0]), None],\\n name = 'decoder_dot_3')\\n d3_params = params\\n process_params([params[1]], name = self.name)\\n\\n # DeConv Layer 1\\n # The output shapes need to be changed according to architecture.\\n\\n dec_3_square = unflatten_layer ( decoder_3_out, channels = CONV_2_N )\\n upsample_1 = upsampling_layer (dec_3_square, size = (10,10), name = 'dec_upsampling_1')\\n\\n deconv1_out, params = deconv_2d_layer ( input = upsample_1,\\n neurons = CONV_1_N,\\n filter_size = CONV_2_FILT,\\n output_shape = (12,12),\\n # n_outs = MINI_BATCH_SIZE,\\n stride = (1,1,1,1), \\n params = [e2_params[0], None], \\n name = 'dec_deconv_1' )\\n\\n process_params([params[1]], name = self.name)\\n d4_params = params\\n\\n # DeConv Layer 2\\n upsample_2 = upsampling_layer (deconv1_out, size = (24,24), name = 'dec_upsampling_2')\\n decoded_images_square, params = deconv_2d_layer ( input = upsample_2,\\n neurons = 1,\\n filter_size = CONV_1_FILT,\\n stride = (1,1,1,1),\\n output_shape = (28,28),\\n # n_outs = MINI_BATCH_SIZE, \\n params = [e1_params[0], None], \\n activation = 'tanh', \\n name = 'dec_deconv_2' )\\n \\n process_params([params[1]], name = self.name)\\n d5_params = params \\n \\n self.decoded = flatten_layer (decoded_images_square, in_shp = [-1, 28, 28, 1])\\n visualize_images(decoded_images_square, name = 'decoded')\\n # This is because transpose don't initialize.\\n self.params = [ [e5_params[0], d1_params[1] ],\\n [e4_params[0], d2_params[1] ],\\n [e3_params[0], d3_params[1] ],\\n [e2_params[0], d4_params[1] ],\\n [e1_params[0], d5_params[1] ] ]\\n\\n with tf.variable_scope (self.name + '_objectives') as scope: \\n with tf.variable_scope( self.name + '_decoder_error') as scope:\\n reconstruction_error = rmse(self.images, self.decoded) \\n tf.add_to_collection( self.name + '_objectives', reconstruction_error ) \\n tf.summary.scalar('reconstruction_error', reconstruction_error)\\n\\n self._cook_optimizer( \\n lr = AUTOENCODER_LR, \\n optimizer = AUTOENCODER_OPTIMIZER,\\n l1_coeff = AUTOENCODER_L1_COEFF,\\n l2_coeff = AUTOENCODER_WEIGHT_DECAY_COEFF)\",\n \"def build_full_conv_autoencoder():\\n input_img = Input(shape=(84, 84, 3))\\n\\n x = Convolution2D(48, 8, 8, activation='relu', border_mode='same', name='c1')(input_img)\\n x = MaxPooling2D((2, 2), border_mode='same')(x)\\n x = Convolution2D(32, 4, 4, activation='relu', border_mode='same', name='c2')(x)\\n x = MaxPooling2D((2, 2), border_mode='same')(x)\\n x = Convolution2D(32, 3, 3, activation='relu', border_mode='same', name='c3')(x)\\n encoded = MaxPooling2D((3, 3), border_mode='same')(x)\\n\\n x = Convolution2D(32, 3, 3, activation='relu', border_mode='same', name='c4')(encoded)\\n x = UpSampling2D((3, 3))(x)\\n x = Convolution2D(32, 4, 4, activation='relu', border_mode='same', name='c5')(x)\\n x = UpSampling2D((2, 2))(x)\\n x = Convolution2D(48, 8, 8, activation='relu', border_mode='same', name='c6')(x)\\n x = UpSampling2D((2, 2))(x)\\n decoded = Convolution2D(3, 4, 4, activation='sigmoid', border_mode='same', name='c7')(x)\\n\\n autoencoder = Model(input_img, decoded)\\n autoencoder.compile(optimizer='adam', metrics=['mse'], loss='mse')\\n autoencoder.summary()\\n return autoencoder\",\n \"def get_augmenter():\\n\\n augmenter = iaa.Sequential([\\n iaa.Fliplr(0.5), # horizontal flips\\n iaa.Crop(percent=(0, 0.1)), # random crops\\n # Small gaussian blur with random sigma between 0 and 0.5.\\n # But we only blur about 50% of all images.\\n iaa.Sometimes(\\n 0.5,\\n iaa.GaussianBlur(sigma=(0, 0.5))\\n ),\\n # Strengthen or weaken the contrast in each image.\\n iaa.LinearContrast((0.75, 1.5)),\\n # Add gaussian noise.\\n # For 50% of all images, we sample the noise once per pixel.\\n # For the other 50% of all images, we sample the noise per pixel AND\\n # channel. This can change the color (not only brightness) of the\\n # pixels.\\n iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05*255), per_channel=0.5),\\n # Make some images brighter and some darker.\\n # In 20% of all cases, we sample the multiplier once per channel,\\n # which can end up changing the color of the images.\\n iaa.Multiply((0.8, 1.2), per_channel=0.2),\\n # Apply affine transformations to each image.\\n # Scale/zoom them, translate/move them, rotate them and shear them.\\n iaa.Affine(\\n scale={\\\"x\\\": (0.80, 1.2), \\\"y\\\": (0.80, 1.2)},\\n translate_percent={\\\"x\\\": (-0.2, 0.2), \\\"y\\\": (-0.2, 0.2)},\\n rotate=(-25, 25),\\n shear=(-6, 6)\\n )\\n], random_order=True) # apply augmenters in random order\\n\\n return augmenter\",\n \"def forward(self, img):\\n c2_outputs = self.run_all_layers(img)[-1]\\n c2_outputs = torch.cat(\\n [c2_out[:, None, :] for c2_out in c2_outputs], 1)\\n return c2_outputs\",\n \"def forward(self, img):\\n device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\\n H, W = img.size()[2], img.size()[3]\\n #print('x',x)\\n #print('x.shape',x.shape) ## 32 x 3 x 96 x 128\\n z32 = self.start(img)\\n z64 = self.layer1(z32) + self.layer1_ds(z32)\\n #print('z1',z64.shape)\\n z128 = self.layer2(z64) + self.layer2_ds(z64)\\n #print('z2',z128.shape)\\n z256 = self.layer3(z128) + self.layer3_ds(z128)\\n #print('z3',z256.shape)\\n z256d = self.drop_out_layer(z256)\\n #print('z_drop',z256d.shape)\\n z256u = self.layer4(z256d)\\n #print('z4',z256u.shape)\\n z128u = self.layer5(torch.cat((z256u, F.interpolate(z256d,size=z256u.size()[2:] )), 1))\\n #print('z5',z128u.shape)\\n z64u = self.layer6(torch.cat((z128u, F.interpolate(z128,size=z128u.size()[2:] )), 1))\\n #print('z6',z64u.shape)\\n\\n z32u = self.final(torch.cat((z64u, F.interpolate(z64,size=z64u.size()[2:] )), 1))\\n #print('z6_plus',z32u.shape)\\n\\n #print('z7_result',self.classifer(z32u)[:, :, :H, :W].shape)\\n result_class = self.classifer(z32u)[:, :, :H, :W]\\n\\n #print('model result shape',result_class.shape)\\n ## 16 x 1 x 300 x 400\\n\\n # using soft argmax\\n spa_argmax = spatial_argmax(torch.squeeze(result_class,1))\\n\\n #one hot with spatial argmax\\n #xy_val = torch.zeros(spa_argmax.shape).float()\\n #for idx, pt in enumerate(spa_argmax):\\n # x_val = (pt[0]+1.0)*63.5\\n # y_val = (pt[1]+1.0)*47.5\\n # # for each batch. [0...127][0...95]\\n # xy_val[idx][0] = x_val\\n # xy_val[idx][1] = y_val\\n\\n xy_val = (spa_argmax+1.0).to(device)\\n #print('spa_argmax',spa_argmax)\\n scaling_factor = torch.FloatTensor([[(W-1)/2,0.],[0.,(H-1)/2]]).to(device)\\n #scaling_factor = torch.FloatTensor([[63.5,0.],[0.,44.5]]).to(device)\\n xy_val = xy_val.mm(scaling_factor)\\n\\n return xy_val\",\n \"def main():\\n args = get_arguments()\\n \\n # Create queue coordinator.\\n coord = tf.train.Coordinator()\\n \\n # Load reader.\\n with tf.name_scope(\\\"create_inputs\\\"):\\n reader = ImageReader_MultiClass_Loss(\\n args.data_dir,\\n args.data_list,\\n None, # No defined input size.\\n RANDOM_SEED,\\n False, # No random scale.\\n False, # No random mirror.\\n coord)\\n image, l2_catg, binary_catg, hinge_catg = reader.image, reader.l2_catg, reader.binary_catg, reader.hinge_catg\\n image_batch = tf.expand_dims(image, dim=0)\\n binary_catg_batch = tf.expand_dims(binary_catg, dim=0)\\n\\n # Create network.\\n net = DeepLabResNetModel({'data': image_batch}, is_training=False)\\n\\n # Which variables to load.\\n restore_var = tf.global_variables()\\n \\n # Predictions.\\n raw_output = net.layers['fc1_voc12']\\n\\n # Do the global average pooling\\n raw_output_bcgd_rmvd = raw_output[:,:,:,1:]\\n g_avg_pool = tf.reduce_mean(tf.reduce_mean(raw_output_bcgd_rmvd, axis=1, keep_dims=True),\\\\\\n axis=2, keep_dims=True) # Avg across the width and height dimension -> [Bx21]\\n g_avg_pool_sqzd = tf.squeeze(g_avg_pool, axis=[1, 2])\\n pred = tf.nn.softmax(g_avg_pool_sqzd)\\n\\n # Get the class activation map\\n raw_output_up = tf.image.resize_bilinear(raw_output_bcgd_rmvd, tf.shape(image_batch)[1:3,])\\n raw_output_up = raw_output_up - tf.reduce_min(tf.reduce_min(raw_output_up, axis=1, keep_dims=True), axis=2, keep_dims=True) + EPSILON\\n raw_output_up = raw_output_up / tf.reduce_max(tf.reduce_max(raw_output_up, axis=1, keep_dims=True), axis=2, keep_dims=True)\\n cam_m_1 = tf.argmax(raw_output_up, dimension=3) + 1\\n raw_output_catgs_rmvd = raw_output_up * tf.expand_dims(tf.expand_dims(binary_catg_batch, 1), 2)\\n cam_m_2 = tf.argmax(raw_output_catgs_rmvd, dimension=3) + 1\\n cam = tf.cast(tf.equal(cam_m_1, cam_m_2), tf.int64) * cam_m_1\\n\\n cam_batch = tf.expand_dims(cam, dim=3)\\n\\n # Set up tf session and initialize variables. \\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n sess = tf.Session(config=config)\\n init = tf.global_variables_initializer()\\n \\n sess.run(init)\\n sess.run(tf.local_variables_initializer())\\n \\n # Load weights.\\n loader = tf.train.Saver(var_list=restore_var)\\n if args.restore_from is not None:\\n load(loader, sess, args.restore_from)\\n \\n # Start queue threads.\\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\\n \\n # Iterate over training steps.\\n for step in range(args.num_steps):\\n preds, images, cams, bin_catg = sess.run([pred, image_batch, cam_batch, binary_catg])\\n \\\"\\\"\\\"\\n print(bin_catg)\\n print(np.unique(np.unique(cams)))\\n \\\"\\\"\\\"\\n img = inv_preprocess(images)\\n attMap = decode_labels(cams)\\n output_dir = './output_maps_binary_without_norm/'\\n img_name = output_dir + str(step) + '.jpg'\\n map_name = output_dir + str(step) + '.png'\\n misc.imsave(img_name, img[0,:,:,:])\\n misc.imsave(map_name, attMap[0,:,:,:])\\n coord.request_stop()\\n coord.join(threads)\",\n \"def model(inputs, target_images, is_training):\\n # if isinstance(inputs, tuple):\\n assert mask_augs >= 0. and mask_augs <= 1., \\\"mask_augs must be in [0, 1]\\\"\\n if FLAGS.use_td_loss and isinstance(inputs, tuple):\\n # print('#'*80)\\n # print(inputs)\\n assert metric is not None, \\\"Metric function is None\\\"\\n inputs, augs = inputs\\n B = inputs.get_shape().as_list()[0]\\n A = augs.get_shape().as_list()[1]\\n if mask_augs > 0:\\n mask = tf.cast(tf.greater(tf.random.uniform(shape=[B, A], minval=0., maxval=1.), 0.5), augs.dtype) # noqa\\n bias = mask * -1\\n augs = (augs * mask) + bias # Randomly mask out augs for difficulty and code those dims as -1\\n with tf.variable_scope('encoder'): # variable_scope name_scope\\n features, block_activities = encoder(inputs, is_training=is_training)\\n print(\\\"Features: \\\")\\n print(features)\\n print(\\\"---\\\")\\n # Global average pool of B 7 7 2048 -> B 2048\\n if data_format == 'channels_last':\\n outputs = tf.reduce_mean(features, [1, 2])\\n else:\\n outputs = tf.reduce_mean(features, [2, 3])\\n outputs = tf.identity(outputs, 'final_avg_pool')\\n print(\\\"Outputs: \\\")\\n print(outputs)\\n print(\\\"---\\\")\\n # B 2048\\n\\n h_w = features.get_shape().as_list()[1]\\n # print(h_w)\\n\\n augs = tf.tile(augs[:,None,None,:], tf.constant([1,h_w,h_w,1]))\\n print(\\\"Augs: \\\")\\n print(augs)\\n print(\\\"---\\\")\\n features = tf.concat([features, augs], axis=-1)\\n \\n with tf.variable_scope('decoder'):\\n recon_images = decoder(\\n features,\\n block_activities,\\n is_training=is_training,\\n skip=skip)\\n print(\\\"Reconstructed images and target images: \\\")\\n print(recon_images)\\n print(target_images)\\n print(\\\"---\\\")\\n with tf.variable_scope('metric'):\\n # Squash both recon and target images\\n recon_images_squash = tf.tanh(recon_images)\\n target_images = (target_images * 2) - 1\\n Bt = target_images.get_shape().as_list()[0]\\n Br = recon_images_squash.get_shape().as_list()[0]\\n if Bt == Br:\\n # Attractive + repulsive loss\\n pass\\n elif Bt * 2 == Br:\\n # Attractive-only loss\\n target_images = tf.concat([target_images, target_images], 0)\\n\\n # Differentiable perceptual metric. First reconstruction.\\n # both_images = tf.concat([recon_images, target_images], -1) # B H W 6\\n all_images = tf.concat([recon_images_squash, target_images], 0) # Stack these in batch dim\\n metric_all_images = metric(all_images, is_training=is_training)\\n # B = metric_all_images.get_shape().as_list()[0]\\n metric_all_images = tf.reshape(metric_all_images, [B, -1])\\n metric_hidden_r, metric_hidden_t = tf.split(metric_all_images, 2, 0) # Split these in batch dim\\n\\n # Prep recon_images for visualization\\n # recon_images = tf.clip_by_value(recon_images, clip_value_min=-5, clip_value_max=5)\\n # recon_images = (recon_images + 5) / 10\\n\\n recon_mean, recon_std = tf.nn.moments(recon_images, axes=[1, 2], keep_dims=True)\\n recon_images = (recon_images - recon_mean) / recon_std\\n recon_images = tf.clip_by_value(recon_images, clip_value_min=-5, clip_value_max=5)\\n recon_images = (recon_images + 5) / 10\\n # recon_images = recon_images_squash\\n if greyscale_viz:\\n recon_images = tf.image.rgb_to_grayscale(recon_images)\\n recon_images = tf.concat([recon_images, recon_images, recon_images], -1)\\n print(\\\"Embedding output: \\\")\\n print(metric_hidden_t)\\n print(\\\"---\\\")\\n return outputs, recon_images, metric_hidden_r, metric_hidden_t\\n\\n else:\\n # augs = None\\n \\n with tf.variable_scope('encoder'): # variable_scope name_scope\\n features, block_activities = encoder(inputs, is_training)\\n \\n if data_format == 'channels_last':\\n print(\\\"Features:\\\")\\n print(features)\\n outputs = tf.reduce_mean(features, [1, 2])\\n else:\\n outputs = tf.reduce_mean(features, [2, 3])\\n outputs = tf.identity(outputs, 'final_avg_pool')\\n \\n # filter_trainable_variables(trainable_variables, after_block=5)\\n # add_to_collection(trainable_variables, 'trainable_variables_inblock_')\\n\\n return outputs\",\n \"def architecture(lq, img=None, mode=None):\\r\\n\\r\\n phase = mode == tf.estimator.ModeKeys.TRAIN #phase is true during training\\r\\n concat_axis = 3\\r\\n\\r\\n ##Reusable blocks\\r\\n\\r\\n def conv_block(input, filters, phase=phase):\\r\\n \\\"\\\"\\\"\\r\\n Convolution -> batch normalisation -> leaky relu\\r\\n phase defaults to true, meaning that the network is being trained\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n conv_block = tf.layers.conv2d(\\r\\n inputs=input,\\r\\n filters=filters,\\r\\n kernel_size=3,\\r\\n padding=\\\"SAME\\\",\\r\\n activation=tf.nn.relu)\\r\\n\\r\\n #conv_block = tf.contrib.layers.batch_norm(\\r\\n # conv_block, \\r\\n # center=True, scale=True, \\r\\n # is_training=phase)\\r\\n\\r\\n #conv_block = tf.nn.leaky_relu(\\r\\n # features=conv_block,\\r\\n # alpha=0.2)\\r\\n #conv_block = tf.nn.relu(conv_block)\\r\\n\\r\\n return conv_block\\r\\n\\r\\n def aspp_block(input, phase=phase):\\r\\n \\\"\\\"\\\"\\r\\n Atrous spatial pyramid pooling\\r\\n phase defaults to true, meaning that the network is being trained\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n #Convolutions at multiple rates\\r\\n conv1x1 = tf.layers.conv2d(\\r\\n inputs=input,\\r\\n filters=aspp_filters,\\r\\n kernel_size=1,\\r\\n padding=\\\"same\\\",\\r\\n activation=tf.nn.relu,\\r\\n name=\\\"1x1\\\")\\r\\n #conv1x1 = tf.contrib.layers.batch_norm(\\r\\n # conv1x1, \\r\\n # center=True, scale=True, \\r\\n # is_training=phase)\\r\\n\\r\\n conv3x3_rateSmall = tf.layers.conv2d(\\r\\n inputs=input,\\r\\n filters=aspp_filters,\\r\\n kernel_size=3,\\r\\n padding=\\\"same\\\",\\r\\n dilation_rate=aspp_rateSmall,\\r\\n activation=tf.nn.relu,\\r\\n name=\\\"lowRate\\\")\\r\\n #conv3x3_rateSmall = tf.contrib.layers.batch_norm(\\r\\n # conv3x3_rateSmall, \\r\\n # center=True, scale=True, \\r\\n # is_training=phase)\\r\\n\\r\\n conv3x3_rateMedium = tf.layers.conv2d(\\r\\n inputs=input,\\r\\n filters=aspp_filters,\\r\\n kernel_size=3,\\r\\n padding=\\\"same\\\",\\r\\n dilation_rate=aspp_rateMedium,\\r\\n activation=tf.nn.relu,\\r\\n name=\\\"mediumRate\\\")\\r\\n #conv3x3_rateMedium = tf.contrib.layers.batch_norm(\\r\\n # conv3x3_rateMedium, \\r\\n # center=True, scale=True, \\r\\n # is_training=phase)\\r\\n\\r\\n conv3x3_rateLarge = tf.layers.conv2d(\\r\\n inputs=input,\\r\\n filters=aspp_filters,\\r\\n kernel_size=3,\\r\\n padding=\\\"same\\\",\\r\\n dilation_rate=aspp_rateLarge,\\r\\n activation=tf.nn.relu,\\r\\n name=\\\"highRate\\\")\\r\\n #conv3x3_rateLarge = tf.contrib.layers.batch_norm(\\r\\n # conv3x3_rateLarge, \\r\\n # center=True, scale=True, \\r\\n # is_training=phase)\\r\\n\\r\\n #Image-level features\\r\\n pooling = tf.nn.pool(\\r\\n input=input,\\r\\n window_shape=(2,2),\\r\\n pooling_type=\\\"AVG\\\",\\r\\n padding=\\\"SAME\\\",\\r\\n strides=(2, 2))\\r\\n #Use 1x1 convolutions to project into a feature space the same size as the atrous convolutions'\\r\\n pooling = tf.layers.conv2d(\\r\\n inputs=pooling,\\r\\n filters=aspp_filters,\\r\\n kernel_size=1,\\r\\n padding=\\\"SAME\\\",\\r\\n name=\\\"imageLevel\\\")\\r\\n pooling = tf.image.resize_images(pooling, [64, 64])\\r\\n #pooling = tf.contrib.layers.batch_norm(\\r\\n # pooling,\\r\\n # center=True, scale=True,\\r\\n # is_training=phase)\\r\\n\\r\\n #Concatenate the atrous and image-level pooling features\\r\\n concatenation = tf.concat(\\r\\n values=[conv1x1, conv3x3_rateSmall, conv3x3_rateMedium, conv3x3_rateLarge, pooling],\\r\\n axis=concat_axis)\\r\\n\\r\\n #Reduce the number of channels\\r\\n reduced = tf.layers.conv2d( #Not sure if this is the correct way to reshape...\\r\\n inputs=concatenation,\\r\\n filters=aspp_filters,\\r\\n kernel_size=1,\\r\\n padding=\\\"SAME\\\")\\r\\n\\r\\n return reduced\\r\\n\\r\\n\\r\\n def strided_conv_block(input, filters, stride, rate=1, phase=phase):\\r\\n \\r\\n return slim.separable_convolution2d(\\r\\n inputs=input,\\r\\n num_outputs=filters,\\r\\n kernel_size=3,\\r\\n depth_multiplier=1,\\r\\n stride=stride,\\r\\n padding='SAME',\\r\\n data_format='NHWC',\\r\\n rate=rate,\\r\\n activation_fn=tf.nn.relu,\\r\\n normalizer_fn=None,\\r\\n normalizer_params=None,\\r\\n weights_initializer=tf.contrib.layers.xavier_initializer(),\\r\\n weights_regularizer=None,\\r\\n biases_initializer=tf.zeros_initializer(),\\r\\n biases_regularizer=None,\\r\\n reuse=None,\\r\\n variables_collections=None,\\r\\n outputs_collections=None,\\r\\n trainable=True,\\r\\n scope=None)\\r\\n\\r\\n\\r\\n def deconv_block(input, filters, phase=phase):\\r\\n '''Transpositionally convolute a feature space to upsample it'''\\r\\n \\r\\n deconv_block = tf.layers.conv2d_transpose(\\r\\n inputs=input,\\r\\n filters=filters,\\r\\n kernel_size=3,\\r\\n strides=2,\\r\\n padding=\\\"SAME\\\",\\r\\n activation=tf.nn.relu)\\r\\n\\r\\n #deconv_block = tf.contrib.layers.batch_norm(\\r\\n # deconv_block, \\r\\n # center=True, scale=True, \\r\\n # is_training=phase)\\r\\n\\r\\n #deconv_block = tf.nn.leaky_relu(\\r\\n # features=deconv_block,\\r\\n # alpha=0.2)\\r\\n #deconv_block = tf.nn.relu(deconv_block)\\r\\n\\r\\n return deconv_block\\r\\n\\r\\n '''Model building'''\\r\\n input_layer = tf.reshape(lq, [-1, cropsize, cropsize, channels])\\r\\n\\r\\n #Encoding block 0\\r\\n cnn0 = conv_block(\\r\\n input=input_layer, \\r\\n filters=features0)\\r\\n cnn0_last = conv_block(\\r\\n input=cnn0, \\r\\n filters=features0)\\r\\n cnn0_strided = strided_conv_block(\\r\\n input=cnn0_last,\\r\\n filters=features0,\\r\\n stride=2)\\r\\n\\r\\n #Encoding block 1\\r\\n cnn1 = conv_block(\\r\\n input=cnn0_strided, \\r\\n filters=features1)\\r\\n cnn1_last = conv_block(\\r\\n input=cnn1, \\r\\n filters=features1)\\r\\n cnn1_strided = strided_conv_block(\\r\\n input=cnn1_last,\\r\\n filters=features1,\\r\\n stride=2)\\r\\n\\r\\n #Encoding block 2\\r\\n cnn2 = conv_block(\\r\\n input=cnn1_strided,\\r\\n filters=features2)\\r\\n cnn2_last = conv_block(\\r\\n input=cnn2,\\r\\n filters=features2)\\r\\n cnn2_strided = strided_conv_block(\\r\\n input=cnn2_last,\\r\\n filters=features2,\\r\\n stride=2)\\r\\n\\r\\n #Encoding block 3\\r\\n cnn3 = conv_block(\\r\\n input=cnn2_strided,\\r\\n filters=features3)\\r\\n cnn3 = conv_block(\\r\\n input=cnn3,\\r\\n filters=features3)\\r\\n cnn3_last = conv_block(\\r\\n input=cnn3,\\r\\n filters=features3)\\r\\n cnn3_strided = strided_conv_block(\\r\\n input=cnn3_last,\\r\\n filters=features3,\\r\\n stride=2)\\r\\n\\r\\n #Encoding block 4\\r\\n cnn4 = conv_block(\\r\\n input=cnn3_strided,\\r\\n filters=features4)\\r\\n cnn4 = conv_block(\\r\\n input=cnn4,\\r\\n filters=features4)\\r\\n cnn4_last = conv_block(\\r\\n input=cnn4,\\r\\n filters=features4)\\r\\n\\r\\n #cnn4_strided = split_separable_conv2d(\\r\\n # inputs=cnn4_last,\\r\\n # filters=features4,\\r\\n # rate=2,\\r\\n # stride=2)\\r\\n\\r\\n #Prepare for aspp\\r\\n aspp_input = strided_conv_block(\\r\\n input=cnn4_last,\\r\\n filters=features4,\\r\\n stride=1,\\r\\n rate=2)\\r\\n aspp_input = conv_block(\\r\\n input=aspp_input,\\r\\n filters=features4)\\r\\n\\r\\n ##Atrous spatial pyramid pooling\\r\\n aspp = aspp_block(aspp_input)\\r\\n\\r\\n #Upsample the semantics by a factor of 4\\r\\n #upsampled_aspp = tf.image.resize_bilinear(\\r\\n # images=aspp,\\r\\n # tf.shape(aspp)[1:3],\\r\\n # align_corners=True)\\r\\n\\r\\n #Decoding block 1 (deepest)\\r\\n deconv4 = conv_block(aspp, features4)\\r\\n deconv4 = conv_block(deconv4, features4)\\r\\n deconv4 = conv_block(deconv4, features4)\\r\\n \\r\\n #Decoding block 2\\r\\n deconv4to3 = deconv_block(deconv4, features4)\\r\\n concat3 = tf.concat(\\r\\n values=[deconv4to3, cnn3_last],\\r\\n axis=concat_axis)\\r\\n deconv3 = conv_block(concat3, features3)\\r\\n deconv3 = conv_block(deconv3, features3)\\r\\n deconv3 = conv_block(deconv3, features3)\\r\\n\\r\\n #Decoding block 3\\r\\n deconv3to2 = deconv_block(deconv3, features3)\\r\\n concat2 = tf.concat(\\r\\n values=[deconv3to2, cnn2_last],\\r\\n axis=concat_axis)\\r\\n deconv2 = conv_block(concat2, features2)\\r\\n deconv2 = conv_block(deconv2, features2)\\r\\n \\r\\n #Decoding block 4\\r\\n deconv2to1 = deconv_block(deconv2, features2)\\r\\n concat1 = tf.concat(\\r\\n values=[deconv2to1, cnn1_last],\\r\\n axis=concat_axis)\\r\\n deconv1 = conv_block(concat1, features1)\\r\\n deconv1 = conv_block(deconv1, features1)\\r\\n\\r\\n #Decoding block 5\\r\\n deconv1to0 = deconv_block(deconv1, features1)\\r\\n concat0 = tf.concat(\\r\\n values=[deconv1to0, cnn0_last],\\r\\n axis=concat_axis)\\r\\n deconv0 = conv_block(concat0, features0)\\r\\n deconv0 = conv_block(deconv0, features0)\\r\\n\\r\\n #Create final image with 1x1 convolutions\\r\\n deconv_final = tf.layers.conv2d_transpose(\\r\\n inputs=deconv0,\\r\\n filters=1,\\r\\n kernel_size=3,\\r\\n padding=\\\"SAME\\\",\\r\\n activation=tf.nn.relu)\\r\\n\\r\\n\\r\\n #Residually connect the input to the output\\r\\n output = deconv_final#+input_layer\\r\\n\\r\\n #Image values will be between 0 and 1\\r\\n output = tf.clip_by_value(\\r\\n output,\\r\\n clip_value_min=0,\\r\\n clip_value_max=1)\\r\\n\\r\\n if phase: #Calculate loss during training\\r\\n ground_truth = tf.reshape(img, [-1, cropsize, cropsize, channels])\\r\\n loss = 1.0-tf_ssim(output, ground_truth)#cropsize*cropsize*tf.reduce_mean(tf.squared_difference(output, ground_truth))\\r\\n \\r\\n #tf.log(cropsize*cropsize*tf.reduce_mean(tf.squared_difference(output, ground_truth))+1)\\r\\n #tf.summary.histogram(\\\"loss\\\", loss)\\r\\n else:\\r\\n loss = -1\\r\\n\\r\\n return loss, output\",\n \"def construct_model():\\n import lbann\\n\\n # Layer graph\\n input = lbann.Input(target_mode='N/A', name='inp_data')\\n # data is 64*64*4 images + 15 scalar + 5 param\\n #inp_slice = lbann.Slice(input, axis=0, slice_points=\\\"0 16399 16404\\\",name='inp_slice')\\n inp_slice = lbann.Slice(input, axis=0, slice_points=str_list([0,args.ydim,args.ydim+5]),name='inp_slice')\\n gt_y = lbann.Identity(inp_slice,name='gt_y')\\n gt_x = lbann.Identity(inp_slice, name='gt_x') #param not used\\n\\n zero = lbann.Constant(value=0.0,num_neurons='1',name='zero')\\n one = lbann.Constant(value=1.0,num_neurons='1',name='one')\\n\\n z_dim = 20 #Latent space dim\\n\\n z = lbann.Gaussian(mean=0.0,stdev=1.0, neuron_dims=\\\"20\\\")\\n model = macc_models.MACCWAE(args.zdim,args.ydim,cf=args.mcf,use_CNN=args.useCNN)\\n d1_real, d1_fake, d_adv, pred_y = model(z,gt_y)\\n\\n d1_real_bce = lbann.SigmoidBinaryCrossEntropy([d1_real,one],name='d1_real_bce')\\n d1_fake_bce = lbann.SigmoidBinaryCrossEntropy([d1_fake,zero],name='d1_fake_bce')\\n d_adv_bce = lbann.SigmoidBinaryCrossEntropy([d_adv,one],name='d_adv_bce')\\n img_loss = lbann.MeanSquaredError([pred_y,gt_y])\\n rec_error = lbann.L2Norm2(lbann.WeightedSum([pred_y,gt_y], scaling_factors=\\\"1 -1\\\"))\\n\\n layers = list(lbann.traverse_layer_graph(input))\\n # Setup objective function\\n weights = set()\\n src_layers = []\\n dst_layers = []\\n for l in layers:\\n if(l.weights and \\\"disc0\\\" in l.name and \\\"instance1\\\" in l.name):\\n src_layers.append(l.name)\\n #freeze weights in disc2\\n if(l.weights and \\\"disc1\\\" in l.name):\\n dst_layers.append(l.name)\\n for idx in range(len(l.weights)):\\n l.weights[idx].optimizer = lbann.NoOptimizer()\\n weights.update(l.weights)\\n l2_reg = lbann.L2WeightRegularization(weights=weights, scale=1e-4)\\n d_adv_bce = lbann.LayerTerm(d_adv_bce,scale=0.01)\\n obj = lbann.ObjectiveFunction([d1_real_bce,d1_fake_bce,d_adv_bce,img_loss,rec_error,l2_reg])\\n # Initialize check metric callback\\n metrics = [lbann.Metric(img_loss, name='recon_error')]\\n #pred_y = macc_models.MACCWAE.pred_y_name\\n callbacks = [lbann.CallbackPrint(),\\n lbann.CallbackTimer(),\\n lbann.CallbackSaveModel(dir=args.dump_models),\\n lbann.CallbackReplaceWeights(source_layers=list2str(src_layers),\\n destination_layers=list2str(dst_layers),\\n batch_interval=2)]\\n\\n if(args.ltfb_batch_interval > 0) :\\n callbacks.append(lbann.CallbackLTFB(batch_interval=args.ltfb_batch_interval,metric='recon_error',\\n low_score_wins=True,\\n exchange_hyperparameters=True))\\n\\n # Construct model\\n return lbann.Model(args.num_epochs,\\n serialize_io=True,\\n weights=weights,\\n layers=layers,\\n metrics=metrics,\\n objective_function=obj,\\n callbacks=callbacks)\",\n \"def mgcNetArchNin(outLayer, l2_val, **kwargs):\\n\\n def_vals = {\\\"input_img_rows\\\" : 72,\\n \\\"input_img_cols\\\" : 72,\\n \\\"channels\\\" : 1,\\n \\\"nb_classes\\\" : 13\\n } # default parameters value\\n\\n for k, v in def_vals.items():\\n kwargs.setdefault(k, v)\\n\\n input_img_rows = kwargs['input_img_rows']\\n input_img_cols = kwargs['input_img_cols']\\n channels = kwargs['channels']\\n nb_classes = kwargs['nb_classes']\\n\\n \\n # Input: 72 x 72 x 1\\n img_shape = layers.Input(shape = (input_img_rows, input_img_cols, channels))\\n\\n # Layer 1\\n #------------------------\\n conv1 = layers.Conv2D(filters=16, kernel_size=(5, 5), padding='valid', activation='relu')(img_shape)\\n conv1 = layers.Conv2D(filters=16, kernel_size=(1, 1), activation='relu')(conv1)\\n conv1 = layers.Conv2D(filters=16, kernel_size=(1, 1), activation='relu')(conv1)\\n conv1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)\\n conv1 = layers.Dropout(0.4)(conv1)\\n\\n # Layer 2\\n #------------------------\\n conv2 = layers.Conv2D(filters=32, kernel_size=(5, 5), padding='same', activation='relu')(conv1)\\n conv2 = layers.Conv2D(filters=32, kernel_size=(1, 1), activation='relu')(conv2)\\n conv2 = layers.Conv2D(filters=32, kernel_size=(1, 1), activation='relu')(conv2)\\n conv2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)\\n conv2 = layers.Dropout(0.4)(conv2)\\n\\n # Layer 3\\n #------------------------\\n conv3 = layers.Conv2D(filters=64, kernel_size=(3, 3), padding='same', activation='relu')(conv2)\\n conv3 = layers.Conv2D(filters=64, kernel_size=(1, 1), activation='relu')(conv3)\\n conv3 = layers.Conv2D(filters=64, kernel_size=(1, 1), activation='relu')(conv3)\\n conv3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)\\n conv3 = layers.Dropout(0.4)(conv3)\\n\\n # Layer 4\\n #------------------------\\n #conv4 = layers.Conv2D(filters=128, kernel_size=(2, 2), padding='same', activation='relu')(conv3)\\n #conv4 = layers.Conv2D(filters=128, kernel_size=(1, 1), activation='relu')(conv4)\\n #conv4 = layers.Conv2D(filters=128, kernel_size=(1, 1), activation='relu')(conv4)\\n #conv4 = layers.MaxPooling2D(pool_size=(2, 2))(conv4)\\n #conv4 = layers.Dropout(0.4)(conv4)\\n\\n # Layer 5\\n #------------------------\\n output = layers.Conv2D(filters=128, kernel_size=(2, 2), padding='same', activation='relu')(conv3) # skip layer 4\\n output = layers.Conv2D(filters=64, kernel_size=(1, 1), activation='relu')(output)\\n output = layers.Conv2D(filters=32, kernel_size=(1, 1))(output)\\n output = layers.MaxPooling2D(pool_size=(2, 2))(output)\\n output = layers.Dropout(0.4)(output)\\n\\n \\n # FC Layer\\n #------------------------\\n outputmlp = layers.Flatten()(output)\\n outputmlp = layers.Dense(64, activation = 'relu')(outputmlp)\\n outputmlp = layers.Dropout(0.5)(outputmlp)\\n\\n predictionsMlp = layers.Dense(nb_classes, activation='softmax')(outputmlp)\\n \\n \\n # global averaging\\n weight_decay=1E-4\\n concat_axis = 1\\n \\n x = BatchNormalization(axis=concat_axis,\\n gamma_regularizer=regularizers.l2(weight_decay),\\n beta_regularizer=regularizers.l2(weight_decay))(output)\\n x = Activation('relu')(x)\\n x = layers.Dropout(0.4)(x)\\n x = GlobalAveragePooling2D(data_format=K.image_data_format())(x)\\n \\n predictionsGloAvg = layers.Dense(nb_classes,\\n activation='softmax',\\n kernel_regularizer=regularizers.l2(weight_decay),\\n bias_regularizer=regularizers.l2(weight_decay))(x)\\n \\n if outLayer == \\\"gloAvg\\\":\\n predictions = predictionsGloAvg\\n elif outLayer == \\\"mlp\\\":\\n predictions = predictionsMlp\\n \\n # prediction model\\n model = Model(img_shape, predictions, name = 'net_in_net')\\n\\n\\n return model\",\n \"def model(images, is_training=True):\\n images = tf.reshape(images, [-1, 28, 28, 1])\\n\\n # First convolutional layer with max pooling and ReLU activation.\\n conv1 = slim.conv2d(images, 32, [5, 5], activation_fn=tf.nn.relu, scope='conv1')\\n pool1 = slim.max_pool2d(conv1, [2, 2], scope='pool1')\\n\\n # Second convolutional layer with max pooling and ReLU activation.\\n conv2 = slim.conv2d(pool1, 64, [5, 5], activation_fn=tf.nn.relu, scope='conv2')\\n pool2 = slim.max_pool2d(conv2, [2, 2], scope='pool2')\\n\\n # First fully connected layer with ReLU activation.\\n flat = slim.flatten(pool2)\\n fc1 = slim.fully_connected(flat, 1024, activation_fn=tf.nn.relu, scope='fc1')\\n\\n # Dropout.\\n drop = slim.dropout(fc1, 0.5, is_training=is_training)\\n\\n # Fully connected output layer (logits).\\n fc2 = slim.fully_connected(drop, 10, activation_fn=None, scope='fc2')\\n return fc2\",\n \"def __call__(\\n self, \\n image: ndarray, \\n adversarial_image: ndarray\\n ) -> Dict[str, Union[float, int]]:\\n ...\",\n \"def GNIs(features, labels, mode, params, config):\\n del config\\n N, H = params[\\\"N\\\"], params[\\\"H\\\"]\\n n_samples = params[\\\"n_samples\\\"]\\n\\n params[\\\"non_targeted_layers\\\"] = []\\n\\n if params[\\\"input_inject\\\"]:\\n params[\\\"non_targeted_layers\\\"] = list(range(1, N + 1))\\n\\n params[\\\"non_targeted_layers\\\"] += [N + 1]\\n\\n image_tile_summary(\\\"input\\\", features, rows=1, cols=16)\\n\\n # --- Ensure input data is flat\\n features = tf.reshape(features, (-1, np.prod(params['image_shape'])))\\n features = tf.cast(features, dtype=tf.float32)\\n if labels is not None:\\n labels = tf.cast(labels, dtype=tf.float32)\\n else:\\n labels = tf.ones_like(features[:, :10], dtype=None)\\n B = int_shape(labels)[0]\\n n_output = int_shape(labels)[-1]\\n\\n if params['activation'] != 'linear':\\n activation = getattr(tf.nn, params['activation'])\\n else:\\n activation = None\\n\\n # --- Make discriminator\\n if params[\\\"disc_type\\\"] == 'mlp':\\n mlp = make_mlp(activation, np.prod(params['image_shape']), N, H,\\n n_output)\\n if params[\\\"disc_type\\\"] == 'convnet':\\n mlp = make_convnet(activation, params['image_shape'], n_output)\\n if params[\\\"disc_type\\\"] == 'vgg':\\n mlp = make_vgg13(activation, params['image_shape'], n_output)\\n\\n # --- Retrieve intermediate activations, and layer output\\n # --- we don't want to mask the final layer so activations doesn't include the output layer\\n p_phi_y = mlp(features)\\n\\n sel_layer_shapes = [p_phi_y['layer_shapes'][i] for i in range(N + 1)]\\n\\n # --- Get Predictions using log(p(y|x))\\n preds = p_phi_y['activations'][-1]\\n\\n # --- Classification loss, log(p(y|x))\\n if params[\\\"loss\\\"] == 'cross_entropy':\\n loss = cross_entropy(labels, preds)\\n pred_class = tf.argmax(input=preds, axis=-1)\\n true_class = tf.argmax(input=labels, axis=-1)\\n acc = tf.cast(tf.equal(pred_class, true_class), tf.float32)\\n tf.compat.v1.summary.scalar(\\\"accuracy\\\", tf.reduce_mean(acc))\\n elif params[\\\"loss\\\"] == 'mse':\\n loss = square_error(labels, preds)\\n\\n global_step = tf.compat.v1.train.get_or_create_global_step()\\n\\n p_phi_y_noisy = replace_mask_layer(\\n features,\\n p_phi_y,\\n non_targeted_layers=params['non_targeted_layers'],\\n var=params[\\\"var\\\"],\\n n_samples=n_samples,\\n mode=params[\\\"noise_mode\\\"])\\n\\n preds_noisy = p_phi_y_noisy['activations'][-1]\\n\\n # --- Classification loss, log(p(y|x))\\n if params[\\\"loss\\\"] == 'cross_entropy':\\n noisy_loss = cross_entropy(labels, preds_noisy)\\n elif params[\\\"loss\\\"] == 'mse':\\n noisy_loss = square_error(labels, preds_noisy)\\n\\n optimizer = tf.compat.v1.train.GradientDescentOptimizer(\\n params[\\\"learning_rate\\\"])\\n\\n gradients, variables = [], []\\n\\n tf.compat.v1.summary.scalar(\\\"learning_rate\\\", params[\\\"learning_rate\\\"])\\n tf.compat.v1.summary.scalar(\\\"batch_size\\\", B)\\n\\n # --- Enumerate over activation layers, zip automatically removes final\\n # --- logit layer\\n\\n layers = [\\n l for l in p_phi_y['net'].layers\\n if ('dense' in l.name or 'conv' in l.name)\\n ]\\n\\n noises = [\\n tf.reshape(n, (B, n_samples, -1)) for n in p_phi_y_noisy['noise'][:-1]\\n ]\\n\\n weights = [layers[i].trainable_weights[0] for i in range(N + 1)]\\n acts = p_phi_y['activations'][:-1]\\n\\n Js = [\\n tf.reshape(batch_jacobian(preds, a, use_pfor=True), (B, -1, n_output))\\n for a in acts\\n ]\\n print(Js)\\n\\n G, C, H = calc_taylor_expansion(Js, loss, preds, noises, B, n_samples)\\n\\n EC = calc_tikhonov_reg(Js, acts, preds, params[\\\"noise_mode\\\"],\\n params[\\\"var\\\"], params[\\\"loss\\\"])\\n\\n H_sig = heavy_tail_variance(Js, loss, preds)\\n\\n l_noise = 0\\n if params[\\\"noise_type\\\"] is None:\\n noisy_loss_estimate = loss\\n elif params[\\\"noise_type\\\"] == 'input':\\n noisy_loss_estimate = noisy_loss\\n elif 'full' in params[\\\"noise_type\\\"]:\\n # --- This is the Gaussian stuff\\n assert n_samples == 1\\n l_noise += H + G + C\\n noisy_loss_estimate = loss + l_noise\\n\\n elif 'marginal' in params[\\\"noise_type\\\"]:\\n # --- Don't ever noise final layer\\n assert n_samples == 1\\n l_noise = EC\\n if 'H' in params[\\\"noise_type\\\"]:\\n l_noise += H\\n\\n if 'C' in params[\\\"noise_type\\\"]:\\n # alpha, beta, sigma, mu = tf.py_func(\\n # estimate_all_params,\\n # inp=[(C - EC)],\\n # Tout=[tf.float32, tf.float32, tf.float32, tf.float32])\\n #\\n # tf.compat.v1.summary.scalar('C/alpha', alpha)\\n # tf.compat.v1.summary.scalar('C/beta', beta)\\n # tf.compat.v1.summary.scalar('C/sigma', sigma)\\n # tf.compat.v1.summary.scalar('C/mu', mu)\\n # tf.compat.v1.summary.scalar('C', tf.reduce_mean(C - EC))\\n # tf.compat.v1.summary.histogram('C', C)\\n l_noise += (C - EC)\\n if 'G' in params[\\\"noise_type\\\"]:\\n l_noise += G\\n noisy_loss_estimate = loss + l_noise\\n\\n actual_noise = tf.reduce_mean(noisy_loss - loss)\\n estimated_noise = tf.reduce_mean(noisy_loss_estimate - loss)\\n\\n tf.compat.v1.summary.scalar('loss/actual_noise', actual_noise)\\n tf.compat.v1.summary.scalar('loss/estimated_noise', estimated_noise)\\n\\n tf.compat.v1.summary.scalar(\\\"loss/noisy_\\\" + params[\\\"loss\\\"],\\n tf.reduce_mean(noisy_loss))\\n tf.compat.v1.summary.scalar(\\\"loss/og_\\\" + params[\\\"loss\\\"],\\n tf.reduce_mean(loss))\\n\\n noise_err = tf.reduce_mean(estimated_noise - actual_noise)\\n\\n tf.compat.v1.summary.scalar(\\n 'loss/noise_est_pe',\\n tf.abs(noise_err / tf.reduce_mean(actual_noise + 1e-8)))\\n\\n tf.compat.v1.summary.scalar('loss/noise_est_mse',\\n tf.abs(tf.reduce_mean(noise_err**2)))\\n\\n loss_err = tf.reduce_mean(noisy_loss_estimate - noisy_loss)\\n\\n tf.compat.v1.summary.scalar(\\n 'loss/loss_est_pe',\\n tf.abs(loss_err / tf.reduce_mean(noisy_loss + 1e-8)))\\n\\n tf.compat.v1.summary.scalar('loss/loss_est_mse',\\n tf.abs(tf.reduce_mean(loss_err**2)))\\n\\n if params[\\\"L2\\\"] > 0:\\n vars = tf.trainable_variables()\\n l2_reg = tf.add_n([tf.nn.l2_loss(v) for v in vars]) * params[\\\"L2\\\"]\\n noisy_loss_estimate += l2_reg\\n tf.compat.v1.summary.scalar(\\\"loss/L2_reg\\\", l2_reg)\\n loss_err = tf.reduce_mean(noisy_loss_estimate - noisy_loss)\\n\\n # tf.compat.v1.summary.image('activations_covariance', activation_covariance)\\n # g_noise =\\n for i, w in enumerate(weights):\\n layer_name = \\\"layer_\\\" + str(i)\\n num_params = np.prod(int_shape(w))\\n\\n a = p_phi_y['activations'][i]\\n noisy_a = p_phi_y_noisy['activations'][i]\\n inj_noise = noisy_a - a\\n print(noisy_a, a)\\n\\n # --- Display in tensorboard -- Injected noise stats\\n tf.compat.v1.summary.histogram(layer_name + '/injected_noise',\\n inj_noise)\\n\\n n_neurons = int_shape(a)[1]\\n\\n tf.compat.v1.summary.histogram(layer_name + '/w', w)\\n corr = tfp.stats.correlation(a)\\n tf.compat.v1.summary.scalar(layer_name + '/corr', tf.reduce_mean(corr))\\n\\n sparsity = tf.reduce_sum(tf.cast(a <= 1e-6, tf.float32))\\n\\n # tf.compat.v1.summary.scalar(layer_name + '/lifetime_sparsity',\\n # sparsity / B)\\n tf.compat.v1.summary.scalar(layer_name + '/population_sparsity',\\n sparsity / (B * n_neurons))\\n\\n # --- Retrieve the noise of the gradient of each layer\\n # --- = noisy gradients - gradients, this corresponds to\\n # --- n_t * gradients where n_t is our noise matrix\\n # --- W gradients\\n\\n og_W_n = tf.gradients([tf.reduce_mean(noisy_loss)], [w])[0]\\n\\n g_W_n = tf.gradients([tf.reduce_mean(noisy_loss_estimate)], [w])[0]\\n g = tf.gradients(tf.reduce_mean(loss), w)[0]\\n\\n err = -g_W_n + og_W_n\\n g_noise = g_W_n - g\\n\\n tf.compat.v1.summary.scalar(layer_name + '/mean_grad_noise',\\n tf.reduce_mean(g_noise))\\n tf.compat.v1.summary.histogram(layer_name + '/grad_noise', g_noise)\\n\\n tf.compat.v1.summary.scalar(layer_name + '/weights_l2/',\\n tf.reduce_mean(tf.norm(w)))\\n\\n tf.compat.v1.summary.scalar(layer_name + '/grad_est_mse',\\n tf.reduce_mean((og_W_n - g_W_n)**2))\\n tf.compat.v1.summary.scalar(layer_name + '/grad_est_pe',\\n tf.reduce_mean((-og_W_n + g_W_n) / og_W_n))\\n\\n gradients.extend([g_W_n])\\n variables.extend([w])\\n\\n if i > 0 and params['calc_hessian']:\\n # --- Number of parameters does not include batch_size\\n\\n hessians = trace_hessian([noisy_loss], weights)\\n h_trace = tf.reduce_sum(tf.concat(hessians, axis=1)) / (B * n_samples)\\n\\n for i, h in enumerate(hessians):\\n layer_name = \\\"layer_\\\" + str(i)\\n tf.compat.v1.summary.scalar(layer_name + '/H_trace',\\n tf.reduce_sum(h) / (B * n_samples))\\n\\n tf.compat.v1.summary.scalar('network/H_trace', h_trace)\\n\\n # --- Sum all them losses\\n\\n loss = tf.reduce_mean(loss)\\n noisy_loss = tf.reduce_mean(noisy_loss)\\n\\n train_step = optimizer.apply_gradients(zip(gradients, variables),\\n global_step=global_step)\\n\\n if mode == tf.estimator.ModeKeys.PREDICT:\\n eval_metrics = {}\\n predictions = {\\n 'preds': tf.nn.softmax(p_phi_y['activations'][-1], axis=1)\\n }\\n predictions['GCH'] = G + C + H - EC\\n\\n for i, J in enumerate(Js):\\n predictions['J' + str(i)] = J\\n\\n # for i, w in enumerate(weights):\\n # predictions['dGCH' + str(i)] = tf.gradients(\\n # [predictions['GCH']], [w])[0]\\n if params['calc_hessian']:\\n # --- Number of parameters does not include batch_size\\n\\n hessians = trace_hessian([noisy_loss], weights[1:3])\\n h_trace = tf.reduce_sum(tf.concat(hessians,\\n axis=1)) / (B * n_samples)\\n\\n predictions['h_trace'] = h_trace\\n\\n else:\\n predictions = {}\\n eval_metrics = {\\n \\\"loss/og\\\": tf.compat.v1.metrics.mean(loss),\\n }\\n if params[\\\"loss\\\"] == 'cross_entropy':\\n eval_metrics[\\\"accuracy\\\"] = tf.compat.v1.metrics.mean(acc)\\n\\n return tf.estimator.EstimatorSpec(mode=mode,\\n loss=loss,\\n predictions=predictions,\\n train_op=train_step,\\n eval_metric_ops=eval_metrics)\",\n \"def pre_analyse():\\n t = transform()\\n model = modified_resnet50()\\n model.load_state_dict(\\n torch.load(\\n \\\"model.pth.tar\\\",\\n map_location=torch.device(\\\"cpu\\\"),\\n )[\\\"state_dict\\\"]\\n )\\n model.eval()\\n\\n def get_preds(img_path):\\n \\\"\\\"\\\"\\n Gives labelds and probabilities for a single image\\n This is were we preprocess the image, using a function defined in the model class\\n \\\"\\\"\\\"\\n # load image\\n img = Image.open(img_path).convert(\\\"RGB\\\")\\n # process it\\n x = t(img)\\n # get in in the right format\\n x = Variable(x).unsqueeze(0)\\n # predictions\\n output = model(x)\\n # decode\\n output = decode(output.cpu().data.numpy()[0])\\n\\n # filter\\n # return pred, proba\\n return output\\n\\n return get_preds(\\\"image.jpg\\\")\",\n \"def problem2():\\n\\n data = loaddata(\\\"data/bayerdata.npy\\\")\\n r, g, b = separatechannels(data)\\n\\n img = assembleimage(r, g, b)\\n display_image(img)\\n\\n img_interpolated = interpolate(r, g, b)\\n display_image(img_interpolated)\",\n \"def forward(self, images: Tensor) -> Tensor | list[Tensor] | tuple[list[Tensor]]:\\n self.encoder.eval()\\n\\n if self.tiler:\\n images = self.tiler.tile(images)\\n encoder_features = self.encoder(images)\\n encoder_features = list(encoder_features.values())\\n decoder_features = self.decoder(self.bottleneck(encoder_features))\\n\\n if self.training:\\n output = encoder_features, decoder_features\\n else:\\n output = self.anomaly_map_generator(encoder_features, decoder_features)\\n if self.tiler:\\n output = self.tiler.untile(output)\\n\\n return output\",\n \"def train():\\n\\n ### DO NOT CHANGE SEEDS!\\n # Set the random seeds for reproducibility\\n np.random.seed(42)\\n\\n ## Prepare all functions\\n # Get number of units in each hidden layer specified in the string such as 100,100\\n if FLAGS.dnn_hidden_units:\\n dnn_hidden_units = FLAGS.dnn_hidden_units.split(\\\",\\\")\\n dnn_hidden_units = [int(dnn_hidden_unit_) for dnn_hidden_unit_ in dnn_hidden_units]\\n else:\\n dnn_hidden_units = []\\n\\n # Get negative slope parameter for LeakyReLU\\n neg_slope = FLAGS.neg_slope\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n import matplotlib.pyplot as plt\\n\\n data = cifar10_utils.get_cifar10(FLAGS.data_dir)\\n train = data['train']\\n test = data['test']\\n dim_x = train.images.shape[1]*train.images.shape[2]*train.images.shape[3]\\n\\n mlp = MLP(dim_x, dnn_hidden_units, train.labels.shape[1], neg_slope)\\n loss_module = CrossEntropyModule()\\n\\n loss_train = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n loss_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n accuracy_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n\\n images_test = test.images\\n labels_test = test.labels\\n images_test = np.reshape(images_test, (images_test.shape[0], dim_x))\\n\\n for i in range(0, FLAGS.max_steps):\\n if PRINTS:\\n print('iter', i+1, end='\\\\r')\\n images, labels = train.next_batch(FLAGS.batch_size) \\n images = np.reshape(images, (images.shape[0], dim_x))\\n\\n pred = mlp.forward(images)\\n loss = loss_module.forward(pred, labels)\\n loss_grad = loss_module.backward(pred, labels)\\n mlp.backward(loss_grad)\\n\\n for module in reversed(mlp.modules):\\n if isinstance(module, LinearModule):\\n module.params['weight'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['weight']\\n module.params['bias'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['bias']\\n if (i+1) % FLAGS.eval_freq == 0:\\n pred_test = mlp.forward(images_test)\\n loss_train[i // FLAGS.eval_freq] = loss\\n accuracy_test[i // FLAGS.eval_freq] = accuracy(pred_test, labels_test)\\n loss_test[i // FLAGS.eval_freq] = loss_module.forward(pred_test, labels_test)\\n if PRINTS:\\n print()\\n print('test_loss:', loss_test[i // FLAGS.eval_freq])\\n print('test_accuracy:', accuracy_test[i // FLAGS.eval_freq])\\n print('train_loss:', loss_train[i // FLAGS.eval_freq])\\n\\n if PLOTS:\\n fig, ax = plt.subplots(1, 2, figsize=(10,5))\\n fig.suptitle('Training curves for Numpy MLP\\\\nFinal test accuracy: {:0.4f}, default configuration'.format(accuracy_test[i // FLAGS.eval_freq]))\\n\\n ax[0].set_title('Loss')\\n ax[0].set_ylabel('Loss value')\\n ax[0].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\\n ax[0].plot(loss_train, label='Train')\\n ax[0].plot(loss_test, label='Test')\\n ax[0].legend()\\n\\n ax[1].set_title('Accuracy')\\n ax[1].set_ylabel('Accuracy value')\\n ax[1].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\\n ax[1].plot(accuracy_test, label='Test')\\n ax[1].legend()\\n plt.show()\\n\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def get_classification(self, image):\\n\\n\\tif 'session' in locals() and session is not None:\\n \\t print('Close interactive session')\\n session.close()\\n\\n time_start = time.time()\\n #TODO implement light color prediction\\n #image_np = self.__preprocess_image(image)\\n \\timage_np = image \\n \\n \\t# Expand dimensions since the model expects images to have shape: [1, None, None, 3]\\n image_np_expanded = np.expand_dims(image_np, axis=0)\\n time0 = time.time()\\n\\n # Actual detection.\\n with self.detection_graph.as_default():\\n (boxes, scores, classes, num) = self.sess.run(\\n [self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections],\\n feed_dict={self.image_tensor: image_np_expanded})\\n\\n time1 = time.time()\\n\\n output = self.__postprocessing_detected_box(scores[0], classes[0])\\n rospy.loginfo('Time in seconds' + str(time1-time_start)+' Result:'+self.__traffic_id_to_name(output))\\n return output\",\n \"def build(imageWidth, imageHeight, imageDepth, classesNumber, finalAct=\\\"sigmoid\\\"):\\n\\n # inizializzo il modello come sequenziale\\n model = Sequential()\\n inputShape = (imageHeight, imageWidth, imageDepth)\\n chanDim = -1\\n\\n # Primo blocco Conv2D, Relu, Normalization, MaxPool\\n # Utilizzo 32 filtri 3*3\\n model.add(Conv2D(filters=32, kernel_size=(3, 3), padding=\\\"same\\\", input_shape=inputShape))\\n # con attivazione Rectified Linear Unit\\n model.add(Activation(\\\"relu\\\"))\\n # applico una batch normalization\\n model.add(BatchNormalization(axis=chanDim))\\n # un MaxPooling 3*3\\n model.add(MaxPooling2D(pool_size=(3, 3)))\\n # ed un 25% di dropout per ridurre overfitting\\n model.add(Dropout(0.25))\\n\\n # Secondo blocco\\n model.add(Conv2D(64, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(Conv2D(64, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n # Terzo blocco\\n model.add(Conv2D(128, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(Conv2D(128, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n # Passo ai Fully Connected Layers\\n # Trasformo il modello in un vettore\\n model.add(Flatten())\\n model.add(Dense(1024))\\n model.add(Activation(\\\"sigmoid\\\"))\\n model.add(BatchNormalization())\\n model.add(Dropout(0.5))\\n\\n # Infine utilizzo l'attivazione per la rete\\n model.add(Dense(classesNumber))\\n model.add(Activation(finalAct))\\n\\n return model\",\n \"def encoder_decoder_archi_gan(inputs, is_train):\\n\\n encoder_layers = []\\n\\n encoded = inputs\\n\\n encoder_layers.append(encoded)\\n\\n for i in range(config.encoder_layers):\\n encoded = encoder_conv_block_gan(encoded, i, is_train)\\n encoder_layers.append(encoded)\\n \\n encoder_layers.reverse()\\n\\n\\n\\n decoded = encoder_layers[0]\\n\\n for i in range(config.encoder_layers):\\n decoded = decoder_conv_block_gan(decoded, encoder_layers[i+1], i, is_train)\\n\\n return decoded\",\n \"def loadGt(self):\\n print('Loading and preparing results...')\\n res = Pascal3D(self.cfg, self.dataset_dir, self.list_flag, self.transforms, self.training, load_cad=False)\\n res.dataset = dict()\\n res.dataset['categories'] = copy.deepcopy(self.category_to_id_map)\\n res.dataset['images'] = []\\n anns = []\\n count = 1\\n tic = time.time()\\n for idx in tqdm(range(len(self.img_list_all))):\\n res.dataset['images'].append({'id': self.img_list_all[idx]})\\n if self.list_flag in ['train', 'val']:\\n target = self._add_gt_annotations_Pascal3D(idx)\\n\\n for id in range(len(target)):\\n ann = dict()\\n ann['image_id'] = self.img_list_all[idx]\\n ann['category_id'] = int(target.get_field('labels')[id].numpy())\\n bb = target.bbox[id].numpy()\\n x1, x2, y1, y2 = bb[0], bb[2], bb[1], bb[3]\\n w = x2 - x1\\n h = y2 - y1\\n x_c = (x1 + x2)/2\\n y_c = (y1 + y2)/2\\n ann['bbox'] = [x_c, y_c, w, h]\\n ann['area'] = w * h\\n\\n if target.has_field('segms'):\\n ann['segms'] = target.get_field('segms')[id]\\n # now only support compressed RLE format as segmentation results\\n ann['area'] = maskUtils.area(ann['segms'])\\n if not 'boxes' in ann:\\n ann['boxes'] = maskUtils.toBbox(ann['segms'])\\n\\n ann['id'] = count\\n ann['iscrowd'] = 0\\n count += 1\\n anns.append(ann)\\n\\n print('DONE (t={:0.2f}s)'.format(time.time() - tic))\\n\\n res.dataset['annotations'] = anns\\n res.createIndex()\\n return res\",\n \"def extract_intrinsic_images_from_lighting_passes(self, outdir, vis=False):\\n logger_name = thisfile + '->extract_intrinsic_images_from_lighting_passes()'\\n xm.general.makedirs(outdir)\\n data = self.data\\n\\n def collapse_passes(components):\\n ch_arrays = []\\n for ch in ['R', 'G', 'B']:\\n comp_arrs = []\\n for comp in components:\\n comp_arrs.append(data[comp + '.' + ch])\\n ch_array = np.sum(comp_arrs, axis=0) # sum components\\n ch_arrays.append(ch_array)\\n # Handle alpha channel\\n first_alpha = data[components[0] + '.A']\\n for ci in range(1, len(components)):\\n assert (first_alpha == data[components[ci] + '.A']).all(), \\\\\\n \\\"Alpha channels of all passes must be the same\\\"\\n ch_arrays.append(first_alpha)\\n return np.dstack(ch_arrays)\\n\\n # Albedo\\n albedo = collapse_passes(['diffuse_color', 'glossy_color'])\\n np.save(join(outdir, 'albedo.npy'), albedo)\\n if vis:\\n xm.vis.matrix_as_image(albedo, outpath=join(outdir, 'albedo.png'))\\n # Shading\\n shading = collapse_passes(['diffuse_indirect', 'diffuse_direct'])\\n np.save(join(outdir, 'shading.npy'), shading)\\n if vis:\\n xm.vis.matrix_as_image(shading, join(outdir, 'shading.png'))\\n # Specularity\\n specularity = collapse_passes(['glossy_indirect', 'glossy_direct'])\\n np.save(join(outdir, 'specularity.npy'), specularity)\\n if vis:\\n xm.vis.matrix_as_image(specularity, join(outdir, 'specularity.png'))\\n # Reconstruction vs. ...\\n recon = np.multiply(albedo, shading) + specularity\\n recon[:, :, 3] = albedo[:, :, 3] # can't add up alpha channels\\n np.save(join(outdir, 'recon.npy'), recon)\\n if vis:\\n xm.vis.matrix_as_image(recon, join(outdir, 'recon.png'))\\n # ... composite from Blender, just for sanity check\\n composite = collapse_passes(['composite'])\\n np.save(join(outdir, 'composite.npy'), composite)\\n if vis:\\n xm.vis.matrix_as_image(composite, join(outdir, 'composite.png'))\\n logger.name = logger_name\\n logger.info(\\\"Intrinsic images extracted to %s\\\", outdir)\",\n \"def build_conv_combo_autoencoder():\\n input_img = Input(shape=(84, 84, 1))\\n\\n x = Convolution2D(48, 4, 4, activation='relu', border_mode='same', name='c1')(input_img)\\n x = MaxPooling2D((2, 2), border_mode='same')(x)\\n x = Convolution2D(48, 4, 4, activation='relu', border_mode='same', name='c2')(x)\\n x = MaxPooling2D((3, 3), border_mode='same')(x)\\n x = Flatten()(x)\\n encoded = Dense(512, activation='relu')(x)\\n\\n encoded_input = Input((512,))\\n d1 = Dense(9408, activation='relu')(encoded_input)\\n d2 = Reshape((14, 14, 48))(d1)\\n d3 = Convolution2D(48, 4, 4, activation='relu', border_mode='same', name='c5')(d2)\\n d4 = UpSampling2D((3, 3))(d3)\\n d5 = Convolution2D(48, 4, 4, activation='relu', border_mode='same', name='c6')(d4)\\n d6 = UpSampling2D((2, 2))(d5)\\n decoded = Convolution2D(1, 4, 4, activation='relu', border_mode='same', name='c9')(d6)\\n\\n encoder = Model(input=input_img, output=encoded, name='conv_encoder')\\n decoder = Model(input=encoded_input, output=decoded, name='conv_decoder')\\n\\n autoencoder = Sequential(name='full_conv_autoencoder')\\n autoencoder.add(encoder)\\n autoencoder.add(decoder)\\n\\n encoder.compile(optimizer='adam', loss='mse')\\n encoder.summary()\\n decoder.compile(optimizer='adam', loss='mse')\\n decoder.summary()\\n autoencoder.compile(optimizer='adam', metrics=['mse'], loss='mse')\\n autoencoder.summary()\\n return autoencoder, encoder, decoder\",\n \"def read():\\n\\n # load json and create model\\n base_model = _model_builder.Network(0, model_type=\\\"load_model\\\")\\n\\n #load image and process\\n digit = Image.open(\\\"./data/number.jpg\\\").convert(\\\"L\\\")\\n digit = ImageOps.expand(digit,border=60,fill='black')\\n digit = digit.resize((28, 28))\\n\\n #flatten the matrix (for input into MLP network todo:CNN)\\n digit_flat = numpy.zeros((1, 784))\\n counter = 0\\n for j in range(0, 28):\\n for i in range(0, 28):\\n digit_flat[0][counter] = (digit.getpixel((i, j)))/255.0\\n counter = counter+1\\n\\n #predict\\n os.system('clear')\\n base_model.predict(digit_flat)\",\n \"def get_data(input_path):\\n all_imgs = []\\n classes_count = {}\\n class_mapping = {}\\n\\n # parsing Flag\\n visualise = False\\n\\n # MSCOCO directory\\n data_path = input_path\\n\\n print('Parsing annotation files')\\n annot_path = os.path.join(data_path, 'annotations_bbox')\\n imgs_path = os.path.join(data_path, 'images')\\n\\n # images directory (train, val, trainval, test)\\n imgsets_path_trainval = os.path.join(data_path, 'images', 'trainval.txt')\\n imgsets_path_train = os.path.join(data_path, 'images', 'train.txt')\\n imgsets_path_val = os.path.join(data_path, 'images', 'val.txt')\\n imgsets_path_test = os.path.join(data_path, 'images', 'test.txt')\\n\\n trainval_files = []\\n train_files = []\\n val_files = []\\n test_files = []\\n\\n with open(imgsets_path_trainval) as f:\\n for line in f:\\n trainval_files.append(line.strip())\\n\\n with open(imgsets_path_train) as f:\\n for line in f:\\n train_files.append(line.strip())\\n\\n with open(imgsets_path_val) as f:\\n for line in f:\\n val_files.append(line.strip())\\n\\n # test-set (default) not included in MSCOCO\\n if os.path.isfile(imgsets_path_test):\\n with open(imgsets_path_test) as f:\\n for line in f:\\n test_files.append(line.strip())\\n\\n # annotation read\\n annots_train = json.load(open(os.path.join(annot_path, 'bbox_train2017.json'), 'r'))\\n annots_val = json.load(open(os.path.join(annot_path, 'bbox_val2017.json'), 'r'))\\n annots = dict()\\n annots['train'] = annots_train\\n annots['val'] = annots_val\\n\\n for part in ['train', 'val']:\\n annots_keys = tqdm(annots[part].keys())\\n for img_name in annots_keys:\\n annots_keys.set_description(\\\"Processing %s\\\" % img_name)\\n for bbox in annots[part][img_name]:\\n class_name = bbox['label'].replace(' ', '')\\n all_imgs.append({\\n \\\"filepath\\\": os.path.join(data_path, 'images', '%s2017' % part, \\\"%s.jpg\\\" % img_name),\\n \\\"width\\\": None,\\n \\\"height\\\": None,\\n \\\"bboxes\\\": [{\\n \\\"class\\\": class_name,\\n \\\"x1\\\": bbox['bbox']['x1'],\\n \\\"y1\\\": bbox['bbox']['x2'],\\n \\\"x2\\\": bbox['bbox']['y1'],\\n \\\"y2\\\": bbox['bbox']['y2'],\\n \\\"difficult\\\": False\\n }],\\n \\\"image_id\\\": img_name,\\n \\\"imageset\\\": part\\n })\\n if class_name not in classes_count:\\n classes_count[class_name] = 1\\n else:\\n classes_count[class_name] += 1\\n if class_name not in class_mapping:\\n class_mapping[class_name] = len(class_mapping)\\n\\n # visualise bounding boxes\\n if visualise:\\n img = cv2.imread(annotation_data['filepath'])\\n for bbox in annotation_data['bboxes']:\\n cv2.rectangle(img, (bbox['x1'], bbox['y1']), (bbox['x2'], bbox['y2']), (0, 0, 255))\\n cv2.imshow('img', img)\\n print(annotation_data['imageset'])\\n cv2.waitKey(0)\\n\\n return all_imgs, classes_count, class_mapping\",\n \"def loadRes(self, predictions):\\n print('Loading and preparing results...')\\n res = Pascal3D(self.cfg, self.dataset_dir, self.list_flag, self.transforms, self.training, load_cad=False)\\n res.dataset = dict()\\n res.dataset['categories'] = copy.deepcopy(self.category_to_id_map)\\n res.dataset['images'] = []\\n anns = []\\n count = 1\\n tic = time.time()\\n masker = Masker(threshold=0.5, padding=1)\\n\\n for idx in tqdm(range(len(self.img_list_all))):\\n res.dataset['images'].append({'id': self.img_list_all[idx]})\\n prediction = predictions[idx]\\n for id in range(len(prediction)):\\n ann = dict()\\n ann['image_id'] = self.img_list_all[idx]\\n ann['category_id'] = int(prediction.get_field('labels')[id].cpu().numpy())\\n bb = prediction.bbox[id].cpu().numpy()\\n x1, x2, y1, y2 = bb[0], bb[2], bb[1], bb[3]\\n w = x2 - x1\\n h = y2 - y1\\n x_c = (x1 + x2) / 2\\n y_c = (y1 + y2) / 2\\n ann['bbox'] = [x_c, y_c, w, h]\\n ann['area'] = w * h\\n ann['score'] = prediction.get_field('scores')[id].cpu().numpy()\\n\\n if prediction.has_field('mask'):\\n image_width, image_height, _ = res.targets[idx]['record']['imgsize']\\n\\n masks = prediction.get_field('mask')\\n # Masker is necessary only if masks haven't been already resized.\\n if list(masks.shape[-2:]) != [image_height, image_width]:\\n masks = masker(masks.expand(1, -1, -1, -1, -1), prediction)\\n masks = masks[0]\\n\\n ann['segms'] = [maskUtils.encode(np.array(mask[0, :, :, np.newaxis], order=\\\"F\\\"))[0] for mask in masks]\\n ann['category_id'] = int(prediction.get_field('labels')[id].cpu().numpy())\\n # now only support compressed RLE format as segmentation results\\n #ann['area'] = maskUtils.area(ann['segms'])\\n if not 'boxes' in ann:\\n ann['boxes'] = maskUtils.toBbox(ann['segms'])\\n\\n ann['id'] = count\\n count += 1\\n ann['iscrowd'] = 0\\n anns.append(ann)\\n\\n print('DONE (t={:0.2f}s)'.format(time.time() - tic))\\n res.dataset['annotations'] = anns\\n res.createIndex()\\n return res\",\n \"def classify_images():\\n\\n # Load the desired image\\n img_path = 'dataset/colorize_images/n02085782_919.jpg'\\n img = image.load_img(img_path, target_size=(299, 299))\\n x = image.img_to_array(img)\\n x = np.expand_dims(x, axis=0)\\n x = preprocess_input(x)\\n\\n model = InceptionV3(weights=\\\"imagenet\\\")\\n preds = model.predict(x)\\n # decode the results into a list of tuples (class, description, probability)\\n # (one such list for each sample in the batch)\\n print('Predicted:', decode_predictions(preds, top=3)[0])\",\n \"def data_augmentation_and_vectorization(self,imlist, lb,im_labels, average_image = None):\\n\\t\\tX,Y,X_original = [] ,[], []\\n\\n\\t\\ti = 0\\n\\t\\tfor im in imlist:\\n\\t\\t\\tim=Image.fromarray(im,mode=self.mode)\\n\\t\\t\\t#try:\\n\\t\\t\\t#im_ini = im\\n\\t\\t\\tim_original = np.asarray(im, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t#im = self.substract_average_image(im, average_image)\\n\\t\\t\\t#print 'i:{} is a: {}' .format(i,im_labels[i])\\n\\t\\t\\t#im.show()\\n\\t\\t\\tX_original.append(im_original)\\n\\n\\t\\t\\t#Rotations \\n\\t\\t\\t#im_r = im.rotate(15)\\n\\t\\t\\t# im_r_2 = im.rotate(-15)\\n\\t\\t\\t# im_r_3 = im.rotate(180)\\n\\t\\t\\t#im_r.show()\\n\\t\\t\\t#im_r_2.show()\\n\\n\\t\\t\\t#Filters\\n\\t\\t\\t#im_f = im_ini.filter(ImageFilter.DETAIL)\\n\\t\\t\\t#im_f = im.filter(ImageFilter.FIND_EDGES)\\n\\t\\t\\t\\n\\t\\t\\tif self.mode == 'RGB':\\n\\t\\t\\t\\tim = np.asarray(im, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t\\t#Uncomment this if you want to use cross-correlate for 2D arrays http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.signal.correlate2d.html\\n\\t\\t\\t\\t# im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t\\t# im = sp.inner(im, [299, 587, 114]) / 1000.0\\n\\t\\t\\t\\t# im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t\\t# # normalize per http://en.wikipedia.org/wiki/Cross-correlation\\n\\t\\t\\t\\t# im = (im - im.mean()) / im.std()\\n\\n\\t\\t\\tif self.mode == 'L':\\n\\t\\t\\t\\t# im = np.asarray(im, dtype='float64')\\n\\t\\t\\t\\t# im = filters.sobel(im)\\n\\t\\t\\t\\t#im = filters.roberts(im)\\n\\t\\t\\t\\tim = np.asarray(im, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t\\n\\t\\t\\t#im = np.asarray(im, dtype=np.uint8)\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t#im = self.flaten_aux(im)\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#im = data.coins() # or any NumPy arr\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#image = data.coins() # or any NumPy array!\\n\\t\\t\\t#print im\\n\\t\\t\\t#im = filter.sobel(im)\\n\\t\\t\\t#im = filter.roberts(im)\\n\\n\\t\\t\\t# im_original = sp.inner(im, [299, 587, 114]) / 1000.0\\n\\t\\t\\t# im_original = np.asarray(im_original, dtype=theano.config.floatX)\\n\\t\\t\\t# # normalize per http://en.wikipedia.org/wiki/Cross-correlation\\n\\t\\t\\t# im = (im_original - im_original.mean()) / im_original.std()\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#print edges\\n\\t\\t\\t# edges = np.asarray(edges, dtype=np.uint8)\\n\\t\\t\\t#Image.fromarray(edges,mode=self.mode).show()\\n\\n\\t\\t\\t#print edges\\n\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX) / 256.\\n\\n\\t\\t\\t#print edges.shape\\n\\t\\t\\t# io.imshow(im)\\n\\t\\t\\t# io.show()\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t\\n\\t\\t\\t# plt.suptitle(im_labels[i], size=16)\\n\\t\\t\\t# plt.imshow(im, cmap=plt.cm.gray, interpolation='nearest')\\n\\t\\t\\t# plt.show()\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#self.reconstructImage(im).show()\\n\\n\\t\\t\\t#im_r = np.asarray(im_r, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t# im_r_2 = np.asarray(im_r_2, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t# im_r_3 = np.asarray(im_r_3, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t#im_f = np.asarray(im_f, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t\\n\\t\\t\\t#im = im.transpose(2, 0, 1)\\n\\t\\t\\t#X.append(np.array(im, dtype=theano.config.floatX))\\n\\t\\t\\t#X.append(np.array(im_raw, dtype=theano.config.floatX))\\n\\t\\t\\t#X.append(im)\\n\\t\\t\\tX.append(im)\\n\\t\\t\\t# if i % 100 == 0:\\n\\t\\t\\t# \\tX.append(im)\\n\\t\\t\\t#X.append(im_r)\\n\\t\\t\\t# X.append(im_r_2)\\n\\t\\t\\t# X.append(im_r_3)\\n\\t\\t\\t#X.append(im_f)\\n\\t\\t\\t#X_original.append(im)\\n\\n\\t\\t\\t# X.append(np.array(im_r, dtype=theano.config.floatX))\\n\\t\\t\\t# X.append(np.array(im_r_2, dtype=theano.config.floatX))\\n\\n\\t\\t\\t#Uncomment this if you want to work with monochrome\\n\\t\\t\\t# im = im.convert('L')\\n\\t\\t\\t# pixels_monochrome = np.array(list(im.getdata()), dtype=np.float)\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t# # scale between 0-1 to speed up computations\\n\\t\\t\\t# min_max_scaler = preprocessing.MinMaxScaler(feature_range=(0,1), copy=True)\\n\\t\\t\\t# pixels_monochrome = min_max_scaler.fit_transform(pixels_monochrome)\\n\\n\\t\\t\\t# X.append(pixels_monochrome)\\n\\n\\t\\t\\t#Y.append(lb.transform([im_labels[i]])[0][0])\\n\\t\\t\\t#print lb.transform([im_labels[i]])\\n\\t\\t\\t\\n\\t\\t\\tlabel = lb.transform([im_labels[i]])[0][0]\\n\\t\\t\\t#print lb.transform([im_labels[i]])\\n\\t\\t\\t# label_vector = lb.transform([im_labels[i]])[0]\\n\\t\\t\\t# label = np.where( label_vector == 1 )[0][0]\\n\\t\\t\\t# print \\\"Label: {}\\\".format(label)\\n\\t\\t\\t#print label\\n\\t\\t\\t#Y.append(label)\\n\\t\\t\\tY.append(label)\\n\\t\\t\\t#Y.append(im_labels[i])\\t\\n\\n\\t\\t\\t\\n\\t\\t\\t#Y.append(label)\\t\\n\\t\\t\\t# Y.append(label)\\t\\n\\t\\t\\t# except Exception, e:\\n\\t\\t\\t# \\tprint e\\n\\t\\t\\t# \\t#raise e\\n\\n\\t\\t\\t# if i == 30:\\n\\t\\t\\t# \\tbreak\\n\\n\\t\\t\\ti += 1\\n\\t\\t\\tif self.verbose:\\n\\t\\t\\t\\tsys.stdout.write(\\\"\\\\r Process: {0}/{1}\\\".format(i, len(imlist)))\\n\\t\\t\\t\\tsys.stdout.flush()\\n\\t\\t\\n\\t\\t# output = open(self.data_path + 'X_original.pkl', 'wb')\\n\\t\\t# cPickle.dump(X_original, output,protocol=-1)\\n\\t\\t# output.close()\\n\\n\\t\\treturn X,Y\",\n \"def train_one_epoch_Image_display(self):\\n print('Training......')\\n\\n # set mode train\\n self.network.train()\\n\\n # prepare data\\n train_loss = 0\\n transform = transforms.Compose([Rescale(params.rescale_size),\\n RandomCrop(params.image_size),\\n RandomHorizontalFlip(),\\n ToTensor()\\n ])\\n\\n\\n\\n dataset = Cityscapes(params.dataset_root, mode='train', transforms = transform)\\n\\n train_loader = DataLoader(dataset,\\n batch_size=params.train_batch,\\n shuffle=params.shuffle,\\n num_workers=params.dataloader_workers)\\n \\n train_size = 1896\\n if train_size % self.params.train_batch != 0:\\n total_batch = train_size // self.params.train_batch + 1\\n else:\\n total_batch = train_size // self.params.train_batch\\n recal = 0\\n precision = 0\\n F_one = 0\\n IOU = 0\\n accuracy_new = 0 \\n # train through dataset\\n for batch_idx, batch in enumerate(train_loader):\\n self.pb.click(batch_idx, total_batch)\\n image, label = batch['image'], batch['label']\\n image_cuda, label_cuda = image.cuda(), label.cuda()\\n\\n # checkpoint split\\n if self.params.should_split:\\n image_cuda.requires_grad_()\\n out = checkpoint_sequential(self.network, self.params.split, image_cuda)\\n else:\\n out = self.network(image_cuda)\\n \\n pred = image_cuda\\n pred = pred.to(torch.device(\\\"cpu\\\"))\\n pred = pred.detach()\\n img_grid = pred[0]\\n #img_grid = torchvision.utils.make_grid(out) \\n img_grid = img_grid.numpy().transpose(1, 2, 0)*255\\n cv2.imwrite(\\\"/content/drive/My Drive/Train_images/original%d.jpg\\\" % batch_idx, img_grid)\\n\\n \\n loss = self.loss_fn(out, label_cuda)\\n \\n #display_image(out, label_cuda)\\n TP, FP, TN, FN = confusion(out, label_cuda)\\n recal = recal+TP\\n precision = precision+FP\\n F_one = F_one + TN\\n IOU = IOU+ FN \\n _,predict = torch.max(out.data,1)\\n predict = predict.to(torch.device(\\\"cpu\\\"))\\n predict = predict.detach()\\n img = predict[0]\\n img = img.numpy()*255\\n #img_grid = torchvision.utils.make_grid(out) \\n cv2.imwrite(\\\"/content/drive/My Drive/Train_images/predict_label%d.png\\\" % batch_idx, img)\\n label = label_cuda.to(torch.device(\\\"cpu\\\"))\\n label = label.detach()\\n label = label[0].numpy()*255\\n cv2.imwrite(\\\"/content/drive/My Drive/Train_images/original_label%d.png\\\" % batch_idx, label)\\n\\n \\n \\n\\n accuracy_final = accuracy(out, label_cuda)\\n accuracy_new = accuracy_new + accuracy_final\\n\\n \\n print(\\\"\\\\t\\\")\\n print(recal/total_batch, precision/ total_batch, F_one/ total_batch, IOU/ total_batch)\\n print(accuracy_new/total_batch)\",\n \"def data_augmentation(im_list, mode='standard', tag=False, params=None, im_size=224,\\n filemode='local', mean_RGB=None):\\n if mean_RGB is None:\\n mean_RGB = np.array([107.59348955, 112.1047813, 80.9982362])\\n else:\\n mean_RGB = np.array(mean_RGB)\\n rot_ang = [0, 90, 180, 270]\\n batch = []\\n if tag:\\n tag_list = im_list[:, 1]\\n im_list = im_list[:, 0]\\n if mode == 'minimal':\\n params = {'mirror': False, 'rescale': False, 'crop_size': False}\\n if mode == 'standard':\\n params = {'mirror': True, 'rescale': 0.3, 'zoom': 0.3, 'crop_size': 1.}\\n if mode == 'test':\\n params = {'mirror': True, 'rescale': 0.1, 'zoom': 0.1, 'crop_size': .9}\\n for i, filename in enumerate(im_list):\\n if filemode == 'local':\\n im = Image.open(filename)\\n im = im.convert('RGB')\\n elif filemode == 'url':\\n filename = BytesIO(requests.get(filename).content)\\n im = Image.open(filename)\\n im = im.convert('RGB')\\n if params['mirror'] and np.random.random() > 0.5:\\n im = im.transpose(Image.FLIP_LEFT_RIGHT)\\n if params['mirror'] and tag and tag_list[i] != 'habit':\\n if np.random.random() > 0.5:\\n im = im.transpose(Image.FLIP_TOP_BOTTOM)\\n rot = np.random.choice(rot_ang)\\n if rot == 90:\\n im = im.transpose(Image.ROTATE_90)\\n if rot == 180:\\n im = im.transpose(Image.ROTATE_180)\\n if rot == 270:\\n im = im.transpose(Image.ROTATE_270)\\n if params['rescale']:\\n rescale = params['rescale']\\n new_scale = np.random.uniform(low=1.-rescale, high=1.+rescale, size=2)\\n im = im.resize((im.size * new_scale).astype(int))\\n if params['crop_size']:\\n zoom = np.random.rand() * params['zoom']\\n crop_size = params['crop_size'] * (1.-zoom)\\n ly, lx = im.size\\n min_side = min([ly, lx])\\n if crop_size == 1:\\n crop_size -= 1e-10 # avoid low=high problem of randint generator\\n if ly > lx:\\n rand_x = np.random.randint(low=0, high=lx*(1.-crop_size))\\n rand_y = np.random.randint(low=0, high=ly-lx*crop_size)\\n else:\\n rand_x = np.random.randint(low=0, high=lx-ly*crop_size)\\n rand_y = np.random.randint(low=0, high=ly*(1.-crop_size))\\n rand_xy = np.array([rand_y, rand_x])\\n im = im.crop(np.concatenate((rand_xy, rand_xy+crop_size*min_side)))\\n im = im.resize((im_size, im_size))\\n batch.append(np.array(im)) # shape (N, 224, 224, 3)\\n\\n batch = np.array(batch) - mean_RGB[None, None, None, :] # mean centering\\n batch = batch.transpose(0, 3, 1, 2) # shape(N, 3, 224, 224)\\n batch = batch[:, ::-1, :, :] # switch from RGB to BGR\\n return batch.astype(np.float32)\",\n \"def image_network_train(learn_data_path):\\n\\n # data selector ----------\\n use_da_data = False\\n increase_val = False\\n print( \\\"\\\\nmode: Use Augmented data: {} | increase validation data: {}\\\".format(use_da_data, increase_val) )\\n\\n # First define original train_data only as train_dir\\n train_dir = os.path.join(data_dir, \\\"train\\\")\\n if (use_da_data == True) and (increase_val == False):\\n # with_augmented data (no validation increase)\\n train_dir = os.path.join(data_dir, \\\"train_with_aug\\\")\\n validation_dir = os.path.join(data_dir, \\\"val\\\") # original validation data\\n\\n # pair of decreaced train_data and increased validation data\\n if (increase_val == True):\\n train_dir = os.path.join(data_dir, \\\"red_train\\\")\\n if (use_da_data == True):\\n train_dir = os.path.join(data_dir, \\\"red_train_with_aug\\\")\\n validation_dir = os.path.join(data_dir, \\\"validation\\\")\\n\\n test_dir = os.path.join(data_dir, \\\"test\\\")\\n\\n print(\\\"\\\\ntrain_dir: \\\", train_dir)\\n print(\\\"validation_dir: \\\", validation_dir)\\n\\n\\n # calcucate the num of category\\n num_category = 0\\n for dirpath, dirnames, filenames in os.walk(train_dir):\\n for dirname in dirnames:\\n num_category += 1\\n\\n # All images will be resized to 299x299\\n image_size = 299\\n batch_size = 16\\n\\n # Rescale all images by 1./255 and apply image augmentation\\n train_datagen = keras.preprocessing.image.ImageDataGenerator(rescale=1./255)\\n validation_datagen = keras.preprocessing.image.ImageDataGenerator(rescale=1./255)\\n test_datagen = keras.preprocessing.image.ImageDataGenerator(rescale=1./255)\\n\\n # Flow training images in batches of using train_datagen generator\\n train_generator = train_datagen.flow_from_directory(\\n train_dir, # Source directory for the training images\\n target_size=(image_size, image_size),\\n batch_size=batch_size,\\n class_mode='categorical')\\n\\n # Flow validation images in batches of 20 using validation_datagen generator\\n validation_generator = validation_datagen.flow_from_directory(\\n validation_dir, # Source directory for the validation images\\n target_size=(image_size, image_size),\\n batch_size=batch_size,\\n class_mode='categorical')\\n\\n # Flow validation images in batches of 20 using test_datagen generator\\n test_generator = test_datagen.flow_from_directory(\\n test_dir, # Source directory for the test images\\n target_size=(image_size, image_size),\\n batch_size=batch_size,\\n class_mode='categorical')\\n\\n # Create the base model from the pre-trained convnets\\n IMG_SHAPE = (image_size, image_size, 3)\\n\\n # Create the base model from the pre-trained model MobileNet V2\\n base_model = keras.applications.xception.Xception(input_shape=IMG_SHAPE, include_top=False, weights='imagenet')\\n\\n # Freeze the convolutional base\\n base_model.trainable = False\\n\\n # モデル\\n model = keras.Sequential([\\n base_model,\\n keras.layers.GlobalAveragePooling2D(),\\n keras.layers.Dense(num_category, activation='softmax')\\n ])\\n\\n # Compile the model\\n model.compile(optimizer=keras.optimizers.Adam(lr=0.0001),\\n loss='categorical_crossentropy',\\n metrics=['accuracy'])\\n\\n # early stopping\\n es = keras.callbacks.EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)\\n\\n model.summary()\\n\\n # 更新される重みの数\\n print('after', len(model.trainable_weights))\\n\\n # Train the model\\n epochs = 30\\n steps_per_epoch = train_generator.n // batch_size\\n validation_steps = validation_generator.n // batch_size\\n test_steps = test_generator.n // batch_size\\n\\n history = model.fit_generator(train_generator,\\n steps_per_epoch = steps_per_epoch,\\n epochs=epochs,\\n workers=4,\\n validation_data=validation_generator,\\n validation_steps=validation_steps,\\n callbacks=[es],\\n class_weight={0:1.0, 1:0.4})\\n\\n loss, acc = model.evaluate_generator(validation_generator, steps=validation_steps)\\n print('val loss: {}, val acc: {}'.format(loss, acc))\\n\\n # Fine tuning\\n # Un-freeze the top layers of the model\\n base_model.trainable = True\\n\\n # The nums of layers are in the base model\\n print(\\\"Number of layers in the base model: \\\", len(base_model.layers))\\n\\n # Fine tune from this layer onwards\\n fine_tune_at = 108\\n\\n # Freeze all the layers before the `fine_tune_at` layer\\n for layer in base_model.layers[:fine_tune_at]:\\n layer.trainable = False\\n\\n # Compile the model using a much-lower training rate\\n model.compile(optimizer = keras.optimizers.Adam(lr=2e-5),\\n loss='categorical_crossentropy',\\n metrics=['accuracy'])\\n\\n model.summary()\\n\\n # 更新される重みの数\\n print('after Fine tune', len(model.trainable_weights))\\n\\n # Continue Train the model\\n history_fine = model.fit_generator(train_generator,\\n steps_per_epoch = steps_per_epoch,\\n epochs=epochs,\\n workers=4,\\n validation_data=validation_generator,\\n validation_steps=validation_steps,\\n callbacks=[es],\\n class_weight={0:1.0, 1:0.4})\\n\\n\\n # print(history_fine.history)\\n model_val_acc = history_fine.history['val_accuracy'][-1]\\n print('val_acc: ', model_val_acc)\\n\\n # save model into hdf5 file ----------\\n model.save(learn_data_path + '/shen_model.h5')\\n\\n loss, acc = model.evaluate_generator(validation_generator, steps=validation_steps)\\n print('val loss: {}, val acc: {}'.format(loss, acc))\\n\\n loss, acc = model.evaluate_generator(test_generator, steps=test_steps)\\n print('Test loss: {}, Test acc: {}'.format(loss, acc))\",\n \"def build_layers(self):\\n raise NotImplementedError\",\n \"def __call__(self, in_data):\\n # There are five data augmentation steps\\n # 1. Color augmentation\\n # 2. Random expansion\\n # 3. Random cropping\\n # 4. Resizing with random interpolation\\n # 5. Random horizontal flipping\\n if self.count % 10 == 0 and self.count % self.batchsize == 0 and self.count != 0:\\n self.i += 1\\n i = self.i % len(self.dim)\\n self.output_shape = (self.dim[i], self.dim[i])\\n # print(self.count, self.i, self.output_shape)\\n self.count += 1\\n\\n img, bbox, label = in_data\\n\\n # 1. Color augmentation\\n img = random_distort(img, brightness_delta=32,\\n contrast_low=0.5, contrast_high=1.5,\\n saturation_low=0.5, saturation_high=1.5,\\n hue_delta=25)\\n\\n # Normalize. range is [0, 1]\\n img /= 255.0\\n\\n _, H, W = img.shape\\n scale = np.random.uniform(0.25, 2)\\n random_expand = np.random.uniform(0.8, 1.2, 2)\\n net_h, net_w = self.output_shape\\n out_h = net_h * scale # random_expand[0]\\n out_w = net_w * scale # random_expand[1]\\n if H > W:\\n out_w = out_h * (float(W) / H) * np.random.uniform(0.8, 1.2)\\n elif H < W:\\n out_h = out_w * (float(H) / W) * np.random.uniform(0.8, 1.2)\\n\\n out_h = int(out_h)\\n out_w = int(out_w)\\n\\n img = resize_with_random_interpolation(img, (out_h, out_w))\\n bbox = transforms.resize_bbox(bbox, (H, W), (out_h, out_w))\\n\\n if out_h < net_h and out_w < net_w:\\n img, param = expand(img, out_h=net_h, out_w=net_w,\\n fill=self.value, return_param=True)\\n bbox = transforms.translate_bbox(\\n bbox, y_offset=param['y_offset'], x_offset=param['x_offset'])\\n else:\\n out_h = net_h if net_h > out_h else int(out_h * 1.05)\\n out_w = net_w if net_w > out_w else int(out_w * 1.05)\\n img, param = expand(img, out_h=out_h, out_w=out_w,\\n fill=self.value, return_param=True)\\n bbox = transforms.translate_bbox(\\n bbox, y_offset=param['y_offset'], x_offset=param['x_offset'])\\n\\n img, param = crop_with_bbox_constraints(\\n img, bbox, return_param=True,\\n crop_height=net_h, crop_width=net_w)\\n bbox, param = transforms.crop_bbox(\\n bbox, y_slice=param['y_slice'], x_slice=param['x_slice'],\\n allow_outside_center=False, return_param=True)\\n label = label[param['index']]\\n\\n\\n # 5. Random horizontal flipping # OK\\n img, params = transforms.random_flip(\\n img, x_random=True, return_param=True)\\n bbox = transforms.flip_bbox(\\n bbox, self.output_shape, x_flip=params['x_flip'])\\n\\n # Preparation for Yolov2 network\\n bbox[:, ::2] /= self.output_shape[0] # y\\n bbox[:, 1::2] /= self.output_shape[1] # x\\n\\n num_bbox = len(bbox)\\n len_max = max(num_bbox, self.max_target)\\n\\n gmap = create_map_anchor_gt(bbox, self.anchors, self.output_shape,\\n self.downscale, self.n_boxes, len_max)\\n\\n out_bbox = np.zeros((len_max, 4), dtype='f')\\n out_bbox[:num_bbox] = bbox[:num_bbox]\\n out_label = np.zeros((len_max), dtype='i')\\n out_label[:num_bbox] = label\\n\\n gmap = gmap[:self.max_target]\\n out_bbox = out_bbox[:self.max_target]\\n out_label = out_label[:self.max_target]\\n num_array = min(num_bbox, self.max_target)\\n\\n img = np.clip(img, 0, 1)\\n return img, out_bbox, out_label, gmap, np.array([num_array], dtype='i')\",\n \"def get_classification(self, image):\\n if self.correct_gamma:\\n if self.gamma == 1.0:\\n self.gamma = 0.6\\n elif self.gamma == 0.6:\\n self.gamma = 1.0\\n image = self.adjust_gamma(image, self.gamma)\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n image_np = np.asarray(image, dtype=\\\"uint8\\\")\\n image_np_expanded = np.expand_dims(image_np, axis=0)\\n\\n detected = False\\n\\n with self.detection_graph.as_default():\\n (boxes, scores, classes, num) = self.sess.run(\\n [self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections],\\n feed_dict={self.image_tensor: image_np_expanded})\\n boxes = np.squeeze(boxes)\\n classes = np.squeeze(classes).astype(np.int32)\\n scores = np.squeeze(scores)\\n best_scores = []\\n\\n for idx, classID in enumerate(classes):\\n if self.MODEL_NAME == 'ssdlite_mobilenet_v2_coco_2018_05_09':\\n if classID == 10: # 10 is traffic light\\n if scores[idx] > 0.10: #confidence level\\n best_scores.append([scores[idx], idx, classID])\\n detected = True\\n else: # we tuned the model to classify only traffic lights\\n if scores[idx] > 0.10: # confidence level\\n best_scores.append([scores[idx], idx, classID])\\n detected = True\\n\\n tl_index = TrafficLight.UNKNOWN\\n if detected:\\n best_scores.sort(key=lambda tup: tup[0], reverse=True)\\n\\n best_score = best_scores[0]\\n rospy.logdebug(\\\"number of TL found %d, best score: %f, color: %f\\\", len(best_scores), best_score[0], best_score[2])\\n nbox = boxes[best_score[1]]\\n\\n height = image.shape[0]\\n width = image.shape[1]\\n\\n box = np.array([nbox[0]*height, nbox[1]*width, nbox[2]*height, nbox[3]*width]).astype(int)\\n box_height = box[2] - box[0]\\n box_width = box[3] - box[1]\\n ratio = float(box_height)/float(box_width)\\n rospy.logdebug(\\\"ratio: %f\\\", ratio)\\n if ratio >= 2.0 and ratio < 3.0: #started from 2.4\\n tl_cropped = image[box[0]:box[2], box[1]:box[3]]\\n tl_color, tl_index = self.get_color(tl_cropped)\\n #color = ['RED', 'YELLOW', 'GREEN', 'UNKNOWN']\\n #tl_index = best_score[2]\\n #tl_color = color[tl_index]\\n #augment image with detected TLs\\n cv2.rectangle(image, (box[1], box[0]), (box[3], box[2]), (0, 255, 0), 2)\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n font_color = (255, 255, 255)\\n cv2.putText(image, tl_color, (box[1], box[0]), font, 2.0, font_color, lineType=cv2.LINE_AA)\\n return image, tl_index\",\n \"def generate_maps(dl: DatasetLoader, model, map_out: str, graph, all_classes=True, batch_size=10, mode='cv2'):\\n # o_generator = get_outputs_generator(model, 'CAM')\\n input = model.input\\n output = model.get_layer('CAM').output\\n output_predict = model.get_layer('W').output\\n output_fn = K.function([input], [output])\\n fn_predict = K.function([input], [output_predict])\\n\\n o_resizer = tf.image.resize_images\\n o_dot = K.dot\\n\\n # plot CAMs only for the validation data:\\n k = 0\\n counter = 0\\n img_arr = []\\n with K.get_session() as sess:\\n in_place = tf.placeholder(tf.float32, [None, None, None, 512])\\n size_place = tf.placeholder(tf.int32, [2])\\n convert_place = tf.placeholder(tf.float32, [512, len(dl.directories)])\\n first_func = o_resizer(in_place, size_place, ResizeMethod.BICUBIC)\\n second_func = o_dot(in_place, convert_place)\\n graph.finalize()\\n\\n for i in range(dl.number_of_imgs_for_train, dl.number_of_imgs):\\n with graph.as_default() as gr:\\n if i == dl.number_of_imgs - 1:\\n k = batch_size - 1\\n rpath = dl.baseDirectory + \\\"/\\\" + dl.imgDataArray[i].directory + \\\"/\\\" + dl.imgDataArray[i].name\\n img = cv2.imread(rpath, cv2.IMREAD_COLOR)\\n # print('!!!!!!!!debug', rpath, i)\\n img_arr.append(img)\\n k += 1\\n if k == batch_size:\\n start_time = time.time()\\n predict_input = np.asarray(img_arr, dtype='float32')\\n predict_input = preprocess_input(predict_input)\\n\\n k = 0\\n img_arr = []\\n\\n layer_outputs = output_fn([predict_input])[0]\\n predictions = fn_predict([predict_input])[0]\\n\\n if mode == 'cv2': # model, layer_outputs, nb_classes, im_width=256):\\n maps_arr = cam_generate_cv2(model, layer_outputs, dl.nb_classes)\\n else:\\n maps_arr = cam_generate_tf_ops(model, layer_outputs, sess, first_func, second_func, in_place,\\n size_place,\\n convert_place)\\n\\n for l, prediction in enumerate(predictions):\\n inc = i - batch_size + l + 1\\n outpath = map_out + \\\"/\\\" + dl.imgDataArray[inc].directory + \\\"/\\\" + dl.imgDataArray[inc].name\\n # print('[DEBUG]', outpath, inc, i, batch_size, l)\\n\\n try:\\n os.makedirs(outpath)\\n except OSError:\\n continue\\n\\n value = np.argmax(prediction)\\n if all_classes:\\n a = 0\\n b = dl.nb_classes\\n else:\\n a = value\\n b = value + 1\\n for j in range(a, b):\\n outname = outpath + \\\"/\\\" + str(j) + '.tiff'\\n if mode == 'cv2':\\n Image.fromarray(maps_arr[l][j]).save(outname)\\n else:\\n Image.fromarray(maps_arr[l, :, :, j]).save(outname)\\n with open(outpath + '/resuts.json', 'w') as outfile:\\n json.dump({'predicted': str(value), \\\"true_label\\\": str(dl.imgDataArray[inc].img_class)},\\n outfile)\\n print(\\\"cam(\\\", counter, \\\"/\\\", dl.number_of_imgs_for_test, \\\"completed\\\")\\n counter += 1\\n print(\\\"got cams in\\\", time.time() - start_time)\",\n \"def augment():\\n print(\\\"augmenting......\\\")\\n path1 = '../trainp1/'\\n path2 = '../trainp2/'\\n # path of pair1 and pair2 similar to img & mask task for segmentation\\n p = Augmentor.Pipeline(path1) # pair1\\n p.ground_truth(path2) # pair2\\n p.rotate(probability=0.3, max_left_rotation=3, max_right_rotation=3) \\n p.flip_left_right(probability=0.2) \\n p.random_distortion(0.5, 2, 2, 2)\\n p.zoom(probability=0.5, min_factor=0.95, max_factor=1.05)\\n p.process()\",\n \"def run_all_layers(self, img): # noqa\\n s1_outputs = [s1(img) for s1 in self.s1_units]\\n\\n # Each C1 layer pools across two S1 layers\\n c1_outputs = []\\n for c1, i in zip(self.c1_units, range(0, len(self.s1_units), 2)):\\n c1_outputs.append(c1(s1_outputs[i:i+2]))\\n\\n s2_outputs = [s2(c1_outputs) for s2 in self.s2_units]\\n c2_outputs = [c2(s2) for c2, s2 in zip(self.c2_units, s2_outputs)]\\n\\n return s1_outputs, c1_outputs, s2_outputs, c2_outputs\",\n \"def get_model(summary=False):\\n\\timage_input=Input(shape=(220,220,5),name='image_input')\\n\\tbranch1_conv1=Conv2D(64, kernel_size=(3, 3), border_mode='same', input_shape=(220,220,5), activation='relu')(image_input)\\n\\tbranch1_conv2=Conv2D(64, kernel_size=(1, 1), border_mode='same', activation='relu')(branch1_conv1)\\t\\n\\tbranch1_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch1_conv1)\\n\\tbranch2_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch1_pool1)\\n\\tbranch2_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch2_conv1)\\t\\n\\tbranch2_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch2_conv2)\\n\\tbranch3_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch2_pool1)\\n\\tbranch3_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch3_conv1)\\t\\n\\tbranch3_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch3_conv2)\\n\\tbranch4_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch3_pool1)\\n\\tbranch4_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch4_conv1)\\t\\n\\tbranch4_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch4_conv2)\\n\\tbranch5_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch4_pool1)\\n\\tbranch5_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch5_conv1)\\t\\n\\tbranch5_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch5_conv2)\\n\\tbranch6_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch5_pool1)\\n\\tbranch6_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch6_conv1)\\t\\n\\tbranch6_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch6_conv2)\\n\\tbranch1_flat=Flatten()(branch6_pool1)\\n\\tdrop=Dropout(.3)(branch1_flat)\\n\\t# FC layers group\\n\\tdense1=Dense(512, activation='relu', name='fc1')(drop)\\n\\tdrop1=Dropout(.3)(dense1)\\n\\tdense2=Dense(256, activation='relu', name='fc2')(drop1)\\n\\tdrop3=Dropout(.3)(dense2)\\n\\tout=Dense(2, activation='softmax', name='fc4')(drop3)\\n\\tmodel=Model(inputs=image_input,outputs=out)\\n\\treturn model\",\n \"def train(args):\\n # Create the data loader\\n loader = sunnerData.DataLoader(\\n dataset = sunnerData.ImageDataset(\\n root = [[args.train]],\\n transforms = transforms.Compose([\\n \\n# transforms.RandomCrop(720,720)\\n# transforms.RandomRotation(45)\\n# transforms.RandomHorizontalFlip(), \\n# transforms.ColorJitter(brightness=0.5, contrast=0.5),\\n \\n\\n sunnerTransforms.Resize(output_size = (args.H, args.W)),\\n #transforms.RandomCrop(512,512)\\n sunnerTransforms.ToTensor(),\\n sunnerTransforms.ToFloat(),\\n # sunnerTransforms.Transpose(),\\n sunnerTransforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),\\n ])\\n ), batch_size = args.batch_size, shuffle = True, num_workers = 2\\n )\\n loader = sunnerData.IterationLoader(loader, max_iter = args.n_iter)\\n\\n # Create the model\\n model = GANomaly2D(r = args.r, device = args.device)\\n model.IO(args.resume, direction = 'load')\\n model.train()\\n \\n # Train!\\n bar = tqdm(loader)\\n for i, (normal_img,) in enumerate(bar):\\n model.forward(normal_img)\\n model.backward()\\n loss_G, loss_D = model.getLoss()\\n bar.set_description(\\\"Loss_G: \\\" + str(loss_G) + \\\" loss_D: \\\" + str(loss_D))\\n bar.refresh()\\n if i % args.record_iter == 0:\\n model.eval()\\n with torch.no_grad():\\n z, z_ = model.forward(normal_img)\\n img, img_ = model.getImg()\\n visualizeEncoderDecoder(img, img_, z, z_,i)\\n model.train()\\n model.IO(args.det, direction = 'save')\\n model.IO(args.det, direction = 'save')\",\n \"def image_to_feature(image_full_path, boundingBox, encoder, features_to_use, autocrop=False):\\n imgcrop = rgb_image_bounding_box(image_full_path, boundingBox, autocrop=autocrop)\\n imgresize = cv2.resize(imgcrop, (128, 128))\\n imgresize = imgresize / 255.\\n imgresize = imgresize.astype('float32')\\n encoded_image = encoder.predict(imgresize[None, :, :, :])\\n # print(input_img.shape)\\n grayscale = cv2.cvtColor(imgresize, cv2.COLOR_BGR2GRAY)\\n fd = hog(grayscale, orientations=4, pixels_per_cell=(16, 16), cells_per_block=(1, 1), visualise=False)\\n fd = fd / np.max(fd)\\n encoded_image = encoded_image / np.max(encoded_image)\\n hsv_img = cv2.cvtColor(imgcrop, cv2.COLOR_BGR2HSV)\\n hsv_hlist = []\\n num_h_elements = np.prod(hsv_img.shape[:2])\\n for channel, (range, nbins) in enumerate(zip([180, 255, 255], [10, 4, 4])): # unsure if ch1 is 180 or 360\\n hsv_h, bins = np.histogram(hsv_img[:, :, channel], range=(0, range), bins=nbins)\\n hsv_hlist.append(hsv_h / num_h_elements)\\n hsv = np.concatenate(hsv_hlist, axis=0)\\n if features_to_use == \\\"All\\\":\\n fv = np.concatenate((fd, hsv, encoded_image.ravel()))\\n elif features_to_use == \\\"encoder\\\":\\n fv = encoded_image.ravel()\\n elif features_to_use == \\\"hog\\\":\\n fv = fd\\n elif features_to_use == \\\"hsv\\\":\\n fv = hsv\\n return fv\",\n \"def mgcNetArchRes(outLayer, l2_val, **kwargs):\\n\\n def_vals = {\\\"input_img_rows\\\" : 72,\\n \\\"input_img_cols\\\" : 72,\\n \\\"channels\\\" : 1,\\n \\\"nb_classes\\\" : 13\\n } # default parameters value\\n\\n for k, v in def_vals.items():\\n kwargs.setdefault(k, v)\\n\\n input_img_rows = kwargs['input_img_rows']\\n input_img_cols = kwargs['input_img_cols']\\n channels = kwargs['channels']\\n nb_classes = kwargs['nb_classes']\\n\\n \\n # Input: 72 x 72 x 1\\n img_shape = layers.Input(shape = (input_img_rows, input_img_cols, channels))\\n\\n # Layer 1\\n #------------------------\\n conv1 = layers.Conv2D(filters=32, kernel_size=(2, 2), padding='same', kernel_regularizer=regularizers.l2(l2_val))(img_shape)\\n conv1 = layers.Activation('relu')(conv1)\\n conv1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)\\n conv1 = layers.Dropout(0.4)(conv1)\\n \\n conv1 = residual_block(img_shape, 32, _strides=(1, 1), _project_shortcut=False)\\n\\n # Layer 2\\n #------------------------\\n conv2 = residual_block(conv1, 32, _strides=(1, 1), _project_shortcut=False)\\n\\n # Layer 3\\n #------------------------\\n conv3 = residual_block(conv2, 32, _strides=(1, 1), _project_shortcut=False)\\n \\n # Layer 4\\n # -----------------------\\n #residual = residual_block(conv3, 64, _strides=(1, 1), _project_shortcut=False)\\n\\n # Layer 5\\n #------------------------\\n output = layers.Conv2D(filters=128, kernel_size=(2,2), padding='same', kernel_regularizer=regularizers.l2(l2_val))(conv3) # skip layer 4\\n output = layers.Activation('relu')(output)\\n output = layers.Conv2D(filters=64, kernel_size=(2,2), padding='same', activation='relu', strides = 2)(output) \\n output = layers.Dropout(0.4)(output)\\n\\n\\n \\n # FC Layer\\n #------------------------\\n outputmlp = layers.Flatten()(output)\\n outputmlp = layers.Dense(64, activation = 'relu')(outputmlp)\\n outputmlp = layers.Dropout(0.5)(outputmlp)\\n\\n predictionsMlp = layers.Dense(nb_classes, activation='softmax')(outputmlp)\\n \\n \\n # global averaging\\n weight_decay=1E-4\\n concat_axis = 1\\n \\n x = BatchNormalization(axis=concat_axis,\\n gamma_regularizer=regularizers.l2(weight_decay),\\n beta_regularizer=regularizers.l2(weight_decay))(output)\\n x = Activation('relu')(x)\\n x = layers.Dropout(0.4)(x)\\n x = GlobalAveragePooling2D(data_format=K.image_data_format())(x)\\n \\n predictionsGloAvg = layers.Dense(nb_classes,\\n activation='softmax',\\n kernel_regularizer=regularizers.l2(weight_decay),\\n bias_regularizer=regularizers.l2(weight_decay))(x)\\n \\n if outLayer == \\\"gloAvg\\\":\\n predictions = predictionsGloAvg\\n elif outLayer == \\\"mlp\\\":\\n predictions = predictionsMlp\\n \\n # prediction model\\n model = Model(img_shape, predictions, name = 'resblock')\\n\\n return model\",\n \"def mgcNetArchMax(outLayer, l2_val, **kwargs):\\n\\n def_vals = {\\\"input_img_rows\\\" : 72,\\n \\\"input_img_cols\\\" : 72,\\n \\\"channels\\\" : 1,\\n \\\"nb_classes\\\" : 13\\n } # default parameters value\\n\\n for k, v in def_vals.items():\\n kwargs.setdefault(k, v)\\n\\n input_img_rows = kwargs['input_img_rows']\\n input_img_cols = kwargs['input_img_cols']\\n channels = kwargs['channels']\\n nb_classes = kwargs['nb_classes']\\n\\n \\n # Input: 72 x 72 x 1\\n img_shape = layers.Input(shape = (input_img_rows, input_img_cols, channels))\\n\\n # Layer 1\\n #------------------------\\n conv1 = layers.Conv2D(filters=32, kernel_size=(2, 2), padding='same', kernel_regularizer=regularizers.l2(l2_val))(img_shape)\\n conv1 = layers.Activation('relu')(conv1)\\n conv1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)\\n conv1 = layers.Dropout(0.4)(conv1)\\n\\n # Layer 2\\n #------------------------\\n conv2 = layers.Conv2D(filters=64, kernel_size=(2,2), padding='same', kernel_regularizer=regularizers.l2(l2_val))(conv1)\\n conv2 = layers.Activation('relu')(conv2) \\n conv2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)\\n conv2 = layers.Dropout(0.4)(conv2)\\n\\n # Layer 3\\n #------------------------\\n conv3 = layers.Conv2D(filters=128, kernel_size=(2,2), padding='same', kernel_regularizer=regularizers.l2(l2_val))(conv2)\\n conv3 = layers.Activation('relu')(conv3) \\n conv3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)\\n conv3 = layers.Dropout(0.4)(conv3)\\n\\n # Layer 4\\n #------------------------\\n conv4 = layers.Conv2D(filters=256, kernel_size=(2,2), padding='same', dilation_rate = (2, 2), kernel_regularizer=regularizers.l2(l2_val))(conv3)\\n conv4 = layers.Activation('relu')(conv4)\\n conv4 = layers.MaxPooling2D(pool_size=(2, 2))(conv4)\\n conv4 = layers.Dropout(0.4)(conv4)\\n\\n # Layer 5\\n #------------------------\\n output = layers.Conv2D(filters=128, kernel_size=(2,2), padding='same', kernel_regularizer=regularizers.l2(l2_val))(conv3) # skip layer 4\\n output = layers.Activation('relu')(output) \\n output = layers.MaxPooling2D(pool_size=(2, 2))(output)\\n output = layers.Dropout(0.4)(output)\\n\\n\\n \\n # FC Layer\\n #------------------------\\n outputmlp = layers.Flatten()(output)\\n outputmlp = layers.Dense(64, activation = 'relu')(outputmlp)\\n outputmlp = layers.Dropout(0.5)(outputmlp)\\n\\n predictionsMlp = layers.Dense(nb_classes, activation='softmax')(outputmlp)\\n \\n \\n # global averaging\\n weight_decay=1E-4\\n concat_axis = 1\\n \\n x = BatchNormalization(axis=concat_axis,\\n gamma_regularizer=regularizers.l2(weight_decay),\\n beta_regularizer=regularizers.l2(weight_decay))(output)\\n x = Activation('relu')(x)\\n x = layers.Dropout(0.4)(x)\\n x = GlobalAveragePooling2D(data_format=K.image_data_format())(x)\\n \\n predictionsGloAvg = layers.Dense(nb_classes,\\n activation='softmax',\\n kernel_regularizer=regularizers.l2(weight_decay),\\n bias_regularizer=regularizers.l2(weight_decay))(x)\\n \\n if outLayer == \\\"gloAvg\\\":\\n predictions = predictionsGloAvg\\n elif outLayer == \\\"mlp\\\":\\n predictions = predictionsMlp\\n \\n # prediction model\\n model = Model(img_shape, predictions, name = 'cnn_max')\\n\\n return model\",\n \"def get_classification(self, image):\\n\\n image_np_expanded = np.expand_dims(image, axis=0)\\n\\n # Perform network inference\\n with self.detection_graph.as_default():\\n (boxes, scores, classes, num) = self.sess.run(\\n [self.detection_boxes, self.detection_scores,\\n self.detection_classes, self.num_detections],\\n feed_dict={self.image_tensor: image_np_expanded})\\n\\n boxes = np.squeeze(boxes)\\n scores = np.squeeze(scores)\\n classes = np.squeeze(classes).astype(np.int32)\\n\\n if self.RUNNING_ON_CARLA == True:\\n for i in range(boxes.shape[0]):\\n if scores is None or scores[i] > .05:\\n if classes[i] == 10:\\n classname = self.category_index[classes[i]]['name']\\n print(classname, scores[i])\\n\\n # Extract image from best bounding box and pass through light classifier\\n ymin, xmin, ymax, xmax = boxes[i]\\n im_height, im_width, im_depth = image.shape\\n (left, right, top, bottom) = (xmin * im_width, xmax * im_width, ymin * im_height, ymax * im_height)\\n tf_image_cropped = image[int(top):int(bottom), int(left):int(right), :]\\n\\n PILImage = Image.fromarray(tf_image_cropped)\\n resized_img = PILImage.resize((85, 256), Image.ANTIALIAS)\\n image_np_resized = self.load_image_into_numpy_array(resized_img)\\n x = np.expand_dims(image_np_resized, axis=0)\\n x = np.vstack([x])\\n\\n #model = load_model('tf_classifier_1.h5')\\n #model.compile(loss='categorical_crossentropy',\\n # optimizer='adam',\\n # metrics=['accuracy'])\\n classes = self.keras_model.predict_classes(x, batch_size=1)\\n print(classes)\\n\\n if classes[0] == 0:\\n self.current_light = TrafficLight.GREEN\\n elif classes[0] == 2:\\n self.current_light = TrafficLight.YELLOW\\n else:\\n self.current_light = TrafficLight.RED\\n\\n break\\n\\n else:\\n # Check the detections. If it has a good score\\n # then set the current light to the detected label. The\\n # first one is always the best (they are returned sorted \\n # in score order).\\n # Note that we have trained for 14 categories, including\\n # left/right arrows etc. Here we are only looking for \\n # standard red, yellow and green light and ignore others.\\n for i in range(boxes.shape[0]):\\n if scores is None or scores[i] > .05:\\n classname = self.category_index[classes[i]]['name']\\n print(classname, scores[i])\\n\\n if classname == 'Green':\\n self.current_light = TrafficLight.GREEN\\n elif classname == 'Yellow':\\n self.current_light = TrafficLight.YELLOW\\n elif classname == 'Red':\\n self.current_light = TrafficLight.RED\\n else:\\n self.current_light = TrafficLight.UNKNOWN\\n\\n break\\n\\n return self.current_light\",\n \"def build_cnn(input_var=None):\\n\\n # input layer\\n network = lasagne.layers.InputLayer(\\n shape=(\\n None,\\n 1,\\n 128,\\n 129\\n ),\\n input_var=input_var\\n )\\n\\n # conv\\n network = lasagne.layers.Conv2DLayer(\\n lasagne.layers.batch_norm(network), # Batch norm on incoming\\n num_filters=32, # Number of convolution filters to use\\n filter_size=(5, 5),\\n stride=(1, 1), # Stride fo (1,1)\\n pad='same', # Keep output size same as input\\n nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\\n W=lasagne.init.GlorotUniform() # W initialization\\n )\\n\\n # conv\\n #network = lasagne.layers.Conv2DLayer(\\n #lasagne.layers.batch_norm(network), # Batch norm on incoming\\n #num_filters=32, # Number of convolution filters to use\\n #filter_size=(5, 5),\\n #stride=(1, 1), # Stride fo (1,1)\\n #pad='same', # Keep output size same as input\\n #nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\\n #W=lasagne.init.GlorotUniform() # W initialization\\n #)\\n\\n # pool (2x2 max pool)\\n network = lasagne.layers.MaxPool2DLayer(\\n network, pool_size=(2, 2)\\n )\\n\\n # conv\\n network = lasagne.layers.Conv2DLayer(\\n lasagne.layers.batch_norm(network), # Batch norm on incoming\\n num_filters=32, # Number of convolution filters to use\\n filter_size=(3, 3),\\n stride=(1, 1), # Stride fo (1,1)\\n pad='same', # Keep output size same as input\\n nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\\n W=lasagne.init.GlorotUniform() # W initialization\\n )\\n\\n # conv\\n #network = lasagne.layers.Conv2DLayer(\\n #lasagne.layers.batch_norm(network), # Batch norm on incoming\\n #num_filters=32, # Number of convolution filters to use\\n #filter_size=(3, 3),\\n #stride=(1, 1), # Stride fo (1,1)\\n #pad='same', # Keep output size same as input\\n #nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\\n #W=lasagne.init.GlorotUniform() # W initialization\\n #)\\n\\n # pool (2x2 max pool)\\n network = lasagne.layers.MaxPool2DLayer(\\n network, pool_size=(2, 2)\\n )\\n\\n # Fully-connected layer of 256 units with 50% dropout on its inputs\\n network = lasagne.layers.DenseLayer(\\n lasagne.layers.dropout(network, p=.5),\\n num_units=256,\\n nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\\n W=lasagne.init.HeUniform() # W initialization\\n )\\n\\n # Finally add a 1-unit softmax output layer\\n network = lasagne.layers.DenseLayer(\\n network,\\n num_units=1,\\n nonlinearity=lasagne.nonlinearities.sigmoid\\n )\\n\\n return network\",\n \"def extract_anisotropy_features (Parameters, image, mask=None):\\n \\n data_inputs = {}\\n \\n Ka, Kb, Kc = Parameters.kA, Parameters.kB, Parameters.kC\\n \\n \\n h, w, channels = image.shape\\n \\n if channels == 2:\\n channel_types = [\\\"Para\\\", \\\"Perp\\\"]\\n elif channels == 3:\\n channel_types = [\\\"Open\\\", \\\"Para\\\", \\\"Perp\\\"]\\n \\n \\n for index, channel in enumerate(channel_types):\\n \\n data_inputs[channel] = np.sum(image[:,:, index])/np.count_nonzero(image[:,:, index])\\n\\n\\n #Additional parameters\\n para_value = data_inputs['Para']\\n perp_value = data_inputs['Perp']\\n data_inputs['AniAvg'] = (para_value - perp_value)/(para_value + 2*perp_value)\\n \\n #With corrections\\n data_inputs['Ix'] = Ix = ((Ka+Kb)*perp_value - (Ka+Kc)*para_value)/(Ka*Kb + Kb*Kb - Ka*Kc - Kc*Kc)\\n data_inputs['Iy'] = Iy = (Kb*para_value - Kc*perp_value)/(Ka*Kb + Kb*Kb - Ka*Kc - Kc*Kc)\\n data_inputs['AniAvg'] = (Ix - Iy)/(Ix + 2*Iy)\\n \\n\\n \\n return (data_inputs)\",\n \"def build(self, mode, config):\\n assert mode in ['training', 'inference']\\n\\n # Image size must be dividable by 2 multiple times\\n h, w = config.IMAGE_SHAPE[:2]\\n if h / 2**6 != int(h / 2**6) or w / 2**6 != int(w / 2**6):\\n raise Exception(\\\"Image size must be dividable by 2 at least 6 times \\\"\\n \\\"to avoid fractions when downscaling and upscaling.\\\"\\n \\\"For example, use 256, 320, 384, 448, 512, ... etc. \\\")\\n\\n # Inputs\\n input_image = KL.Input(\\n shape=[None, None, 3], name=\\\"input_image\\\")\\n input_image_meta = KL.Input(shape=[config.IMAGE_META_SIZE],\\n name=\\\"input_image_meta\\\")\\n if mode == \\\"training\\\":\\n pass\\n elif mode == \\\"inference\\\":\\n # Anchors in normalized coordinates\\n input_anchors = KL.Input(shape=[None, 4], name=\\\"input_anchors\\\")\\n\\n # Build the shared convolutional layers.\\n # Bottom-up Layers\\n # Returns a list of the last layers of each stage, 5 in total.\\n # Don't create the thead (stage 5), so we pick the 4th item in the list.\\n _, C2, C3, C4, C5 = resnet_graph(input_image, config.BACKBONE,\\n stage5=True, train_bn=config.TRAIN_BN)\\n # Top-down Layers\\n # TODO: add assert to varify feature map sizes match what's in config\\n P5 = KL.Conv2D(256, (1, 1), name='fpn_c5p5')(C5)\\n P4 = KL.Add(name=\\\"fpn_p4add\\\")([\\n KL.UpSampling2D(size=(2, 2), name=\\\"fpn_p5upsampled\\\")(P5),\\n KL.Conv2D(256, (1, 1), name='fpn_c4p4')(C4)])\\n P3 = KL.Add(name=\\\"fpn_p3add\\\")([\\n KL.UpSampling2D(size=(2, 2), name=\\\"fpn_p4upsampled\\\")(P4),\\n KL.Conv2D(256, (1, 1), name='fpn_c3p3')(C3)])\\n P2 = KL.Add(name=\\\"fpn_p2add\\\")([\\n KL.UpSampling2D(size=(2, 2), name=\\\"fpn_p3upsampled\\\")(P3),\\n KL.Conv2D(256, (1, 1), name='fpn_c2p2')(C2)])\\n # Attach 3x3 conv to all P layers to get the final feature maps.\\n P2 = KL.Conv2D(256, (3, 3), padding=\\\"SAME\\\", name=\\\"fpn_p2\\\")(P2)\\n P3 = KL.Conv2D(256, (3, 3), padding=\\\"SAME\\\", name=\\\"fpn_p3\\\")(P3)\\n P4 = KL.Conv2D(256, (3, 3), padding=\\\"SAME\\\", name=\\\"fpn_p4\\\")(P4)\\n P5 = KL.Conv2D(256, (3, 3), padding=\\\"SAME\\\", name=\\\"fpn_p5\\\")(P5)\\n # P6 is used for the 5th anchor scale in RPN. Generated by\\n # subsampling from P5 with stride of 2.\\n P6 = KL.MaxPooling2D(pool_size=(1, 1), strides=2, name=\\\"fpn_p6\\\")(P5)\\n\\n # Note that P6 is used in RPN, but not in the classifier heads.\\n rpn_feature_maps = [P2, P3, P4, P5, P6]\\n mrcnn_feature_maps = [P2, P3, P4, P5]\\n\\n # Anchors\\n if mode == \\\"training\\\":\\n anchors = self.get_anchors(config.IMAGE_SHAPE)\\n # Duplicate across the batch dimension because Keras requires it\\n # TODO: can this be optimized to avoid duplicating the anchors?\\n anchors = np.broadcast_to(anchors, (config.BATCH_SIZE,) + anchors.shape)\\n # A hack to get around Keras's bad support for constants\\n anchors = KL.Lambda(lambda x: tf.Variable(anchors), name=\\\"anchors\\\")(input_image)\\n else:\\n anchors = input_anchors\\n\\n # RPN Model\\n rpn = build_rpn_model(config.RPN_ANCHOR_STRIDE,\\n len(config.RPN_ANCHOR_RATIOS), 256)\\n # Loop through pyramid layers\\n layer_outputs = [] # list of lists\\n for p in rpn_feature_maps:\\n layer_outputs.append(rpn([p]))\\n # Concatenate layer outputs\\n # Convert from list of lists of level outputs to list of lists\\n # of outputs across levels.\\n # e.g. [[a1, b1, c1], [a2, b2, c2]] => [[a1, a2], [b1, b2], [c1, c2]]\\n output_names = [\\\"rpn_class_logits\\\", \\\"rpn_class\\\", \\\"rpn_bbox\\\"]\\n outputs = list(zip(*layer_outputs))\\n outputs = [KL.Concatenate(axis=1, name=n)(list(o))\\n for o, n in zip(outputs, output_names)]\\n\\n rpn_class_logits, rpn_class, rpn_bbox = outputs\\n\\n # Generate proposals\\n # Proposals are [batch, N, (y1, x1, y2, x2)] in normalized coordinates\\n # and zero padded.\\n proposal_count = config.POST_NMS_ROIS_TRAINING if mode == \\\"training\\\"\\\\\\n else config.POST_NMS_ROIS_INFERENCE\\n rpn_rois = ProposalLayer(\\n proposal_count=proposal_count,\\n nms_threshold=config.RPN_NMS_THRESHOLD,\\n name=\\\"ROI\\\",\\n config=config)([rpn_class, rpn_bbox, anchors])\\n\\n if mode == \\\"training\\\":\\n pass\\n else:\\n # Network Heads\\n # Proposal classifier and BBox regressor heads\\n mrcnn_class_logits, mrcnn_class, mrcnn_bbox =\\\\\\n fpn_classifier_graph(rpn_rois, mrcnn_feature_maps, input_image_meta,\\n config.POOL_SIZE, config.NUM_CLASSES,\\n train_bn=config.TRAIN_BN)\\n\\n # Detections\\n # output is [batch, num_detections, (y1, x1, y2, x2, class_id, score)] in \\n # normalized coordinates\\n detections = DetectionLayer(config, name=\\\"mrcnn_detection\\\")(\\n [rpn_rois, mrcnn_class, mrcnn_bbox, input_image_meta])\\n\\n # Create masks for detections\\n detection_boxes = KL.Lambda(lambda x: x[..., :4])(detections)\\n mrcnn_mask = build_fpn_mask_graph(detection_boxes, mrcnn_feature_maps,\\n input_image_meta,\\n config.MASK_POOL_SIZE,\\n config.NUM_CLASSES,\\n train_bn=config.TRAIN_BN)\\n\\n model = KM.Model([input_image, input_image_meta, input_anchors],\\n [detections, mrcnn_class, mrcnn_bbox,\\n mrcnn_mask, rpn_rois, rpn_class, rpn_bbox],\\n name='mask_rcnn')\\n\\n return model\",\n \"def __call__(\\n self,\\n image: np.ndarray,\\n f_keep_pixels: float = 0,\\n f_keep_colored_pixels: float = 0,\\n ) -> np.ndarray:\\n # Store shape\\n h, w, c = image.shape\\n\\n img_np = image\\n\\n # Apply transformations\\n image: torch.Tensor = self.transform(Image.fromarray(image))\\n image = image.to(self.device)\\n\\n # Copy the numpy array because it's not writeable otherwise\\n # Bring into shape [1,1,h,w]\\n image.unsqueeze_(0)\\n\\n # Inference\\n result = self.model.networks.g_b_to_a.forward(image).detach()\\n\\n # From [-1,1] to [0,256]\\n result = tensor2im(result, to_rgb=False)\\n\\n # Resize to the size the input image has\\n result = cv2.resize(result, dsize=(w, h), interpolation=cv2.INTER_LINEAR)\\n\\n if f_keep_pixels > 0:\\n grey_img = cv2.cvtColor(img_np, cv2.COLOR_BGR2GRAY)\\n colored_pxls = f_keep_pixels * np.ones((h, w))\\n\\n result = (1 - f_keep_pixels) * result + f_keep_pixels * grey_img\\n\\n if f_keep_colored_pixels > 0:\\n grey_img = cv2.cvtColor(img_np, cv2.COLOR_BGR2GRAY)\\n colored_pxls = f_keep_colored_pixels * np.ones((h, w))\\n colored_pxls[img_np[:, :, 0] == img_np[:, :, 1]] = 0\\n\\n result = (\\n np.ones_like(colored_pxls) - colored_pxls\\n ) * result + colored_pxls * grey_img\\n\\n return result.astype(np.uint8)\",\n \"def _recognition_network(self):\\n last_input = tf_build_architecture(self.architecture,\\n batch_in=self.x_shaped,\\n scope_prefix=\\\"recognize\\\",\\n variables_collection=self.training_scope,\\n data_format=self.data_format)\\n\\n last_input = tf_ensure_flat(last_input)\\n\\n # The hidden layers are ready - now build the last two, first reshaping the last layer, if needed\\n z_mean = tf_dense_layer(\\\"latent_mean\\\", last_input,\\n params={ 'size':self.output_size, 'func': None },\\n variables_collection=self.training_scope)\\n\\n z_log_sigma_sq = tf_dense_layer(\\\"latent_log_sigma_sq\\\", last_input,\\n params={ 'size': self.output_size, 'func': None },\\n variables_collection=self.training_scope)\\n return z_mean, z_log_sigma_sq\",\n \"def _part_generate_repr(img, steps, params, featsel, filt_l, legacy=True, debug=False):\\n\\n assert img.ndim == 2 or img.ndim == 3, \\\"must be gray or RGB\\\"\\n\\n if 'preproc_resize' in steps:\\n img = _preproc_resize(img, params['preproc']['max_edge'], legacy)\\n orig_imga = img.copy()\\n if debug:\\n print(\\\"orig_imga, mean {}, std {}\\\".format(orig_imga.mean(), orig_imga.std()))\\n # convert image into gray scale, 2 dim array.\\n response = img\\n # this is the established way to deal with images for legacy behavior.\\n if legacy:\\n response = img.astype(np.float32) / 255.0\\n\\n if response.ndim == 3:\\n response = 0.2989 * response[:, :, 0] + 0.5870 * response[:, :, 1] + 0.1140 * response[:, :, 2]\\n\\n assert response.ndim == 2, \\\"must be two channels!\\\"\\n # in case we still have float64 dtype, in the case of non legacy\\n response = response.astype(np.float32, copy=True)\\n assert response.dtype == np.float32\\n if debug:\\n print(\\\"imga0, mean {}, std {}\\\".format(response.mean(), response.std()))\\n\\n if 'preproc_lowpass' in steps:\\n response = _preproc_lowpass(response, params['preproc']['lsum_ksize'], legacy)\\n imga0 = response.copy()\\n if debug:\\n print(\\\"imga0 normalized, mean {}, std {}\\\".format(imga0.mean(), imga0.std()))\\n\\n if 'normin' in steps:\\n response = _normin(response, params['normin'], legacy)\\n imga1 = response.copy()\\n if debug:\\n print(\\\"imga1, shape{}, mean {}, std {}\\\".format(imga1.shape, imga1.mean(), imga1.std()))\\n\\n if 'filter' in steps:\\n response = _filter(response, filt_l, legacy, mode=params['filter']['mode'])\\n else:\\n response = response[:, :, np.newaxis]\\n # make sure it's 3d.\\n assert response.ndim == 3, \\\"must have a 3d response array\\\"\\n imga2 = response.copy()\\n if debug:\\n print(\\\"imga2, shape {}, mean {}, std {}\\\".format(imga2.shape, imga2.mean(), imga2.std()))\\n\\n if 'activ' in steps:\\n # 'type': 'clamp', # can also be `square`, `exp`, `recsquare`, `rec`\\n response = _activ(response, params['activ'])\\n imga3 = response.copy()\\n if debug:\\n print(\\\"imga3, shape {}, mean {}, std {}\\\".format(imga3.shape, imga3.mean(), imga3.std()))\\n\\n if 'normout' in steps:\\n response = _normin(response, params['normout'], legacy)\\n imga4 = response.copy()\\n if debug:\\n print(\\\"imga4, shape {}, mean {}, std {}\\\".format(imga4.shape, imga4.mean(), imga4.std()))\\n\\n if 'dimr' in steps:\\n response = _dimr(response, params['dimr']['lsum_ksize'], params['dimr']['outshape'], legacy)\\n if debug:\\n print(\\\"output, shape {}, mean {}, std {}\\\".format(response.shape, response.mean(), response.std()))\\n images = {'imga0': imga0,\\n 'imga1': imga1,\\n 'imga2': imga2,\\n 'imga3': imga3,\\n 'imga4': imga4,\\n 'orig_imga': orig_imga}\\n\\n # handle additional features.\\n # pure legacy functions.\\n fvector = handle_feature_selection(response, images, featsel)\\n return fvector\",\n \"def main():\\n labels, data = load_image_data()\\n print(labels.shape, data.shape)\",\n \"def arch(self, nn) -> 'final node of the tensor flow graph (y_conv)':\\n\\n print(self)\\n\\n # first conv. layer \\n # 5x5 filter, 1 input channel, 32 output channels\\n W_conv1 = nn.weight_variable([5, 5, 1, 32])\\n b_conv1 = nn.bias_variable([32])\\n stride1 = 1\\n h_conv1 = tf.nn.relu(nn.conv2d(nn.x_image, W_conv1, stride1, 'VALID') + b_conv1) \\n # outputs a 24x24x32 image\\n \\n # first pooling layer (2x2) \\n h_pool1 = nn.max_pool_2x2(h_conv1) \\n # outputs a 12x12x32 image\\n\\n # second conv. layer \\n # 3x3 filter, 32 input channel, 32 output channels\\n W_conv2 = nn.weight_variable([3, 3, 32, 32])\\n b_conv2 = nn.bias_variable([32])\\n stride2 = 1\\n h_conv2 = tf.nn.relu(nn.conv2d(h_pool1, W_conv2, stride2, 'VALID') + b_conv2)\\n # outputs a 10x10x32 image\\n\\n # third conv. layer\\n # 3x3 filter, 32 input channel, 32 output channels\\n W_conv3 = nn.weight_variable([3, 3, 32, 32])\\n b_conv3 = nn.bias_variable([32])\\n stride3 = 1\\n h_conv3 = tf.nn.relu(nn.conv2d(h_conv2, W_conv3, stride3, 'VALID') + b_conv3)\\n # outputs a 8x8x32 image\\n\\n # reshape (flatten) output\\n h_conv3_flat = tf.reshape(h_conv3, [-1, 8*8*32])\\n\\n # first fully connected layer\\n W_fc1 = nn.weight_variable([8 * 8 * 32, 1024])\\n b_fc1 = nn.bias_variable([1024])\\n h_fc1 = tf.nn.relu(tf.matmul(h_conv3_flat, W_fc1) + b_fc1)\\n\\n # dropout\\n h_fc1_drop = tf.nn.dropout(h_fc1, nn.keep_prob)\\n\\n # second (final) fully connected layer (softmax)\\n W_fc2 = nn.weight_variable([1024, 10])\\n b_fc2 = nn.bias_variable([10])\\n y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)\\n\\n return y_conv\",\n \"def network_process(images, exposures, gains):\\n\\t\\t\\n\\t# Getting the images\\n\\timage1 = images[2]\\n\\timage2 = images[1]\\n\\timage3 = images[0]\\n\\t\\n\\t# Resizing\\n\\timage1 = cv2.resize(image1, (image_width, image_height))\\n\\timage2 = cv2.resize(image2, (image_width, image_height))\\n\\timage3 = cv2.resize(image3, (image_width, image_height))\\n\\n\\t# Convert images to tensors for pytorch\\n\\timage1 = tensor(image1)\\n\\timage2 = tensor(image2)\\n\\timage3 = tensor(image3)\\n\\n\\t# print(\\\"Image 1: \\\", image1)\\n\\n\\t# Get exposure values\\n\\texposure1 = exposures[2]\\n\\texposure2 = exposures[1]\\n\\texposure3 = exposures[0]\\n\\n\\tgain1 = gains[2]\\n\\tgain2 = gains[1]\\n\\tgain3 = gains[0]\\n\\n\\t# Setting 75us and 30ms as the lower and upper limits of exposure respectively\\n\\tadjusted_exp1 = ((exposure1-75)/(30000-75))*(1)\\n\\tadjusted_exp2 = ((exposure2-75)/(30000-75))*(1)\\n\\tadjusted_exp3 = ((exposure3-75)/(30000-75))*(1)\\n\\n\\t# Setting 0 dB and 30 dB as the lower and upper limits of gain respectively\\n\\tadjusted_gain1 = (gain1/30)*(1)\\n\\tadjusted_gain2 = (gain2/30)*(1)\\n\\tadjusted_gain3 = (gain3/30)*(1)\\n\\n\\t# Create a single channel for the exposure and gain values\\n\\tones = torch.ones((1, image_height, image_width))\\n\\texposure_1 = ones*adjusted_exp1\\n\\texposure_2 = ones*adjusted_exp2\\n\\texposure_3 = ones*adjusted_exp3\\n\\n\\tgain_1 = ones*adjusted_gain1\\n\\tgain_2 = ones*adjusted_gain2\\n\\tgain_3 = ones*adjusted_gain3\\n\\n\\tparameter_1 = torch.cat((exposure_1, gain_1), 0)\\n\\tparameter_2 = torch.cat((exposure_2, gain_2), 0)\\n\\tparameter_3 = torch.cat((exposure_3, gain_3), 0)\\n\\n\\tnew_img1 = torch.cat((image1, parameter_1), 0)\\n\\tnew_img2 = torch.cat((image2, parameter_2), 0)\\n\\tnew_img3 = torch.cat((image3, parameter_3), 0)\\n\\n\\tim1_im2 = torch.cat((new_img1, new_img2), 0)\\n\\tcombined_images = torch.cat((im1_im2, new_img3),0)\\n\\tfinal_images = combined_images.unsqueeze(0).to(device)\\n\\n\\toutput = model.forward(final_images)\\n\\t\\n\\toutput_exposure = int(((output[:,0]-0)*29925)/1 + 75)\\n\\toutput_gain = float(((output[:,1]-0)*30)/1 + 0)\\n\\n\\treturn output_exposure, output_gain\",\n \"def demo(image, name):\\n\\n # Log.set_log_max_depth(5)\\n\\n image = normalise(image.astype(np.float32))\\n # noisy = add_noise(image, intensity=None, variance=0.1, sap=0, clip=False)\\n noisy = random_noise(image, mode=\\\"gaussian\\\", var=0.1, seed=0, clip=False)\\n noisier = random_noise(noisy, mode=\\\"gaussian\\\", var=0.1, seed=100, clip=False)\\n\\n generator = StandardFeatureGenerator(\\n include_corner_features=True,\\n include_scale_one=True,\\n include_fine_features=True,\\n include_spatial_features=True,\\n )\\n regressor = CBRegressor(\\n patience=16, loss='l1', learning_rate=0.002, max_num_estimators=4096\\n )\\n\\n it = ImageTranslatorFGR(feature_generator=generator, regressor=regressor)\\n\\n it.train(noisy, noisy, jinv=True)\\n n2s_denoised = it.translate(noisy)\\n\\n it.exclude_center_feature = False\\n it.train(noisier, noisy, jinv=False)\\n denoised = it.translate(noisy)\\n denoised_corrected = 2 * denoised - noisy\\n\\n # denoised2 = it.translate(it.translate(it.translate(denoised)))\\n denoised2 = it.translate(denoised)\\n\\n image = numpy.clip(image, 0, 1)\\n noisy = numpy.clip(noisy, 0, 1)\\n n2s_denoised = numpy.clip(n2s_denoised, 0, 1)\\n denoised_corrected = numpy.clip(denoised_corrected, 0, 1)\\n denoised2 = numpy.clip(denoised2, 0, 1)\\n\\n psnr_noisy = psnr(image, noisy)\\n ssim_noisy = ssim(image, noisy)\\n\\n psnr_n2s_denoised = psnr(image, n2s_denoised)\\n ssim_n2s_denoised = ssim(image, n2s_denoised)\\n\\n psnr_denoised = psnr(image, denoised)\\n ssim_denoised = ssim(image, denoised)\\n\\n psnr_denoised_corrected = psnr(image, denoised_corrected)\\n ssim_denoised_corrected = ssim(image, denoised_corrected)\\n\\n psnr_denoised2 = psnr(image, denoised2)\\n ssim_denoised2 = ssim(image, denoised2)\\n\\n print(\\\"noisy :\\\", psnr_noisy, ssim_noisy)\\n print(\\n \\\"denoised (classic_denoisers) :\\\",\\n psnr_n2s_denoised,\\n ssim_n2s_denoised,\\n )\\n print(\\\"denoised (noiser2noise) :\\\", psnr_denoised, ssim_denoised)\\n print(\\n \\\"denoised (noiser2noise corrected) :\\\",\\n psnr_denoised_corrected,\\n ssim_denoised_corrected,\\n )\\n print(\\\"denoised (x2) :\\\", psnr_denoised2, ssim_denoised2)\\n\\n Log.enable_output = False\\n denoised_images = []\\n for i in range(1, 32):\\n psnr_denoised = psnr(image, numpy.clip(denoised, 0, 1))\\n ssim_denoised = ssim(image, numpy.clip(denoised, 0, 1))\\n psnr_sslos = psnr(numpy.clip(n2s_denoised, 0, 1), numpy.clip(denoised, 0, 1))\\n ssim_sslos = ssim(numpy.clip(n2s_denoised, 0, 1), numpy.clip(denoised, 0, 1))\\n print(f\\\"x{i} :\\\", psnr_sslos, ssim_sslos, psnr_denoised, ssim_denoised)\\n\\n denoised_images.append(numpy.clip(denoised, 0, 1))\\n denoised = it.translate(denoised)\\n\\n import napari\\n\\n with napari.gui_qt():\\n viewer = napari.Viewer()\\n viewer.add_image(image, name='image')\\n viewer.add_image(noisy, name='noisy')\\n viewer.add_image(noisier, name='noisier')\\n viewer.add_image(n2s_denoised, name='denoised (classic_denoisers)')\\n viewer.add_image(denoised, name='denoised (noiser3noise)')\\n viewer.add_image(denoised_corrected, name='denoised (noiser3noise corrected)')\\n viewer.add_image(numpy.stack(denoised_images), name=f'denoised images')\",\n \"def data_augmentation(image, aug):\\n if (aug == \\\"random_crop\\\") and (random.randint(0,1)):\\n image = random_crop(image) \\n if (aug == \\\"random_rotation\\\") and (random.randint(0,1)): \\n image = random_rotation(image) \\n if (aug == \\\"random_flip\\\") and (random.randint(0,1)): \\n image = random_flip(image)\\n if (aug == \\\"affine_transformation\\\") and (random.randint(0,1)): \\n image = affine_transformation(image)\\n if (aug == \\\"random_gaussian_noise\\\") and (random.randint(0,1)): \\n image = random_gaussian_noise(image)\\n if (aug == \\\"random_erasing\\\") and (random.randint(0,1)): \\n image = random_erasing(image) \\n return image\",\n \"def test_model_sample(net, data_loader):\\n net.eval()\\n array = []\\n with torch.no_grad():\\n for data in data_loader:\\n X = data['X']\\n output = net(X)\\n output = ToPILImage()(output)\\n array.append(output)\\n return array\",\n \"def forward_pass(X,architecture):\\n \\n architecture['layer1'][0] = X\\n kernel_shape1 = architecture['layer1'][7]\\n stride1 = architecture['layer1'][8]\\n if kernel_shape1 is not None and not isinstance(kernel_shape1,int):\\n X_input_1_im2col,imX = im2col(X,kernel_shape1,stride1,im_needed = False, shape_specified = True)\\n architecture['layer1'][4] = X_input_1_im2col\\n else:\\n architecture['layer1'][4] = None\\n\\n for layer in range(len(architecture)): # Feedforward from the first till the second last layer\\n X_input,X_output,weightsi,biasi,X_input_1_im2col,imi,output_shapei,kernel_shapei,stridei,operationi,imx = architecture['layer{}'.format(layer+1)]\\n\\n if operationi == 'conv_bn_relu':\\n conv_output = relu(BatchNorm(torch.t(X_input_1_im2col).mm(weightsi) + biasi))\\n conv_output = torch.reshape(conv_output,output_shapei)\\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\\n if operationi__1 == 'maxpool':\\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\\n else:\\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\\n # resetting input im2col of next layer as the im2col of the output of this layer\\n else:\\n architecture['layer{}'.format(layer+2)][4] = None\\n elif operationi == 'conv_relu':\\n conv_output = relu(torch.t(X_input_1_im2col).mm(weightsi) + biasi)\\n conv_output = torch.reshape(conv_output,output_shapei)\\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\\n if operationi__1 == 'maxpool':\\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\\n else:\\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\\n # resetting input im2col of next layer as the im2col of the output of this layer\\n else:\\n architecture['layer{}'.format(layer+2)][4] = None\\n elif operationi == 'conv_bn_sigmoid':\\n conv_output = sigmoid(BatchNorm(torch.t(X_input_1_im2col).mm(weightsi) + biasi))\\n conv_output = torch.reshape(conv_output,output_shapei)\\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\\n if operationi__1 == 'maxpool':\\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\\n else:\\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\\n # resetting input im2col of next layer as the im2col of the output of this layer\\n else:\\n architecture['layer{}'.format(layer+2)][4] = None\\n elif operationi == 'conv_sigmoid':\\n conv_output = sigmoid(torch.t(X_input_1_im2col).mm(weightsi) + biasi)\\n conv_output = torch.reshape(conv_output,output_shapei)\\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\\n if operationi__1 == 'maxpool':\\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\\n else:\\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\\n # resetting input im2col of next layer as the im2col of the output of this layer\\n else:\\n architecture['layer{}'.format(layer+2)][4] = None\\n elif operationi == 'maxpool':\\n maxpool_output = maxpool(X_input,kernel_shapei,stridei)\\n\\n maxpool_output = torch.reshape(maxpool_output,output_shapei)\\n\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = maxpool_output\\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\\n architecture['layer{}'.format(layer+2)][4],imX = im2col(maxpool_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\\n else:\\n architecture['layer{}'.format(layer+2)][4] = None\\n elif operationi == 'flatten_dense_relu':\\n # kernel_shapei in this case refers to the output channels: stride for dense layer will be None\\n output = flatten_and_dense(X_input,kernel_shapei,weightsi,biasi,activation = 'relu',initialise_weights = False)\\n architecture['layer{}'.format(layer+1)][1] = output\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = output\\n elif operationi == 'flatten_dense_none':\\n # kernel_shapei in this case refers to the output channels: stride for dense layer will be None\\n output = flatten_and_dense(X_input,kernel_shapei,weightsi,biasi,activation = 'none',initialise_weights = False)\\n architecture['layer{}'.format(layer+1)][1] = output\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = output\\n elif operationi == 'flatten_dense_sigmoid':\\n # kernel_shapei in this case refers to the output channels: stride for dense layer will be None\\n output = flatten_and_dense(X_input,kernel_shapei,weightsi,biasi,activation = 'sigmoid',initialise_weights = False)\\n architecture['layer{}'.format(layer+1)][1] = output\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = output\\n elif operationi == 'softmax':\\n Xin = architecture['layer{}'.format(layer+1)][0]\\n output = softmax(Xin).squeeze()\\n architecture['layer{}'.format(layer+1)][1] = output\\n if layer == len(architecture) - 1:\\n y_pred = architecture['layer{}'.format(len(architecture))][1]\\n \\n return y_pred\",\n \"def visualize_saliency_of_output(FLAGS, model, input_images=[]):\\n if len(input_images) == 0:\\n # use predefined images\\n img_dir='/esat/opal/kkelchte/docker_home/pilot_data/visualization_images'\\n input_images=sorted([img_dir+'/'+f for f in os.listdir(img_dir)])\\n\\n print(\\\"[tools.py]: extracting saliency maps of {0} in {1}\\\".format([os.path.basename(i) for i in input_images], os.path.dirname(input_images[0])))\\n \\n \\n inputs = load_images(input_images, model.input_size[1:])\\n\\n print 'shape: ',inputs.shape\\n\\n if 'nfc' in FLAGS.network:\\n inputs = np.concatenate([inputs]*FLAGS.n_frames, axis=-1)\\n \\n # extract deconvolution\\n import tf_cnnvis\\n\\n # layers = ['c']\\n # layers=['MobilenetV1_1/control/Conv2d_1c_1x1/Conv2D']\\n # layers=['MobilenetV1_1/control/Conv2d_1c_1x1/Conv2D','MobilenetV1_1/AvgPool_1a/AvgPool']\\n\\n # layers = [str(i.name) for i in model.sess.graph.get_operations() if 'outputs' in i.name and not 'activations' in i.name and not 'gradients' in i.name]\\n layers = [model.endpoints['eval']['outputs'].name[:-2]] #cut out :0 in the end to change name from tensor to operation name\\n # layers = ['outputs']\\n \\n # results = tf_cnnvis.activation_visualization(sess_graph_path = model.sess, \\n # value_feed_dict = {model.inputs : inputs}, \\n # layers=layers)\\n results = tf_cnnvis.deconv_visualization(sess_graph_path = model.sess, \\n value_feed_dict = {model.inputs : inputs}, \\n layers=layers)\\n\\n # Normalize deconvolution within 0:1 range\\n num_rows=0\\n clean_results={} \\n # Loop over layers\\n for k in results.keys():\\n clean_results[k]=[]\\n # Loop over channels\\n for c in range(len(results[k])):\\n num_rows+=1\\n clean_results[k].append(np.zeros((results[k][c].shape[0:3])))\\n # Loop over images\\n for i in range(results[k][c].shape[0]):\\n clean_results[k][c][i]=deprocess_image(results[k][c][i],one_channel=True)\\n if num_rows > 6:\\n print(\\\"[tools.py]: There are too many columns to create a proper image.\\\")\\n return\\n\\n # create one combined image with each input image on each column\\n fig, axes = plt.subplots(num_rows+1,min(len(input_images),5),figsize=(23, 4*(2*len(results.keys())+1)))\\n # fig, axes = plt.subplots(num_columns+1,min(len(input_images),5),figsize=(23, 4*(2*len(results.keys())+1)))\\n # add original images in first row\\n for i in range(axes.shape[1]):\\n axes[0, i].set_title(os.path.basename(input_images[i]).split('.')[0])\\n axes[0, i].imshow(matplotlibprove(inputs[i]), cmap='inferno')\\n axes[0, i].axis('off')\\n \\n # experts=np.asarray([[k]*(FLAGS.action_quantity if FLAGS.discrete else 1) for v in sorted(model.factor_offsets.values()) for k in model.factor_offsets.keys() if model.factor_offsets[k]==v]).flatten()\\n\\n # add deconvolutions over the columns\\n row_index = 1\\n for k in results.keys(): # go over layers\\n for c in range(len(results[k])): # add each channel in 2 new column\\n for i in range(axes.shape[1]): # fill row going over input images\\n # axes[row_index, i].set_title(k.split('/')[1]+'/'+k.split('/')[2]+'_'+str(c))\\n axes[row_index, i].set_title(k+'_'+str(c))\\n # axes[row_index, i].set_title(experts[c])\\n \\n axes[row_index, i].imshow(np.concatenate((inputs[i],np.expand_dims(clean_results[k][c][i],axis=2)), axis=2))\\n axes[row_index, i].axis('off')\\n # row_index+=2\\n row_index+=1\\n # plt.show()\\n plt.savefig(FLAGS.summary_dir+FLAGS.log_tag+'/saliency_maps.jpg',bbox_inches='tight')\",\n \"def example():\\n accShape, accTexture, accFinal = train_and_eval_all_models()\\n print(f'Accuracy -- only shape: {accShape}; only texture: {accTexture}; combined: {accFinal}.')\",\n \"def forward(self, img, return_loss=True, **kwargs):\\n return self.architecture(img, return_loss=return_loss, **kwargs)\",\n \"def load_image(nom):\\n print(\\\"load_image : [\\\", nom, \\\"]\\\")\\n fic = gdal.Open(nom)\\n print(fic)\\n return fic.ReadAsArray(), fic.GetGeoTransform()\",\n \"def _get_logits(images,\\n model_options,\\n outputs_to_num_classes,\\n weight_decay=0.0001,\\n reuse=tf.AUTO_REUSE,\\n is_training=False,\\n fine_tune_batch_norm=False):\\n features, end_points = _extract_features(\\n images,\\n model_options,\\n weight_decay=weight_decay,\\n reuse=reuse,\\n is_training=is_training,\\n fine_tune_batch_norm=fine_tune_batch_norm)\\n\\n # TODO: CHECK\\n DEBUG_VARS.aspp_result = features\\n if model_options.decoder_output_stride is not None:\\n decoder_height = scale_dimension(model_options.crop_size[0],\\n 1.0 / model_options.decoder_output_stride)\\n decoder_width = scale_dimension(model_options.crop_size[1],\\n 1.0 / model_options.decoder_output_stride)\\n features = refine_by_decoder(\\n features,\\n end_points,\\n decoder_height=decoder_height,\\n decoder_width=decoder_width,\\n decoder_use_separable_conv=model_options.decoder_use_separable_conv,\\n model_variant=model_options.model_variant,\\n weight_decay=weight_decay,\\n reuse=reuse,\\n is_training=is_training,\\n fine_tune_batch_norm=fine_tune_batch_norm)\\n\\n outputs_to_logits = {}\\n for output in sorted(outputs_to_num_classes):\\n outputs_to_logits[output] = _get_branch_logits(\\n features,\\n outputs_to_num_classes[output],\\n model_options.atrous_rates,\\n aspp_with_batch_norm=model_options.aspp_with_batch_norm,\\n kernel_size=model_options.logits_kernel_size,\\n weight_decay=weight_decay,\\n reuse=reuse,\\n scope_suffix=output)\\n\\n return outputs_to_logits\",\n \"def build(self):\\n input_shape_img = (None, None, 3)\\n img_input = Input(shape=input_shape_img)\\n roi_input = Input(shape=(None, 4))\\n shared_layers = self.cnn_model.nn_base(img_input, trainable=True)\\n num_anchors = len(self.C.anchor_scales) * len(self.C.anchor_ratios)\\n \\n output_region_proposal = self.region_proposal_net(shared_layers, num_anchors)\\n output_classifier = self.classifier(shared_layers,\\n self.cnn_model.classifier_layers, \\n roi_input, self.C.num_roi, \\n num_class=len(self.class_count), trainable=True)\\n \\n self.model_region_proposal = Model(img_input, output_region_proposal[:2])\\n self.model_classifier = Model([img_input, roi_input], output_classifier)\\n self.model_all = Model([img_input, roi_input], output_region_proposal[:2] + output_classifier)\\n\\n optimizer = Adam(lr=1e-5)\\n self.model_region_proposal.compile(optimizer=optimizer, \\n loss=[losses.rpn_loss_cls(num_anchors), \\n losses.rpn_loss_regr(num_anchors)])\\n self.model_classifier.compile(optimizer=optimizer, \\n loss=[losses.class_loss_cls, \\n losses.class_loss_regr(len(self.class_count)-1)], \\n metrics={'dense_class_{}'.format(len(self.class_count)): 'accuracy'})\\n self.model_all.compile(optimizer='sgd', loss='mae')\\n\\n # print(self.model_all.summary())\\n plot_model(self.model_region_proposal, show_shapes=True, to_file='./frcnn/images/region_proposal.png')\\n plot_model(self.model_classifier, show_shapes=True, to_file='./frcnn/images/classifier.png')\\n plot_model(self.model_all, show_shapes=True, to_file='./frcnn/images/model_all.png')\",\n \"def encode(self, img):\\n with tf.variable_scope('encoder'):\\n #conv1 = self.conv_layer(\\n # img, [5, 5], [3, 32], stride=2, initializer_type=1, name='conv1')\\n #conv2 = self.conv_layer(\\n # conv1, [5, 5], [32, 32], stride=2, initializer_type=1, name='conv2')\\n conv3 = self.conv_layer(\\n img, [5, 5], [self.in_channels, 64], stride=2, initializer_type=1, name='conv3')\\n #conv4 = self.conv_bn_layer(\\n conv4 = self.conv_layer(\\n conv3, [5, 5], [64, 128], stride=2, #is_training=self.is_training,\\n initializer_type=1, name='conv4')\\n #conv5 = self.conv_bn_layer(\\n conv5 = self.conv_layer(\\n conv4, [5, 5], [128, 256], stride=2, #is_training=self.is_training,\\n initializer_type=1, name='conv5')\\n shape = conv5.get_shape().as_list()\\n feature_map_size = shape[1]*shape[2]*shape[3]\\n conv5_flat = tf.reshape(\\n conv5, [-1, feature_map_size], 'conv5_flat')\\n #fc6 = self.fc_bn_layer(conv5_flat, 1024, is_training=self.is_training,\\n fc6 = self.fc_layer(conv5_flat, 1024,\\n initializer_type=1, name='fc6')\\n #fc7 = self.fc_layer(fc6, 1024, initializer_type=1, name='fc7')\\n return fc6, shape\",\n \"def compute_img(self):\\r\\n self.load_img()\\r\\n self.check_shape()\\r\\n self.convert_img()\\r\\n self.img_computed = True\",\n \"def my_hom_cnn_model_fn(features, labels, mode):\\n # Input Layer\\n # Reshape X to 4-D tensor: [batch_size, width, height, channels]\\n\\n #HOM Images are 128x128, and have two channels\\n input_layer = tf.reshape(features[\\\"x\\\"], [-1, pSize, pSize, 2])\\n\\n # Convolutional Layer #1\\n # Computes 32 features using a 3x3 filter with ReLU activation.\\n # Padding is added to preserve width and height.\\n conv1 = tf.layers.conv2d(inputs=input_layer, filters=64,kernel_size=[3, 3], padding=\\\"same\\\",activation=tf.nn.relu) #None\\n conv2 = tf.layers.conv2d(inputs=conv1, filters=64, kernel_size=[3, 3], padding=\\\"same\\\", activation=tf.nn.relu)\\n pool1 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)\\n\\n conv3 = tf.layers.conv2d(inputs=pool1, filters=64, kernel_size=[3, 3], padding=\\\"same\\\",activation=tf.nn.relu)\\n conv4 = tf.layers.conv2d(inputs=conv3,filters=64,kernel_size=[3, 3],padding=\\\"same\\\",activation=tf.nn.relu)\\n pool2 = tf.layers.max_pooling2d(inputs=conv4, pool_size=[2, 2], strides=2)\\n\\n conv5 = tf.layers.conv2d(inputs=pool2, filters=128, kernel_size=[3, 3], padding=\\\"same\\\",activation=tf.nn.relu)\\n conv6 = tf.layers.conv2d(inputs=conv5,filters=128,kernel_size=[3, 3],padding=\\\"same\\\",activation=tf.nn.relu)\\n pool3 = tf.layers.max_pooling2d(inputs=conv6, pool_size=[2, 2], strides=2)\\n\\n conv7 = tf.layers.conv2d(inputs=pool3, filters=128, kernel_size=[3, 3], padding=\\\"same\\\",activation=tf.nn.relu)\\n conv8 = tf.layers.conv2d(inputs=conv7,filters=128,kernel_size=[3, 3],padding=\\\"same\\\",activation=tf.nn.relu)\\n\\n # Dense Layer\\n # Densely connected layer with 1024 neurons\\n conv2_flat = tf.reshape(conv8, [-1, 128 * 128 * 2])\\n # Add dropout operation; 0.5 probability that element will be kept\\n dropout = tf.layers.dropout(inputs=conv2_flat, rate=0.5, training=mode == tf.estimator.ModeKeys.TRAIN)\\n\\n fully_connect = tf.layers.dense(inputs=dropout, units=1024, activation=None) #activation=None\\n predictions = tf.layers.dense(inputs=fully_connect, units=8, activation=None)\\n\\n #predictions\\n if mode == tf.estimator.ModeKeys.PREDICT:\\n return tf.estimator.EstimatorSpec(mode=mode, predictions = predictions)\\n \\n loss = tf.losses.mean_squared_error(labels=labels, predictions = predictions)\\n \\n #loss = tf.nn.softmax_cross_entropy_with_logits(labels=labels, logits=predictions, name=\\\"softmax_tensor\\\")\\n\\n # Configure the Training Op (for TRAIN mode)\\n if mode == tf.estimator.ModeKeys.TRAIN:\\n optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)\\n train_op = optimizer.minimize(loss=loss, global_step=tf.train.get_global_step())\\n return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)\\n\\n # Add evaluation metrics (for EVAL mode)\\n #eval_metric_ops = {\\\"accuracy\\\": tf.metrics.accuracy(labels=labels, predictions=predictions[\\\"coord\\\"])}#predictions=predictions[\\\"classes\\\"])}\\n \\n if mode == tf.estimator.ModeKeys.EVAL:\\n eval_metric_ops = {\\n \\\"mean_square_error\\\": tf.metrics.mean_squared_error(labels=labels, predictions = predictions)}#predictions=predictions[\\\"classes\\\"])}\\n\\n return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops, predictions = predictions)\",\n \"def process(bayer_images, red_gains, blue_gains, cam2rgbs):\\n bayer_images.shape.assert_is_compatible_with((None, None, None, 4))\\n with tf.name_scope(None, 'process'):\\n # White balance.\\n bayer_images = apply_gains(bayer_images, red_gains, blue_gains)\\n # Demosaic.\\n bayer_images = tf.clip_by_value(bayer_images, 0.0, 1.0)\\n images = demosaic(bayer_images)\\n # Color correction.\\n images = apply_ccms(images, cam2rgbs)\\n # Gamma compression.\\n images = tf.clip_by_value(images, 0.0, 1.0)\\n images = gamma_compression(images)\\n return images\",\n \"def loadRes(self, predictions, type='boxes'):\\n print('Loading and preparing results...')\\n res = Car3D(self.cfg, self.dataset_dir, self.list_flag, self.transforms, self.training)\\n res.dataset = dict()\\n res.dataset['categories'] = copy.deepcopy(self.category_to_id_map)\\n res.dataset['images'] = []\\n anns = []\\n count = 1\\n tic = time.time()\\n\\n for idx in tqdm(range(len(self.img_list_all))):\\n res.dataset['images'].append({'id': self.img_list_all[idx]})\\n prediction = predictions[idx]\\n if type == 'boxes':\\n for id in range(len(prediction)):\\n ann = dict()\\n ann['image_id'] = self.img_list_all[idx]\\n ann['category_id'] = int(prediction.get_field('labels')[id].numpy())\\n bb = prediction.bbox[id].numpy()\\n x1, x2, y1, y2 = bb[0], bb[2], bb[1], bb[3]\\n w = x2 - x1\\n h = y2 - y1\\n x_c = (x1 + x2) / 2\\n y_c = (y1 + y2) / 2\\n ann['bbox'] = [x_c, y_c, w, h]\\n ann['area'] = w * h\\n ann['id'] = count\\n ann['iscrowd'] = 0\\n ann['score'] = prediction.get_field('scores')[id].numpy()\\n\\n count += 1\\n anns.append(ann)\\n elif type == 'segms':\\n masks = prediction.get_field(\\\"mask\\\")\\n masks = self.masker([masks], [prediction])[0]\\n\\n for id in range(len(prediction)):\\n ann = dict()\\n ann['image_id'] = self.img_list_all[idx]\\n ann['score'] = prediction.get_field('scores')[id].numpy()\\n binary_mask = masks[id, 0]\\n fortran_binary_mask = np.asfortranarray(binary_mask)\\n ann['segms'] = maskUtils.encode(fortran_binary_mask)\\n ann['category_id'] = int(prediction.get_field('labels')[id].numpy())\\n # now only support compressed RLE format as segmentation results\\n ann['area'] = maskUtils.area(ann['segms'])\\n if not 'boxes' in ann:\\n ann['boxes'] = maskUtils.toBbox(ann['segms'])\\n ann['id'] = count\\n count += 1\\n ann['iscrowd'] = 0\\n anns.append(ann)\\n\\n print('DONE (t={:0.2f}s)'.format(time.time() - tic))\\n res.dataset['annotations'] = anns\\n res.createIndex()\\n #res.eval_class = []\\n return res\",\n \"def create_inputs_norb(path, is_train: bool,batch_size,epochs):\\n\\n # Create batched dataset\\n dataset = input_fn(path, is_train,batch_size=batch_size, epochs=epochs)\\n\\n # Create one-shot iterator\\n iterator = tf.compat.v1.data.make_one_shot_iterator(dataset)\\n\\n img, lab, cat, elv, azi, lit = iterator.get_next()\\n\\n output_dict = {'image': img,\\n 'label': lab,\\n 'category': cat,\\n 'elevation': elv,\\n 'azimuth': azi,\\n 'lighting': lit}\\n\\n return output_dict\",\n \"def get_classification(self, image):\\n # return TrafficLight.RED\\n # TODO implement light color prediction\\n # creating an image object \\n img_np = np.array(image) \\n\\n # convert np array to tensor\\n input_tensor = tf.convert_to_tensor(img_np)\\n\\n # The model expects a batch of images, so add an axis with `tf.newaxis`.\\n input_tensor = input_tensor[tf.newaxis, ...]\\n\\n\\n detections = self.loaded(input_tensor)\\n\\n num_detections = int(detections.pop('num_detections'))\\n\\n # detection_classes should be ints.\\n detections_dict = {key: value[0, :num_detections].numpy() for key, value in detections.items()}\\n\\n\\n # detection_classes should be ints.\\n detections_dict['detection_classes'] = detections_dict['detection_classes'].astype(np.int64)\\n\\n label_id_offset = 1\\n\\n # DEBUG - can do it in a cleaner way :0\\n tl_classes = {3: 'green', 2: 'red'}\\n top_classes_prediction = list(detections_dict['detection_classes']+label_id_offset)[:5] \\n #print(top_classes_prediction)\\n for i in range(len(top_classes_prediction)):\\n if top_classes_prediction[i] == 2:\\n top_classes_prediction[i] = 'green'\\n elif top_classes_prediction[i] == 3:\\n top_classes_prediction[i] = 'red'\\n\\n\\n #print(\\\"--------->\\\", image_path, \\\"<-----------\\\")\\n #print( top_classes_prediction ) \\n #print(detections_dict['detection_scores'][:5], '\\\\n' )\\n\\n # basic red tl logic\\n if top_classes_prediction[0] == 'red' and detections_dict['detection_scores'][0] >= 0.60:\\n #print(\\\"-------------> RED TRAFFIC LIGHT <----------------\\\\n\\\")\\n self.current_light = TrafficLight.RED\\n #rospy.logwarn( \\\"----------------- Taffic light is RED !!! -------------------- \\\" )\\n self.display_predictions_scores( top_classes_prediction, detections_dict['detection_scores'] )\\n else:\\n #print(\\\"No red traffic is detected\\\\n\\\")\\n self.current_light = TrafficLight.GREEN\\n #rospy.logwarn( \\\"----------------- You're good to go !!! --------: {0} - {1} \\\".format(top_classes_prediction[0], detections_dict['detection_scores'][0]) )\\n self.display_predictions_scores( top_classes_prediction, detections_dict['detection_scores'] )\\n\\n return self.current_light\",\n \"def inception_network():\\n X = K.Input(shape=(224, 224, 3))\\n initializer = K.initializers.he_normal(seed=None)\\n conv_1 = K.layers.Conv2D(filters=64, kernel_size=7,\\n padding='same', strides=2,\\n kernel_initializer=initializer,\\n activation='relu')(X)\\n max_pool_1 = K.layers.MaxPooling2D(pool_size=3, strides=2,\\n padding='same')(conv_1)\\n\\n conv_2 = K.layers.Conv2D(filters=64, padding='same',\\n kernel_size=1, activation='relu',\\n kernel_initializer=initializer)(max_pool_1)\\n conv2_1 = K.layers.Conv2D(filters=192, padding='same',\\n kernel_size=3, activation='relu',\\n kernel_initializer=initializer)(conv_2)\\n max_pool_2 = K.layers.MaxPooling2D(pool_size=3, strides=2,\\n padding='same')(conv2_1)\\n\\n incep_3a = inception_block(max_pool_2, [64, 96, 128, 16, 32, 32])\\n incep_3b = inception_block(incep_3a, [128, 128, 192, 32, 96, 64])\\n max_pool_3 = K.layers.MaxPooling2D(pool_size=3, strides=2,\\n padding='same')(incep_3b)\\n\\n incep_4a = inception_block(max_pool_3, [192, 96, 208, 16, 48, 64])\\n incep_4b = inception_block(incep_4a, [160, 112, 224, 24, 64, 64])\\n incep_4c = inception_block(incep_4b, [128, 128, 256, 24, 64, 64])\\n incep_4d = inception_block(incep_4c, [112, 144, 288, 32, 64, 64])\\n incep_4e = inception_block(incep_4d, [256, 160, 320, 32, 128, 128])\\n max_pool_4 = K.layers.MaxPooling2D(pool_size=3, strides=2,\\n padding='same')(incep_4e)\\n\\n incep_5a = inception_block(max_pool_4, [256, 160, 320, 32, 128, 128])\\n incep_5b = inception_block(incep_5a, [384, 192, 384, 48, 128, 128])\\n avg_pool = K.layers.AveragePooling2D(pool_size=7, strides=None)(incep_5b)\\n\\n drop_out = K.layers.Dropout(0.4)(avg_pool)\\n dense = K.layers.Dense(units=1000, activation='softmax',\\n kernel_initializer=initializer)(drop_out)\\n return K.models.Model(inputs=X, outputs=dense)\",\n \"def data_augmentation(image_data, mask_data, rotate=False, vertical_flip=False, horizontal_flip=False):\\n aug_images = []\\n aug_masks = []\\n\\n for _ in range(len(image_data)):\\n if rotate:\\n rotation = A.RandomRotate90(p=1)\\n rotated_data = rotation(image=image_data[_], mask=mask_data[_])\\n rotated_image = rotated_data['image']\\n rotated_mask = rotated_data['mask']\\n aug_images.append(rotated_image)\\n aug_masks.append(rotated_mask)\\n\\n if vertical_flip:\\n flip_v = A.VerticalFlip(p=1)\\n vertical_data = flip_v(image=image_data[_], mask=mask_data[_])\\n vertical_image = vertical_data['image']\\n vertical_mask = vertical_data['mask']\\n aug_images.append(vertical_image)\\n aug_masks.append(vertical_mask)\\n\\n if horizontal_flip:\\n flip_h = A.HorizontalFlip(p=1)\\n horizontal_data = flip_h(image=image_data[_], mask=mask_data[_])\\n horizontal_image = horizontal_data['image']\\n horizontal_mask = horizontal_data['mask']\\n aug_images.append(horizontal_image)\\n aug_masks.append(horizontal_mask)\\n\\n nd_images = make_ndarray(aug_images)\\n nd_masks = make_ndarray(aug_masks)\\n #nd_images = np.zeros((len(aug_images), IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS), dtype=np.float32)\\n #nd_masks = np.zeros((len(aug_masks), IMG_HEIGHT, IMG_WIDTH), dtype=np.float32)\\n\\n #for _ in range(len(aug_images)): # Load into ndarray\\n # nd_images[_] = aug_images[_]\\n # nd_masks[_] = aug_masks[_] # load mask without channel variable\\n\\n return nd_images, nd_masks\",\n \"def create(self):\\n \\n \\\"\\\"\\\" A solo prepressing reduction network in the head \\\"\\\"\\\"\\n print(\\\"pre_reduction\\\")\\n with tf.name_scope('pre_reduction'):\\n conv1 = NW.conv(self.X, 7, 7, 64, 2, 2, name='conv1')\\n pool1 = NW.max_pool(conv1, 3, 3, 2, 2, name='pool1')\\n norm1 = NW.lrn(pool1, 2, 2e-05, 0.75, name='norm1')\\n reduction2 = NW.conv(norm1, 1, 1, 64, 1, 1, name='reduction2')\\n conv2 = NW.conv(reduction2, 3, 3, 192, 1, 1,name='conv2')\\n norm2 = NW.lrn(conv2, 2, 2e-05, 0.75, name='norm2')\\n pool2 = NW.max_pool(norm2, 3, 3, 2, 2, name='pool2')\\n \\n \\\"\\\"\\\" 1st inception layer group \\\"\\\"\\\"\\n print(\\\"icp1\\\")\\n with tf.name_scope('icp1'):\\n # branch 0\\n icp1_out0 = NW.conv(pool2, 1, 1, 64, 1, 1, name='icp1_out0')\\n # branch 1\\n icp1_reduction1 = NW.conv(pool2, 1, 1, 96, 1, 1, name='icp1_reduction1')\\n icp1_out1 = NW.conv(icp1_reduction1, 3, 3, 128, 1, 1, name='icp1_out1')\\n # branch 2\\n icp1_reduction2 = NW.conv(pool2, 1, 1, 16, 1, 1, name='icp1_reduction2')\\n icp1_out2 = NW.conv(icp1_reduction2, 5, 5, 32, 1, 1, name='icp1_out2')\\n # branch 3\\n icp1_pool = NW.max_pool(pool2, 3, 3, 1, 1, name='icp1_pool')\\n icp1_out3 = NW.conv(icp1_pool, 1, 1, 32, 1, 1, name='icp1_out3')\\n # concat\\n icp2_in = NW.concat([icp1_out0,\\n icp1_out1,\\n icp1_out2,\\n icp1_out3], 3, 'icp2_in')\\n\\n \\\"\\\"\\\" 2nd inception layer group \\\"\\\"\\\"\\n print(\\\"icp2\\\")\\n with tf.name_scope('icp2'):\\n # branch 0\\n icp2_out0 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_out0')\\n # branch 1\\n icp2_reduction1 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_reduction1')\\n icp2_out1 = NW.conv(icp2_reduction1, 3, 3, 192, 1, 1, name='icp2_out1')\\n # branch 2\\n icp2_reduction2 = NW.conv(icp2_in, 1, 1, 32, 1, 1, name='icp2_reduction2')\\n icp2_out2 = NW.conv(icp2_reduction2, 5, 5, 96, 1, 1, name='icp2_out2')\\n # branch 3\\n icp2_pool = NW.max_pool(icp2_in, 3, 3, 1, 1, name='icp2_pool')\\n icp2_out3 = NW.conv(icp2_pool, 1, 1, 64, 1, 1, name='icp2_out3')\\n # concat\\n icp2_out = NW.concat([icp2_out0,\\n icp2_out1,\\n icp2_out2,\\n icp2_out3], 3, 'icp2_out')\\n \\n \\\"\\\"\\\" 3rd inception layer group \\\"\\\"\\\"\\n print(\\\"icp3\\\")\\n with tf.name_scope('icp3'):\\n icp3_in = NW.max_pool(icp2_out, 3, 3, 2, 2, name='icp3_in')\\n # branch 0\\n icp3_out0 = NW.conv(icp3_in, 1, 1, 192, 1, 1, name='icp3_out0')\\n # branch 1\\n icp3_reduction1 = NW.conv(icp3_in, 1, 1, 96, 1, 1, name='icp3_reduction1')\\n icp3_out1 = NW.conv(icp3_reduction1, 3, 3, 208, 1, 1, name='icp3_out1')\\n # branch 2\\n icp3_reduction2 = NW.conv(icp3_in, 1, 1, 16, 1, 1, name='icp3_reduction2')\\n icp3_out2 = NW.conv(icp3_reduction2, 5, 5, 48, 1, 1, name='icp3_out2')\\n # branch 3\\n icp3_pool = NW.max_pool(icp3_in, 3, 3, 1, 1, name='icp3_pool')\\n icp3_out3 = NW.conv(icp3_pool, 1, 1, 64, 1, 1, name='icp3_out3')\\n # concat\\n icp3_out = NW.concat([icp3_out0,\\n icp3_out1,\\n icp3_out2,\\n icp3_out3], 3, 'icp3_out')\\n \\n \\\"\\\"\\\" 1st classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls1'):\\n cls1_pool = NW.avg_pool(icp3_out, 5, 5, 3, 3, padding='VALID', name='cls1_pool')\\n cls1_reduction_pose = NW.conv(cls1_pool, 1, 1, 128, 1, 1, name='cls1_reduction_pose')\\n cls1_fc1_pose = NW.fc(cls1_reduction_pose, 1024, name='cls1_fc1_pose')\\n cls1_fc_pose_xy = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_xy')\\n cls1_fc_pose_ab = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_ab')\\n self.layers[\\\"cls1_fc_pose_xy\\\"] = cls1_fc_pose_xy\\n self.layers[\\\"cls1_fc_pose_ab\\\"] = cls1_fc_pose_ab\\n \\n \\\"\\\"\\\" 4st inception layer group \\\"\\\"\\\"\\n print(\\\"icp4\\\")\\n with tf.name_scope('icp4'):\\n # branch 0\\n icp4_out0 = NW.conv(icp3_out, 1, 1, 160, 1, 1, name='icp4_out0')\\n # branch 1\\n icp4_reduction1 = NW.conv(icp3_out, 1, 1, 112, 1, 1, name='icp4_reduction1')\\n icp4_out1 = NW.conv(icp4_reduction1, 3, 3, 224, 1, 1, name='icp4_out1')\\n # branch 2\\n icp4_reduction2 = NW.conv(icp3_out, 1, 1, 24, 1, 1, name='icp4_reduction2')\\n icp4_out2 = NW.conv(icp4_reduction2, 5, 5, 64, 1, 1, name='icp4_out2')\\n # branch 3\\n icp4_pool = NW.max_pool(icp3_out, 3, 3, 1, 1, name='icp4_pool')\\n icp4_out3 = NW.conv(icp4_pool, 1, 1, 64, 1, 1, name='icp4_out3')\\n # concat\\n icp4_out = NW.concat([icp4_out0,\\n icp4_out1,\\n icp4_out2,\\n icp4_out3],3, name='icp4_out')\\n\\n \\\"\\\"\\\" 5st inception layer group \\\"\\\"\\\"\\n print(\\\"icp5\\\")\\n with tf.name_scope('icp5'):\\n # branch 0\\n icp5_out0 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_out0')\\n # branch 1\\n icp5_reduction1 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_reduction1')\\n icp5_out1 = NW.conv(icp5_reduction1, 3, 3, 256, 1, 1, name='icp5_out1')\\n # branch 2\\n icp5_reduction2 = NW.conv(icp4_out,1, 1, 24, 1, 1, name='icp5_reduction2')\\n icp5_out2 = NW.conv(icp5_reduction2, 5, 5, 64, 1, 1, name='icp5_out2')\\n # branch 3\\n icp5_pool = NW.max_pool(icp4_out,3, 3, 1, 1, name='icp5_pool')\\n icp5_out3 = NW.conv(icp5_pool, 1, 1, 64, 1, 1, name='icp5_out3')\\n # concat\\n icp5_out = NW.concat([icp5_out0, \\n icp5_out1, \\n icp5_out2, \\n icp5_out3], 3, name='icp5_out')\\n \\n \\\"\\\"\\\" 6st inception layer group \\\"\\\"\\\"\\n print(\\\"icp6\\\")\\n with tf.name_scope('icp6'):\\n # branch 0\\n icp6_out0 = NW.conv(icp5_out, 1, 1, 112, 1, 1, name='icp6_out0')\\n # branch 1\\n icp6_reduction1 = NW.conv(icp5_out, 1, 1, 144, 1, 1, name='icp6_reduction1')\\n icp6_out1 = NW.conv(icp6_reduction1, 3, 3, 288, 1, 1, name='icp6_out1')\\n # branch 2\\n icp6_reduction2 = NW.conv(icp5_out, 1, 1, 32, 1, 1, name='icp6_reduction2')\\n icp6_out2 = NW.conv(icp6_reduction2, 5, 5, 64, 1, 1, name='icp6_out2')\\n # branch 3\\n icp6_pool = NW.max_pool(icp5_out,3, 3, 1, 1, name='icp6_pool')\\n icp6_out3 = NW.conv(icp6_pool, 1, 1, 64, 1, 1, name='icp6_out3')\\n # concat\\n icp6_out = NW.concat([icp6_out0,\\n icp6_out1,\\n icp6_out2,\\n icp6_out3], 3, name='icp6_out')\\n\\n \\\"\\\"\\\" 2nd classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls2'):\\n cls2_pool = NW.avg_pool(icp6_out, 5, 5, 3, 3, padding='VALID', name='cls2_pool')\\n cls2_reduction_pose = NW.conv(cls2_pool, 1, 1, 128, 1, 1, name='cls2_reduction_pose')\\n cls2_fc1 = NW.fc(cls2_reduction_pose, 1024, name='cls2_fc1')\\n cls2_fc_pose_xy = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_xy')\\n cls2_fc_pose_ab = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_ab')\\n self.layers[\\\"cls2_fc_pose_xy\\\"] = cls2_fc_pose_xy\\n self.layers[\\\"cls2_fc_pose_ab\\\"] = cls2_fc_pose_ab\\n\\n \\\"\\\"\\\" 7st inception layer group \\\"\\\"\\\"\\n print(\\\"icp7\\\")\\n with tf.name_scope('icp7'):\\n # branch 0\\n icp7_out0 = NW.conv(icp6_out, 1, 1, 256, 1, 1, name='icp7_out0')\\n # branch 1\\n icp7_reduction1 = NW.conv(icp6_out, 1, 1, 160, 1, 1, name='icp7_reduction1')\\n icp7_out1 = NW.conv(icp7_reduction1, 3, 3, 320, 1, 1, name='icp7_out1')\\n # branch 2\\n icp7_reduction2 = NW.conv(icp6_out, 1, 1, 32, 1, 1, name='icp7_reduction2')\\n icp7_out2 = NW.conv(icp7_reduction2, 5, 5, 128, 1, 1, name='icp7_out2')\\n # branch 3\\n icp7_pool = NW.max_pool(icp6_out, 3, 3, 1, 1, name='icp7_pool')\\n icp7_out3 = NW.conv(icp7_pool, 1, 1, 128, 1, 1, name='icp7_out3')\\n # concat\\n icp7_out = NW.concat([icp7_out0,\\n icp7_out1,\\n icp7_out2,\\n icp7_out3], 3, name='icp7_out')\\n\\n \\\"\\\"\\\" 8st inception layer group \\\"\\\"\\\"\\n print(\\\"icp8\\\")\\n with tf.name_scope('icp8'):\\n icp8_in = NW.max_pool(icp7_out, 3, 3, 2, 2, name='icp8_in')\\n # branch 0\\n icp8_out0 = NW.conv(icp8_in, 1, 1, 256, 1, 1, name='icp8_out0')\\n # branch 1\\n icp8_reduction1 = NW.conv(icp8_in, 1, 1, 160, 1, 1, name='icp8_reduction1')\\n icp8_out1 = NW.conv(icp8_reduction1, 3, 3, 320, 1, 1, name='icp8_out1')\\n # branch 2\\n icp8_reduction2 = NW.conv(icp8_in, 1, 1, 32, 1, 1, name='icp8_reduction2')\\n icp8_out2 = NW.conv(icp8_reduction2, 5, 5, 128, 1, 1, name='icp8_out2')\\n # branch 3\\n icp8_pool = NW.max_pool(icp8_in, 3, 3, 1, 1, name='icp8_pool')\\n icp8_out3 = NW.conv(icp8_pool, 1, 1, 128, 1, 1, name='icp8_out3')\\n # concat\\n icp8_out = NW.concat([icp8_out0,\\n icp8_out1,\\n icp8_out2,\\n icp8_out3], 3, name='icp8_out')\\n \\n \\\"\\\"\\\" 9st inception layer group \\\"\\\"\\\"\\n print(\\\"icp9\\\")\\n with tf.name_scope('icp9'):\\n # branch 0\\n icp9_out0 = NW.conv(icp8_out, 1, 1, 384, 1, 1, name='icp9_out0')\\n # branch 1\\n icp9_reduction1 = NW.conv(icp8_out, 1, 1, 192, 1, 1, name='icp9_reduction1')\\n icp9_out1 = NW.conv(icp9_reduction1, 3, 3, 384, 1, 1, name='icp9_out1')\\n # branch 2\\n icp9_reduction2 = NW.conv(icp8_out, 1, 1, 48, 1, 1, name='icp9_reduction2')\\n icp9_out2 = NW.conv(icp9_reduction2, 5, 5, 128, 1, 1, name='icp9_out2')\\n # branch 3\\n icp9_pool = NW.max_pool(icp8_out, 3, 3, 1, 1, name='icp9_pool')\\n icp9_out3 = NW.conv(icp9_pool, 1, 1, 128, 1, 1, name='icp9_out3')\\n # concat\\n icp9_out = NW.concat([icp9_out0,\\n icp9_out1,\\n icp9_out2,\\n icp9_out3], 3, name='icp9_out')\\n\\n \\\"\\\"\\\" 3rd classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls3'):\\n cls3_pool = NW.avg_pool(icp9_out, 7, 7, 1, 1, padding='VALID', name='cls3_pool')\\n cls3_fc1_pose = NW.fc(cls3_pool, 2048, name='cls3_fc1_pose')\\n cls3_fc_pose_xy = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_xy')\\n cls3_fc_pose_ab = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_ab')\\n self.layers[\\\"cls3_fc_pose_xy\\\"] = cls3_fc_pose_xy\\n self.layers[\\\"cls3_fc_pose_ab\\\"] = cls3_fc_pose_ab\",\n \"def main():\\n feature_extraction_model = \\\"HOG\\\"\\n # feature_extraction_models = [\\\"CM\\\", \\\"HOG\\\"]\\n feature_extraction_model_1 = \\\"CM\\\"\\n dimension_reduction_model = \\\"PCA\\\"\\n k_value = 10\\n dim_k_value = 40\\n # K_value = 20\\n # lab_folder = \\\"Dataset3/Labelled/Set1\\\"\\n # unlab_folder = \\\"Dataset3/Unlabelled/Set 2\\\"\\n lab_folder = get_input_folder(\\\"Labelled Folder\\\")\\n unlab_folder = get_input_folder(\\\"Classify\\\")\\n start = time.time()\\n # ================================================================================================================\\n # labelled Images\\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\\n folder_metadata=lab_folder,\\n metadata_collection=\\\"labelled\\\")\\n obj_feat_lab = dim_red.get_object_feature_matrix()\\n features_list_lab = np.array(obj_feat_lab['featureVector'].tolist())\\n images_list_lab = np.array(obj_feat_lab['imageId'])\\n # filtering the labelled set\\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\\n\\n # unlabelled images\\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\\n folder_metadata=unlab_folder,\\n metadata_collection=\\\"unlabelled\\\")\\n obj_feat_unlab = dim_red.get_object_feature_matrix()\\n features_list_unlab = np.array(obj_feat_unlab['featureVector'].tolist())\\n images_list_unlab = np.array(obj_feat_unlab['imageId'])\\n\\n # ================================================================================================================\\n # labelled Images\\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\\n folder_metadata=lab_folder,\\n metadata_collection=\\\"labelled\\\")\\n obj_feat_lab_1 = dim_red.get_object_feature_matrix()\\n features_list_lab_1 = np.array(obj_feat_lab_1['featureVector'].tolist())\\n # images_list_lab = np.array(obj_feat_lab_1['imageId'])\\n # filtering the labelled set\\n\\n\\n # unlabelled images\\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\\n folder_metadata=unlab_folder,\\n metadata_collection=\\\"unlabelled\\\")\\n obj_feat_unlab_1 = dim_red.get_object_feature_matrix()\\n features_list_unlab_1 = np.array(obj_feat_unlab_1['featureVector'].tolist())\\n # images_list_unlab = np.array(obj_feat_unlab['imageId'])\\n features_list_lab = np.concatenate((features_list_lab, features_list_lab_1), axis=1)\\n features_list_unlab = np.concatenate((features_list_unlab, features_list_unlab_1), axis=1)\\n\\n # ================================================================================================================\\n\\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\\n features_list = np.concatenate((features_list_lab, features_list_unlab))\\n images_list = np.concatenate((images_list_lab, images_list_unlab))\\n images_list = list(images_list)\\n # Finding Similarity Matrix\\n cos_sim = cosine_similarity(features_list)\\n sim_graph = np.empty((0, len(cos_sim)))\\n for row in cos_sim:\\n k_largest = np.argsort(-np.array(row))[1:k_value + 1]\\n sim_graph_row = [d if i in k_largest else 0 for i, d in enumerate(row)]\\n sim_graph = np.append(sim_graph, np.array([sim_graph_row]), axis=0)\\n\\n row_sums = sim_graph.sum(axis=1)\\n sim_graph = sim_graph / row_sums[:, np.newaxis]\\n idx = 0\\n results_dorsal = ppr(sim_graph, images_list, dorsal_list)\\n results_palmar = ppr(sim_graph, images_list, palmar_list)\\n final_results = {}\\n\\n for img in images_list_unlab:\\n if results_dorsal[img] < results_palmar[img]:\\n final_results[img] = \\\"dorsal\\\"\\n else:\\n final_results[img] = \\\"palmar\\\"\\n\\n actual_labels = fetch_actual_labels(images_list_unlab)\\n print(\\\"Classification\\\")\\n no_correct = 0\\n correctly_classified = []\\n incorrectly_classified = []\\n print(\\\"| ImageId | Prediction | Actual |\\\")\\n for r in final_results:\\n print(\\\"| {} | {} | {} |\\\".format(r, final_results[r], actual_labels[r]))\\n if final_results[r] == actual_labels[r]:\\n correctly_classified.append(r)\\n no_correct += 1\\n else:\\n incorrectly_classified.append(r)\\n\\n print(\\\"Correctly classified: {}\\\\n\\\".format(correctly_classified))\\n print(\\\"InCorrectly classified: {}\\\\n\\\".format(incorrectly_classified))\\n\\n print(\\\"Classification Accuracy: {}%\\\".format(no_correct / len(images_list_unlab) * 100))\\n print(\\\"Execution time: {} seconds\\\".format(time.time() - start))\",\n \"def data_tf(img):\\n img = crop.process(img)\\n img = random_contrast.process(img)\\n img = random_brightness.process(img)\\n img = random_color.process(img)\\n img = random_sharpness.process(img)\\n if img.size[1] >= 32:\\n img = compress.process(img)\\n img = adjust_resolution.process(img)\\n img = blur.process(img)\\n img = exposure.process(img)\\n # img = rotate.process(img)\\n img = salt.process(img)\\n img = inverse_color(img)\\n img = stretch.process(img)\\n return img\",\n \"def mgcNetArch(self, **kwargs):\\n\\n def_vals = {\\\"input_img_rows\\\" : self.input_img_rows,\\n \\\"input_img_cols\\\" : self.input_img_cols,\\n \\\"channels\\\" : self.channels,\\n \\\"nb_classes\\\" : self.nb_classes,\\n \\\"outLayer\\\" : 'gloAvg', \\n \\\"l2_val\\\" : 0.00, \\n \\\"net_architr\\\" : 'cnn_max', \\n \\\"block_typex\\\" : 'basic', \\n \\\"block_repeatx\\\" : [1, 1]\\n }\\n\\n\\n for k, v in def_vals.items():\\n kwargs.setdefault(k, v)\\n\\n _input_img_rows = kwargs['input_img_rows']\\n _input_img_cols = kwargs['input_img_cols']\\n _channels = kwargs['channels']\\n _nb_classes = kwargs['nb_classes']\\n _outLayer = kwargs['outLayer']\\n _l2_val = kwargs['l2_val']\\n _net_architr = kwargs['net_architr']\\n _block_typex = kwargs['block_typex']\\n _block_repeatx = kwargs['block_repeatx']\\n \\n \\n params = {\\\"input_img_rows\\\" : _input_img_rows,\\n \\\"input_img_cols\\\" : _input_img_cols,\\n \\\"channels\\\" : _channels,\\n \\\"nb_classes\\\" : _nb_classes\\n }\\n \\n print(_net_architr)\\n if _net_architr == 'cnn_max':\\n model = mgcNetArchMax(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n elif _net_architr == 'cnn_stride':\\n model = mgcNetArchStride2(outLayer = _outLayer, l2_val = _l2_val, **params)\\n\\n elif _net_architr == 'cnn_stride_mini':\\n model = mgcNetArchStride2Mini(outLayer = _outLayer, l2_val = _l2_val, **params)\\n\\n elif _net_architr == 'common_cnn':\\n model = mgcNetArchCommonCnn(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n elif _net_architr == 'net_in_net':\\n model = mgcNetArchNin(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n elif _net_architr == 'resnet':\\n model = mgcResnet(block_type = _block_typex, block_repeat = _block_repeatx, **params)\\n \\n elif _net_architr == 'resblock':\\n model = mgcNetArchRes(outLayer = _outLayer, l2_val = _l2_val, **params)\\n\\n elif _net_architr == 'skipconnect':\\n model = mgcNetArchSkip(outLayer = _outLayer, l2_val = _l2_val, **params)\\n elif _net_architr == 'skipconnect_mini':\\n model = mgcNetArchSkipMini(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n self.model = model\\n self.plot_model = SVG(model_to_dot(model, show_shapes = True).create(prog='dot', format='svg'))\\n #self.model_summary = model.summary() \\n \\n return self\",\n \"def image_model_fn(self, features, labels, mode):\\n col_count, row_count = self.metadata_.get_matrix_size(0)\\n sequence_size = self.metadata_.get_sequence_size()\\n output_dim = self.metadata_.get_output_size()\\n\\n # Input Layer\\n input_layer = features[\\\"x\\\"]\\n # Transpose X to 4-D tensor: [batch_size, row_count, col_count, sequence_size]\\n # Normally the last axis should be channels instead of time axis, but they\\n # are both equal to 1 for images\\n hidden_layer = tf.transpose(input_layer, [0, 2, 3, 1])\\n # At begining number of filters = 32\\n num_filters = 32\\n while True:\\n hidden_layer = tf.layers.conv2d(\\n inputs=hidden_layer,\\n filters=num_filters,\\n kernel_size=[3, 3],\\n strides=(1, 1),\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n hidden_layer = tf.layers.max_pooling2d(inputs=hidden_layer, pool_size=[2, 2], strides=2)\\n num_rows = hidden_layer.shape[1]\\n num_columns = hidden_layer.shape[2]\\n num_filters *= 2 # Double number of filters each time\\n if num_rows == 1 or num_columns == 1:\\n break\\n hidden_layer = tf.layers.flatten(hidden_layer)\\n hidden_layer = tf.layers.dense(inputs=hidden_layer, units=1024, activation=tf.nn.relu)\\n hidden_layer = tf.layers.dropout(\\n inputs=hidden_layer, rate=0.5, training=mode == tf.estimator.ModeKeys.TRAIN)\\n logits = tf.layers.dense(inputs=hidden_layer, units=output_dim)\\n sigmoid_tensor = tf.nn.sigmoid(logits, name=\\\"sigmoid_tensor\\\")\\n\\n predictions = {\\n # Generate predictions (for PREDICT and EVAL mode)\\n \\\"classes\\\": tf.argmax(input=logits, axis=1),\\n # Add `sigmoid_tensor` to the graph. It is used for PREDICT and by the\\n # `logging_hook`.\\n \\\"probabilities\\\": sigmoid_tensor\\n }\\n if mode == tf.estimator.ModeKeys.PREDICT:\\n return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)\\n\\n # Calculate Loss (for both TRAIN and EVAL modes)\\n # For multi-label classification, a correct loss is sigmoid cross entropy\\n loss = sigmoid_cross_entropy_with_logits(labels=labels, logits=logits)\\n\\n # Configure the Training Op (for TRAIN mode)\\n if mode == tf.estimator.ModeKeys.TRAIN:\\n optimizer = tf.train.AdamOptimizer()\\n train_op = optimizer.minimize(\\n loss=loss,\\n global_step=tf.train.get_global_step())\\n return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)\\n\\n # Add evaluation metrics (for EVAL mode)\\n eval_metric_ops = {\\n \\\"accuracy\\\": tf.metrics.accuracy(\\n labels=labels, predictions=predictions[\\\"classes\\\"])}\\n return tf.estimator.EstimatorSpec(\\n mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)\",\n \"def combine_images(args):\\n\\n # Read all images into a cube (TODO: think about the RAM)\\n with fits.open(args.input[0]) as im0:\\n lx, ly = im0[0].data.shape\\n ref_hdr = im0[0].header\\n\\n headers = [fits.open(im_name)[0].header for im_name in args.input]\\n cube = numpy.ma.zeros((len(args.input), lx, ly))\\n cube.mask = numpy.zeros_like(cube.data)\\n for ii, im_name in enumerate(args.input):\\n with astroim.Astroim(im_name) as im:\\n cube.data[ii, :,:] = im.chips[0].data\\n if im.chips[0].mask is not None:\\n cube.mask[ii,:,:] = im.chips[0].mask\\n\\n # Scale images\\n scale_functions = {\\\"median\\\": numpy.ma.median,\\n \\\"mean\\\": numpy.ma.mean,\\n \\\"mode\\\": scipy.stats.mstats.mode,\\n \\\"none\\\": lambda x: 1}\\n for ii, im_name in enumerate(args.input):\\n func = scale_functions[args.scale.lower()]\\n cube[ii,:,:] /= func(cube[ii,:,:])\\n\\n\\n # Reproject all images to the ref_hdr\\n for ii, _ in enumerate(args.input):\\n if ii == 0:\\n continue\\n cube.data[ii,:,:], footprint = reproject_interp((cube.data[ii,:,:], headers[ii]), ref_hdr)\\n cube.mask[ii,:,:], footprint = reproject_interp((cube.mask[ii,:,:], headers[ii]), ref_hdr)\\n #whr = numpy.isnan(cube.data[ii,:,:])\\n #cube.mask[ii,:,:][whr] = True\\n\\n # Do average\\n average_functions = {\\\"median\\\": numpy.ma.median, \\\"mean\\\": numpy.ma.mean, \\\"sum\\\": numpy.ma.sum}\\n func = average_functions[args.average.lower()]\\n final_image = func(cube, axis=0)\\n ref_hdr[\\\"NCOMBINE\\\"] = len(args.input)\\n\\n mask_name = utilities.replace_extension(args.output, \\\".fits.msk\\\")\\n mask_name_header = utilities.replace_extension(os.path.basename(args.output), \\\".fits.msk\\\")\\n ref_hdr[\\\"MASK\\\"] = mask_name_header\\n fits.writeto(args.output, final_image.data, ref_hdr, clobber=True )\\n fits.writeto(mask_name, numpy.array(final_image.mask, dtype=int), clobber=True)\\n\\n return args.output\",\n \"def enhance(img, window=30):\\n hp = highPassFilter(img, window=window)\\n tmp = grayscale(img) + laplacian(img)\\n return tmp\",\n \"def image_model_predict(input_ms_image_filename, input_pan_image_filename, pan_img_height_size, pan_img_width_size, \\r\\n fitted_model, write, output_filename):\\r\\n \\r\\n with rasterio.open(input_ms_image_filename) as f:\\r\\n metadata = f.profile\\r\\n ms_img = np.transpose(f.read(tuple(np.arange(metadata['count']) + 1)), [1, 2, 0])\\r\\n \\r\\n with rasterio.open(input_pan_image_filename) as g:\\r\\n metadata_pan = g.profile\\r\\n pan_img = g.read(1)\\r\\n \\r\\n pan_img = np.expand_dims(pan_img, axis = 2)\\r\\n \\r\\n ms_to_pan_ratio = metadata['transform'][0] / metadata_pan['transform'][0]\\r\\n \\r\\n class_layer = np.zeros((pan_img.shape[0], pan_img.shape[1]))\\r\\n \\r\\n img_pan_holder = []\\r\\n img_ms_holder = []\\r\\n \\r\\n for i in range(0, pan_img.shape[0] - pan_img_height_size, int(ms_to_pan_ratio)):\\r\\n for j in range(0, pan_img.shape[1] - pan_img_width_size, int(ms_to_pan_ratio)):\\r\\n img_pan_iter = pan_img[i : i + pan_img_height_size, j : j + pan_img_width_size, 0]\\r\\n img_pan_holder.append(img_pan_iter)\\r\\n \\r\\n for i in range(0, int(ms_img.shape[0] - (pan_img_height_size / ms_to_pan_ratio)), int(ms_to_pan_ratio)):\\r\\n for j in range(0, int(pan_img.shape[1] - (pan_img_width_size / ms_to_pan_ratio)), int(ms_to_pan_ratio)):\\r\\n img_ms_iter = ms_img[i : int(i + (pan_img_height_size / ms_to_pan_ratio)), \\r\\n j : int(j + (pan_img_width_size / ms_to_pan_ratio)), \\r\\n 0 : metadata['count']]\\r\\n img_ms_holder.append(img_ms_iter)\\r\\n \\r\\n img_pan_array = np.concatenate(img_pan_holder, axis = 0)\\r\\n img_ms_array = np.concatenate(img_ms_holder, axis = 0)\\r\\n \\r\\n pred_array = np.argmax(fitted_model.predict([img_ms_array, img_pan_array]), axis = 1)\\r\\n \\r\\n n = 0 \\r\\n for i in range(int(pan_img_height_size / 2), pan_img.shape[0] - int(pan_img_height_size / 2), int(ms_to_pan_ratio)):\\r\\n for j in range(int(pan_img_width_size / 2), pan_img.shape[1] - int(pan_img_width_size / 2), int(ms_to_pan_ratio)):\\r\\n class_layer[i, j] = pred_array[n]\\r\\n n += 1\\r\\n \\r\\n if write:\\r\\n with rasterio.open(output_filename, 'w', **metadata_pan) as dst:\\r\\n dst.write(class_layer)\\r\\n \\r\\n return class_layer\",\n \"def build_resnet101(self):\\n use_batch_norm = self.use_batch_norm\\n\\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\\n is_train = tf.placeholder(tf.bool)\\n\\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\\n conv1_feats = nonlinear(conv1_feats, 'relu')\\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\\n\\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\\n \\n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128) \\n temp = res3a_feats\\n for i in range(1, 4):\\n temp = self.basic_block2(temp, 'res3b'+str(i), 'bn3b'+str(i), is_train, use_batch_norm, 128)\\n res3b3_feats = temp\\n \\n res4a_feats = self.basic_block(res3b3_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\\n temp = res4a_feats\\n for i in range(1, 23):\\n temp = self.basic_block2(temp, 'res4b'+str(i), 'bn4b'+str(i), is_train, use_batch_norm, 256)\\n res4b22_feats = temp\\n\\n res5a_feats = self.basic_block(res4b22_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\\n\\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\\n self.conv_feats = res5c_feats_flat\\n self.conv_feat_shape = [49, 2048]\\n self.num_ctx = 49 \\n self.dim_ctx = 2048\\n\\n self.imgs = imgs\\n self.is_train = is_train\",\n \"def train(images, labels, fold, model_type, batch_size=32, num_epochs=5):\\n num_classes = len(np.unique(labels))\\n (X_train, y_train), (X_val, y_val), (X_test, y_test) = reformatInput(images, labels, fold)\\n X_train = X_train.astype(\\\"float32\\\", casting='unsafe')\\n X_val = X_val.astype(\\\"float32\\\", casting='unsafe')\\n X_test = X_test.astype(\\\"float32\\\", casting='unsafe')\\n # Prepare Theano variables for inputs and targets\\n input_var = T.TensorType('floatX', ((False,) * 5))()\\n target_var = T.ivector('targets')\\n # Create neural network model (depending on first command line parameter)\\n print(\\\"Building model and compiling functions...\\\")\\n # Building the appropriate model\\n if model_type == '1dconv':\\n network = build_convpool_conv1d(input_var, num_classes)\\n elif model_type == 'maxpool':\\n network = build_convpool_max(input_var, num_classes)\\n elif model_type == 'lstm':\\n network = build_convpool_lstm(input_var, num_classes, 100)\\n elif model_type == 'mix':\\n network = build_convpool_mix(input_var, num_classes, 100)\\n elif model_type == 'cnn':\\n input_var = T.tensor4('inputs')\\n network, _ = build_cnn(input_var)\\n network = DenseLayer(lasagne.layers.dropout(network, p=.5),\\n num_units=256,\\n nonlinearity=lasagne.nonlinearities.rectify)\\n network = DenseLayer(lasagne.layers.dropout(network, p=.5),\\n num_units=num_classes,\\n nonlinearity=lasagne.nonlinearities.softmax)\\n else:\\n raise ValueError(\\\"Model not supported ['1dconv', 'maxpool', 'lstm', 'mix', 'cnn']\\\")\\n # Create a loss expression for training, i.e., a scalar objective we want\\n # to minimize (for our multi-class problem, it is the cross-entropy loss):\\n prediction = lasagne.layers.get_output(network)\\n loss = lasagne.objectives.categorical_crossentropy(prediction, target_var)\\n loss = loss.mean()\\n params = lasagne.layers.get_all_params(network, trainable=True)\\n updates = lasagne.updates.adam(loss, params, learning_rate=0.001)\\n # Create a loss expression for validation/testing. The crucial difference\\n # here is that we do a deterministic forward pass through the network,\\n # disabling dropout layers.\\n test_prediction = lasagne.layers.get_output(network, deterministic=True)\\n test_loss = lasagne.objectives.categorical_crossentropy(test_prediction,\\n target_var)\\n test_loss = test_loss.mean()\\n # As a bonus, also create an expression for the classification accuracy:\\n test_acc = T.mean(T.eq(T.argmax(test_prediction, axis=1), target_var),\\n dtype=theano.config.floatX)\\n # Compile a function performing a training step on a mini-batch (by giving\\n # the updates dictionary) and returning the corresponding training loss:\\n train_fn = theano.function([input_var, target_var], loss, updates=updates)\\n # Compile a second function computing the validation loss and accuracy:\\n val_fn = theano.function([input_var, target_var], [test_loss, test_acc])\\n # Finally, launch the training loop.\\n print(\\\"Starting training...\\\")\\n best_validation_accu = 0\\n # We iterate over epochs:\\n for epoch in range(num_epochs):\\n # In each epoch, we do a full pass over the training data:\\n train_err = 0\\n train_batches = 0\\n start_time = time.time()\\n for batch in iterate_minibatches(X_train, y_train, batch_size, shuffle=False):\\n inputs, targets = batch\\n train_err += train_fn(inputs, targets)\\n train_batches += 1\\n # And a full pass over the validation data:\\n val_err = 0\\n val_acc = 0\\n val_batches = 0\\n for batch in iterate_minibatches(X_val, y_val, batch_size, shuffle=False):\\n inputs, targets = batch\\n err, acc = val_fn(inputs, targets)\\n val_err += err\\n val_acc += acc\\n val_batches += 1\\n av_train_err = train_err / train_batches\\n av_val_err = val_err / val_batches\\n av_val_acc = val_acc / val_batches\\n # Then we print the results for this epoch:\\n print(\\\"Epoch {} of {} took {:.3f}s\\\".format(\\n epoch + 1, num_epochs, time.time() - start_time))\\n print(\\\" training loss:\\\\t\\\\t{:.6f}\\\".format(av_train_err))\\n print(\\\" validation loss:\\\\t\\\\t{:.6f}\\\".format(av_val_err))\\n print(\\\" validation accuracy:\\\\t\\\\t{:.2f} %\\\".format(av_val_acc * 100))\\n if av_val_acc > best_validation_accu:\\n best_validation_accu = av_val_acc\\n # After training, we compute and print the test error:\\n test_err = 0\\n test_acc = 0\\n test_batches = 0\\n for batch in iterate_minibatches(X_test, y_test, batch_size, shuffle=False):\\n inputs, targets = batch\\n err, acc = val_fn(inputs, targets)\\n test_err += err\\n test_acc += acc\\n test_batches += 1\\n av_test_err = test_err / test_batches\\n av_test_acc = test_acc / test_batches\\n print(\\\"Final results:\\\")\\n print(\\\" test loss:\\\\t\\\\t\\\\t{:.6f}\\\".format(av_test_err))\\n print(\\\" test accuracy:\\\\t\\\\t{:.2f} %\\\".format(av_test_acc * 100))\\n # Dump the network weights to a file like this:\\n np.savez('weights_lasg_{0}'.format(model_type), *lasagne.layers.get_all_param_values(network))\\n print('-'*50)\\n print(\\\"Best validation accuracy:\\\\t\\\\t{:.2f} %\\\".format(best_validation_accu * 100))\\n print(\\\"Best test accuracy:\\\\t\\\\t{:.2f} %\\\".format(av_test_acc * 100))\",\n \"def model(input_shape, output_dim, num_hidden_units,num_hidden_units_2, num_code_units, filter_size, batch_size=BATCH_SIZE):\\n shape = tuple([None]+list(input_shape[1:]))\\n print(shape)\\n l_in = lasagne.layers.InputLayer(shape=shape)\\n\\n print(\\\"Input shape: \\\",lasagne.layers.get_output_shape(l_in))\\n\\n # print(shaped_units)\\n # shaped_units = shaped_units[0]\\n shaped_units = 2800\\n\\n # print(shape)\\n\\n l_conv2D_1 = lasagne.layers.Conv2DLayer(\\n l_in, \\n num_filters=8,\\n filter_size=filter_size, \\n stride=(1, 1), \\n border_mode=\\\"valid\\\", \\n untie_biases=False, \\n nonlinearity=None,\\n )\\n\\n print(\\\"Conv 2D shape: \\\",lasagne.layers.get_output_shape(l_conv2D_1))\\n\\n l_reshape_1 = lasagne.layers.ReshapeLayer(\\n l_conv2D_1,\\n shape=(([0], -1))\\n )\\n\\n print(\\\"Reshape 1 shape: \\\", lasagne.layers.get_output_shape(l_reshape_1))\\n\\n l_hidden_1 = lasagne.layers.DenseLayer(\\n l_reshape_1,\\n num_units= num_hidden_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 1 shape: \\\", lasagne.layers.get_output_shape(l_hidden_1))\\n\\n l_code_layer = lasagne.layers.DenseLayer(\\n l_hidden_1,\\n num_units=num_code_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Code layer shape: \\\",lasagne.layers.get_output_shape(l_code_layer))\\n\\n l_hidden_2 = lasagne.layers.DenseLayer(\\n l_code_layer,\\n num_units=num_hidden_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 2 shape: \\\",lasagne.layers.get_output_shape(l_hidden_2))\\n\\n l_hidden_3 = lasagne.layers.DenseLayer(\\n l_hidden_2,\\n num_units=shaped_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 3 shape: \\\",lasagne.layers.get_output_shape(l_hidden_3))\\n\\n l_reshape_2 = lasagne.layers.ReshapeLayer(\\n l_hidden_3,\\n shape=(([0],8,7,50))\\n )\\n\\n print(\\\"Reshape 2 shape: \\\",lasagne.layers.get_output_shape(l_reshape_2))\\n\\n l_out = lasagne.layers.Conv2DLayer(\\n l_reshape_2, \\n num_filters=1,\\n filter_size=filter_size, \\n stride=(1, 1), \\n border_mode=\\\"valid\\\", \\n untie_biases=False, \\n nonlinearity=None,\\n )\\n\\n # print(\\\"Deconv shape: \\\",lasagne.layers.get_output_shape(l_deconv2D_1))\\n\\n print(\\\"Output shape: \\\",lasagne.layers.get_output_shape(l_out))\\n\\n return l_out\",\n \"def forward_train(self, img, img_metas, **kwargs):\\n labels = {}\\n labels['trans_inv'] = kwargs['trans_inv']\\n labels['intrinsic_param'] = kwargs['intrinsic_param']\\n labels['joint_root'] = kwargs['joint_root']\\n labels['depth_factor'] = kwargs['depth_factor']\\n labels['target_uvd_29'] = kwargs['target_uvd_29']\\n labels['target_xyz_24'] = kwargs['target_xyz_24']\\n labels['target_weight_24'] = kwargs['target_weight_24']\\n labels['target_weight_29'] = kwargs['target_weight_29']\\n labels['target_xyz_17'] = kwargs['target_xyz_17']\\n labels['target_weight_17'] = kwargs['target_weight_17']\\n labels['target_theta'] = kwargs['target_theta']\\n labels['target_beta'] = kwargs['target_beta']\\n labels['target_smpl_weight'] = kwargs['target_smpl_weight']\\n labels['target_theta_weight'] = kwargs['target_theta_weight']\\n labels['target_twist'] = kwargs['target_twist']\\n labels['target_twist_weight'] = kwargs['target_twist_weight']\\n # flip_output = kwargs.pop('is_flipped', None)\\n\\n for k, _ in labels.items():\\n labels[k] = labels[k].cuda()\\n\\n trans_inv = labels.pop('trans_inv')\\n intrinsic_param = labels.pop('intrinsic_param')\\n joint_root = labels.pop('joint_root')\\n depth_factor = labels.pop('depth_factor')\\n\\n if self.backbone is not None:\\n img = img.cuda().requires_grad_()\\n features = self.backbone(img)\\n features = features[0]\\n else:\\n features = img['features']\\n\\n if self.neck is not None:\\n features = self.neck(features)\\n\\n predictions = self.head(features, trans_inv, intrinsic_param,\\n joint_root, depth_factor, self.smpl)\\n\\n losses = self.compute_losses(predictions, labels)\\n\\n return losses\",\n \"def construct_from_anatomy(self, anet, architecture):\\n # construct conv layer for input -> LGNd\\n self.area_channels['input'] = INPUT_SIZE[0]\\n self.area_size['input'] = INPUT_SIZE[1]\\n \\n out_sigma = 1\\n out_channels = np.floor(anet.find_layer('LGNd','').num/out_sigma/INPUT_SIZE[1]/INPUT_SIZE[2])\\n architecture.set_num_channels('LGNd', '', out_channels)\\n self.area_channels['LGNd'] = out_channels\\n \\n out_size = INPUT_SIZE[1] * out_sigma\\n self.area_size['LGNd'] = out_size\\n \\n convlayer = ConvLayer('input', 'LGNd',\\n ConvParam(in_channels=INPUT_SIZE[0], \\n out_channels=out_channels,\\n gsh=INPUT_GSH,\\n gsw=INPUT_GSW, out_sigma=out_sigma),\\n out_size)\\n self.layers.append(convlayer)\\n \\n # construct conv layers for all other connections\\n G, _ = anet.make_graph()\\n Gtop = nx.topological_sort(G)\\n root = next(Gtop) # get root of graph\\n for i, e in enumerate(nx.edge_bfs(G, root)):\\n \\n in_layer_name = e[0].area+e[0].depth\\n out_layer_name = e[1].area+e[1].depth\\n print('constructing layer %s: %s to %s'%(i, in_layer_name, out_layer_name))\\n \\n in_conv_layer = self.find_conv_target_area(in_layer_name)\\n in_size = in_conv_layer.out_size\\n in_channels = in_conv_layer.params.out_channels\\n \\n out_anat_layer = anet.find_layer(e[1].area, e[1].depth)\\n \\n out_sigma = get_out_sigma(e[0].area, e[0].depth, e[1].area, e[1].depth)\\n out_size = in_size * out_sigma\\n self.area_size[e[1].area+e[1].depth] = out_size\\n\\n if SUBFIELDS:\\n pixel_area = calculate_pixel_area_with_visual_field(architecture, e[1].area, e[1].depth)\\n out_channels = np.floor(out_anat_layer.num / pixel_area)\\n else:\\n out_channels = np.floor(out_anat_layer.num/out_size**2)\\n\\n architecture.set_num_channels(e[1].area, e[1].depth, out_channels)\\n self.area_channels[e[1].area+e[1].depth] = out_channels\\n \\n convlayer = ConvLayer(in_layer_name, out_layer_name, \\n ConvParam(in_channels=in_channels, \\n out_channels=out_channels,\\n gsh=architecture.get_kernel_peak_probability(e[0].area, e[0].depth, e[1].area, e[1].depth),\\n gsw=architecture.get_kernel_width_pixels(e[0].area, e[0].depth, e[1].area, e[1].depth), out_sigma=out_sigma),\\n out_size)\\n \\n self.layers.append(convlayer)\",\n \"def forward_train(self, img, img_metas, **kwargs):\",\n \"def train(trial_num, image_num, filter_num, filter_size, input_size, channel_num, pooling_rate, left_upper_padding, right_lower_padding):\\n\\n input_batch_num = 1\\n batch_num = 2\\n\\n init_filters = np.array(np.random.normal(size=filter_num * channel_num *\\n filter_size*filter_size), dtype=\\\"float32\\\")\\n #init_filters = np.array([1.0] * filter_num * channel_num * filter_size * filter_size, dtype=\\\"float32\\\")\\n init_filters = 0.01 * init_filters.reshape(filter_num, channel_num*filter_size*filter_size)\\n\\n init_hbias = np.array([-0.1] * filter_num, dtype=\\\"float32\\\").reshape(filter_num, 1)\\n\\n init_vbias = np.array([0.0] * channel_num, dtype=\\\"float32\\\").reshape(channel_num, 1)\\n\\n libnvcrbm = __import__(\\\"nvcrbm\\\")\\n cur_filters = libnvcrbm.init(filter_num, filter_size, \\n input_batch_num, input_size, channel_num,\\n pooling_rate, left_upper_padding, right_lower_padding,\\n init_filters, init_hbias, init_vbias)\\n\\n imgs = cPickle.load(open(\\\"../data/kyoto_large_train.pkl\\\", \\\"r\\\"))\\n img_size = imgs[0].shape[0]\\n\\n for trial_idx in xrange(trial_num):\\n for img_idx in xrange(image_num):\\n for batch_idx in xrange(batch_num):\\n row_idx = np.arange(0, input_size) + np.random.random_integers(img_size - 2 * filter_size - input_size) + filter_size - 1\\n col_idx = np.arange(0, input_size) + np.random.random_integers(img_size - 2 * filter_size - input_size) + filter_size - 1\\n #row_idx = np.arange(0, input_size) + 200\\n #col_idx = np.arange(0, input_size) + 200\\n\\n batch_data = imgs[img_idx][row_idx][:,col_idx]\\n batch_data = batch_data - batch_data.mean()\\n batch_data = np.asarray(batch_data.reshape(1, input_size * input_size), dtype=\\\"float32\\\")\\n \\n libnvcrbm.run_batch(trial_idx, img_idx, batch_idx, batch_data)\\n\\n libnvcrbm.print_result()\\n cur_filters = libnvcrbm.get_gpu_filters()\\n dump_filter_image(cur_filters, \\\"../data/kyoto/filters/trial_%d.png\\\" % trial_idx)\\n\\n first_layer = {}\\n first_layer[\\\"filters\\\"] = cur_filters\\n first_layer[\\\"bias\\\"] = libnvcrbm.get_gpu_hbias()\\n cPickle.dump(first_layer, open(\\\"../data/first_layer.dat\\\", \\\"w+\\\"))\",\n \"def build_model(self):\\n\\n # If center crop is valid, output dimensions will be the image dimensions.\\n\\n if self.is_crop:\\n image_dims = [self.output_height, self.output_width, self.c_dim]\\n else:\\n # Otherwise, input dimensions will not be changed.\\n image_dims = [self.input_height, self.input_width, self.c_dim]\\n self.image_dims = image_dims\\n\\n # GAN latent variable.\\n self.z = tf.placeholder(tf.float32, [FLAGS.batch_size + FLAGS.cs_batch_size, self.z_dim], name='z')\\n\\n if not FLAGS.just_cs: # If we are not training only on measurements (non-compressed data is present).\\n self.inputs = tf.placeholder(tf.float32, [\\n FLAGS.batch_size + FLAGS.cs_batch_size] + image_dims, name='real_images')\\n self.sample_inputs = tf.placeholder(tf.float32, [self.sample_num] + image_dims, name='sample_inputs')\\n\\n if self.cs_learning: # If not DCGAN.\\n # Load the A (sampling) matrix.\\n if self.superres_learning:\\n self.A_val = get_A_superres()\\n FLAGS.cs_num_measurements = self.A_val.shape[1]\\n elif self.inpaint_learning:\\n self.A_val = get_A_inpaint()\\n FLAGS.cs_num_measurements = self.A_val.shape[1]\\n else:\\n # Use the same A matrix for all of the experiments.\\n A_path = os.path.join(FLAGS.sampling_mat_dir,\\n '{}_w{}_h{}_m{}_a{}.pckl'.format(FLAGS.dataset, FLAGS.output_width,\\n FLAGS.output_height, FLAGS.cs_num_measurements,\\n FLAGS.a_ind))\\n if os.path.exists(A_path):\\n with open(A_path, 'r') as f:\\n self.A_val = cPickle.load(f)\\n else:\\n raise RuntimeError('[!] No A matrix was found at {}. Run the following command first:\\\\n'\\n 'python main.py --cfg <config> --generate_A'.format(A_path))\\n\\n self.A = tf.constant(self.A_val, dtype=tf.float32)\\n\\n # Batch size for compressed measurements.\\n cs_bsize = FLAGS.cs_batch_size\\n if self.cs_m_and_orig:\\n # In algorithm 2, we use the compressed original samples to\\n # train the discriminator of the measurements too.\\n cs_bsize = cs_bsize + FLAGS.batch_size\\n\\n if self.cs_m_and_orig:\\n print('[#] Solving for both the measurements and original inputs.')\\n # Placeholder for original samples.\\n self.orig_inputs = tf.placeholder(tf.float32, [\\n FLAGS.batch_size] + image_dims, name='real_images')\\n elif FLAGS.just_cs:\\n print('[#] Solving for just the measurements, not the original inputs.')\\n\\n # Placeholder for compressed measurements.\\n self.xs_target = tf.placeholder(tf.float32, [cs_bsize] + self.image_dims, name='target_xs')\\n # Compute y_batch on GPU.\\n self.y_batch = tf.matmul(tf.reshape(self.xs_target, [cs_bsize, -1]), self.A) + \\\\\\n FLAGS.cs_noise_std * tf.random_normal([cs_bsize, FLAGS.cs_num_measurements])\\n\\n if FLAGS.just_cs: # If we are in only compressed measurements mode, the inputs are y_batches.\\n self.inputs = self.y_batch\\n\\n # Batch normalization (deals with poor initialization helps gradient flow).\\n self.d_bn1 = batch_norm(name='d_bn1')\\n self.d_bn2 = batch_norm(name='d_bn2')\\n self.d_bn3 = batch_norm(name='d_bn3')\\n self.g_bn0 = batch_norm(name='g_bn0')\\n self.g_bn1 = batch_norm(name='g_bn1')\\n self.g_bn2 = batch_norm(name='g_bn2')\\n self.g_bn3 = batch_norm(name='g_bn3')\\n\\n # Generator network.\\n self.G = self.generator(self.z, batch_size=FLAGS.cs_batch_size + FLAGS.batch_size)\\n\\n # Discriminator network outputs.\\n self.D, self.D_logits = self.discriminator(self.inputs, batch_size=FLAGS.cs_batch_size + FLAGS.batch_size)\\n\\n def sigmoid_cross_entropy_with_logits(x, y):\\n return tf.nn.sigmoid_cross_entropy_with_logits(logits=x, labels=y)\\n\\n # If both compressed measurements and original images are used.\\n if self.cs_m_and_orig:\\n measured_generator_output = tf.matmul(\\n tf.reshape(self.G, [FLAGS.cs_batch_size + FLAGS.batch_size, FLAGS.n_inputs]), self.A)\\n self.D_, self.D_logits_ = self.discriminator(measured_generator_output, reuse=True,\\n batch_size=FLAGS.cs_batch_size + FLAGS.batch_size)\\n # Create disciriminator for original inputs.\\n self.D_orig, self.D_logits_orig = self.discriminator(self.orig_inputs, reuse=False,\\n batch_size=FLAGS.batch_size, orig=True)\\n # Give the generator to the original inputs discriminator.\\n self.D_orig_, self.D_logits_orig_ = self.discriminator(self.G, reuse=True,\\n batch_size=FLAGS.cs_batch_size + FLAGS.batch_size,\\n orig=True)\\n\\n # Losses and summaries.\\n self.d_loss_orig_real = tf.reduce_mean(\\n sigmoid_cross_entropy_with_logits(self.D_logits_orig, tf.ones_like(self.D_orig)))\\n\\n self.d_loss_orig_fake = tf.reduce_mean(\\n sigmoid_cross_entropy_with_logits(self.D_logits_orig_, tf.zeros_like(self.D_orig_)))\\n\\n self.d_loss_orig_sum = scalar_summary(\\\"d_loss_orig_sum\\\", self.d_loss_orig_real + self.d_loss_orig_fake)\\n\\n self.g_loss_orig = tf.reduce_mean(\\n sigmoid_cross_entropy_with_logits(self.D_logits_orig_, tf.ones_like(self.D_orig_)))\\n\\n # If only compressed measurements are used.\\n elif FLAGS.just_cs:\\n # The measurements on the output of the generator.\\n measured_generator_output = tf.matmul(\\n tf.reshape(self.G, [FLAGS.cs_batch_size + FLAGS.batch_size, FLAGS.n_inputs]), self.A)\\n\\n self.D_, self.D_logits_ = self.discriminator(measured_generator_output, reuse=True,\\n batch_size=FLAGS.cs_batch_size + FLAGS.batch_size)\\n\\n # If only original images are used.\\n else:\\n self.D_, self.D_logits_ = self.discriminator(self.G, reuse=True,\\n batch_size=FLAGS.cs_batch_size + FLAGS.batch_size)\\n\\n # Losses and summaries.\\n self.d_loss_real = tf.reduce_mean(sigmoid_cross_entropy_with_logits(self.D_logits, tf.ones_like(self.D)))\\n self.d_loss_fake = tf.reduce_mean(sigmoid_cross_entropy_with_logits(self.D_logits_, tf.zeros_like(self.D_)))\\n\\n self.g_loss = tf.reduce_mean(sigmoid_cross_entropy_with_logits(self.D_logits_, tf.ones_like(self.D_)))\\n\\n self.d_loss_real_sum = scalar_summary(\\\"d_loss_real\\\", self.d_loss_real)\\n self.d_loss_fake_sum = scalar_summary(\\\"d_loss_fake\\\", self.d_loss_fake)\\n\\n self.d_loss = self.d_loss_real + self.d_loss_fake\\n\\n # If both compressed measurements and original images are used, add the two losses.\\n if self.cs_m_and_orig:\\n self.g_loss = self.g_loss + self.g_loss_orig\\n self.d_loss = self.d_loss + self.d_loss_orig_real + self.d_loss_orig_fake\\n\\n self.g_loss_sum = scalar_summary(\\\"g_loss\\\", self.g_loss)\\n self.d_loss_sum = scalar_summary(\\\"d_loss\\\", self.d_loss)\\n\\n t_vars = tf.global_variables()\\n\\n # Gather variables.\\n self.d_vars = [var for var in t_vars if 'disc' in var.name]\\n self.g_vars = [var for var in t_vars if 'generator' in var.name]\\n self.other_vars = [var for var in tf.global_variables() if 'save_' in var.name]\\n\\n self.save_var_names = self.d_vars + self.g_vars + self.other_vars\\n\\n # Build the Compressed Sensing estimator.\\n if self.cs_learning:\\n self.cs_grad_estimator()\\n\\n # Keep all checkpoints.\\n if self.keep_all:\\n self.saver = tf.train.Saver(self.save_var_names, max_to_keep=None)\\n else:\\n self.saver = tf.train.Saver(self.save_var_names)\",\n \"def _build(self, generation):\\n with tf.variable_scope ('discriminator') as scope:\\n \\n image_unflatten = unflatten_layer ( self.images )\\n gen_unflatten = unflatten_layer ( generation )\\n\\n # Conv Layer 1 - image\\n conv1_out_image, params = conv_2d_layer (\\n input = image_unflatten,\\n neurons = CONV_1_N,\\n filter_size = CONV_1_FILT,\\n name = 'conv_1_img',\\n visualize = True ) \\n pool1_out_img = max_pool_2d_layer ( input = conv1_out_image, name = 'pool_1_img')\\n lrn1_out_img = local_response_normalization_layer (pool1_out_img, name = 'lrn_1_img' ) \\n \\n # Conv Layer 1 - gen\\n conv1_out_gen, params = conv_2d_layer (\\n input = gen_unflatten,\\n neurons = CONV_1_N,\\n filter_size = CONV_1_FILT,\\n params = params,\\n name = 'conv_1_gen',\\n visualize = False )\\n\\n pool1_out_gen = max_pool_2d_layer ( input = conv1_out_gen, name = 'pool_1_gen')\\n lrn1_out_gen = local_response_normalization_layer (pool1_out_gen, name = 'lrn_1_gen' ) \\n process_params(params, name = self.name)\\n c1_params = params\\n\\n\\n\\n\\n\\n # Conv Layer 2 - image\\n conv2_out_image, params = conv_2d_layer (\\n input = lrn1_out_img,\\n neurons = CONV_2_N,\\n filter_size = CONV_2_FILT,\\n name = 'conv_2_img' )\\n\\n pool2_out_img = max_pool_2d_layer ( input = conv2_out_image, name = 'pool_2_img')\\n lrn2_out_img = local_response_normalization_layer (pool2_out_img, name = 'lrn_2_img' ) \\n\\n\\n # Conv Layer 2 - gen\\n conv2_out_gen, params = conv_2d_layer (\\n input = lrn1_out_gen,\\n neurons = CONV_2_N,\\n filter_size = CONV_2_FILT,\\n params = params,\\n name = 'conv_2_gen' )\\n\\n pool2_out_gen = max_pool_2d_layer ( input = conv2_out_gen, name = 'pool_2_gen')\\n lrn2_out_gen = local_response_normalization_layer (pool2_out_gen, name = 'lrn_2_gen' ) \\n process_params(params, name = self.name)\\n c2_params = params\\n\\n # Dropout Layer\\n flat_gen = flatten_layer(lrn2_out_gen)\\n flat_img = flatten_layer(lrn2_out_img)\\n\\n flat_gen_dropout = dropout_layer ( input = flat_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_1_gen') \\n\\n flat_img_dropout = dropout_layer ( input = flat_img,\\n prob = self.dropout_prob,\\n name = 'dropout_1_img') \\n\\n\\n\\n # Dot Product Layer 1 -img\\n fc1_out_img, params = dot_product_layer ( input = flat_img_dropout,\\n neurons = HIDDEN_1,\\n name = 'image_disc_dot_1')\\n # Dot Product Layer 1 - gen\\n fc1_out_gen, params = dot_product_layer ( input = flat_gen_dropout,\\n params = params,\\n neurons = HIDDEN_2,\\n name = 'gen_disc_dot_1')\\n\\n process_params(params, name = self.name)\\n d1_params = params\\n \\n ##\\n fc1_out_gen_dropout = dropout_layer ( input = fc1_out_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_2_gen') \\n fc1_out_img_dropout = dropout_layer ( input = fc1_out_img,\\n prob = self.dropout_prob,\\n name = 'dropout_2_img')\\n\\n # Dot Product Layer 2 -img\\n fc2_out_img, params = dot_product_layer ( input = fc1_out_img_dropout,\\n neurons = HIDDEN_2,\\n name = 'image_disc_dot_2')\\n # Dot Product Layer 2 - gen\\n fc2_out_gen, params = dot_product_layer ( input = fc1_out_gen_dropout,\\n params = params,\\n neurons = HIDDEN_2,\\n name = 'gen_disc_dot_2')\\n process_params(params, name = self.name)\\n d2_params = params\\n\\n ##\\n fc2_out_gen_dropout = dropout_layer ( input = fc2_out_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_3_gen') \\n fc2_out_img_dropout = dropout_layer ( input = fc2_out_img,\\n prob = self.dropout_prob,\\n name = 'dropout_3_img')\\n\\n # Dot Product Layer 1 -img\\n self.real, params = dot_product_layer ( input = fc2_out_img_dropout,\\n neurons = 1,\\n activation = 'sigmoid',\\n name = 'real')\\n # Dot Product Layer 1 -gen\\n self.fake, params = dot_product_layer ( input = fc2_out_gen_dropout,\\n params = params,\\n neurons = 1,\\n activation = 'sigmoid',\\n name = 'fake')\\n\\n process_params(params, name = self.name)\\n d3_params = params\\n self.params = [c1_params, c2_params, d1_params, d2_params, d3_params] \\n\\n\\n with tf.variable_scope (self.name + '_objectives') as scope: \\n with tf.variable_scope( self.name + 'discriminator_obj') as scope: \\n # discriminator_obj = - 0.5 * tf.reduce_mean(log(self.real)) - \\\\\\n # 0.5 * tf.reduce_mean(log(1-self.fake))\\n discriminator_obj = 0.5 * tf.reduce_mean ((self.real-1)**2) + \\\\\\n 0.5 * tf.reduce_mean ((self.fake)**2)\\n tf.summary.scalar('discriminator_obj', discriminator_obj)\\n tf.add_to_collection( self.name + '_objectives', discriminator_obj ) \\n\\n with tf.variable_scope (self.name + '_probabilites') as scope: \\n tf.summary.scalar('fake_probability', tf.reduce_mean(self.fake))\\n tf.summary.scalar('real_probability', tf.reduce_mean(self.real))\\n \\n self._cook_optimizer( \\n lr = DIS_GAN_LR, \\n optimizer = DIS_GAN_OPTIMIZER,\\n l1_coeff = DIS_GAN_L1_COEFF,\\n l2_coeff = DIS_GAN_WEIGHT_DECAY_COEFF)\",\n \"def _build(self):\\n self.autoencoder = autoencoder(\\n images = self.images,\\n name = 'autoencoder')\\n # self.hash = self.autoencoder.hash\\n self.z = tf.placeholder(tf.float32, shape = [None, CODEWORD_LENGTH], \\n name = 'z-layer') \\n with tf.variable_scope('latent_space') as scope:\\n for i in range(CODEWORD_LENGTH):\\n tf.summary.histogram('z_' + str(i) ,self.z[:,i]) \\n tf.summary.histogram('codeword_' + str(i), self.autoencoder.codeword[:,i])\\n self.generator = gan_generator( z = self.z,\\n input_params = self.autoencoder.params,\\n name = 'gan_generator')\\n self.discriminator = gan_discriminator ( images = self.images,\\n generation = self.generator.generation,\\n name = 'gan_discriminator' )\\n self.generator.cook(fake = self.discriminator.fake)\\n mean_z, var_z = tf.nn.moments(self.z, axes=[0])\\n mean_codeword, var_codeword = tf.nn.moments(self.autoencoder.codeword, axes = [0])\\n\\n with tf.variable_scope ('divergence') as scope:\\n tf.summary.scalar( tensor = tf.nn.l2_loss(mean_z-mean_codeword), name = 'mean divergence')\\n tf.summary.scalar( tensor = tf.nn.l2_loss(var_z-var_codeword), name = 'variance divergence')\\n # divergence = self.hash \",\n \"def init():\\n ########################\\n # OPTIONS\\n ########################\\n # Debugging tools\\n global TIMER # displays time of every major step\\n TIMER = True\\n global MONITOR # displays monitoring infos\\n MONITOR = False\\n \\n global directories\\n directories = {'1Face': 'data/1Face/',\\n '2Faces': 'data/2Faces/',\\n '3Faces': 'data/3Faces/',\\n 'test': 'data/test/'}\\n \\n # Opt. swicthes\\n global maxfinder # to find the max dim. amongst the pictures\\n maxfinder = False\\n global ML_mode\\n ML_mode = {'CNN_Train': False,\\n 'CNN_Pred' : True,\\n 'Sampler': True}\\n \\n # Global variables\\n global num_pics\\n num_pics = {'1Face': 0,\\n '2Faces': 0,\\n '3Faces': 0}\\n global labels\\n labels = {'1Face': 0,\\n '2Faces': 1,\\n '3Faces': 2}\\n global num_data\\n num_data = 0\\n global splitsize # Fraction of data to build the training set\\n splitsize = 0.7 \\n global maxheight # Resize the pictures to a power of 2 for CNN (2^8 here)\\n maxheight = 128\\n global maxwidth\\n maxwidth = 128\\n global TreshEdge # Number of consecutive black pixels to define an edge\\n TreshEdge = 2\\n global TreshFace # Number of white pixels to define a face (or large edge)\\n TreshFace = maxheight/16\",\n \"def classify_lenet5(batch_size=500, output_size=20):\\n\\n rng = numpy.random.RandomState(23455)\\n\\n\\n # start-snippet-1\\n x = T.matrix('x') # the data is presented as rasterized images\\n ######################\\n # BUILD ACTUAL MODEL #\\n ######################\\n print '... building the model'\\n\\n # Reshape matrix of rasterized images of shape (batch_size, 28 * 28)\\n # to a 4D tensor, compatible with our LeNetConvPoolLayer\\n # (28, 28) is the size of MNIST images.\\n layer0_input = x.reshape((batch_size, 1, 37, 23))\\n\\n # Construct the first convolutional pooling layer:\\n # filtering reduces the image size to (28-5+1 , 28-5+1) = (24, 24)\\n # maxpooling reduces this further to (24/2, 24/2) = (12, 12)\\n # 4D output tensor is thus of shape (batch_size, nkerns[0], 12, 12)\\n layer0 = LeNetConvPoolLayer(\\n rng,\\n input=layer0_input,\\n image_shape=(batch_size, 1, 37, 23),\\n filter_shape=(20, 1, 4, 2),\\n poolsize=(2, 2),\\n )\\n\\n # layer1 = LeNetConvPoolLayer(\\n # rng,\\n # input=layer0.output,\\n # image_shape=(batch_size, 20, 17, 11),\\n # filter_shape=(50, 20, 4, 2),\\n # poolsize=(2, 2),\\n # )\\n #\\n # layer4 = LeNetConvPoolLayer(\\n # rng,\\n # input=layer1.output,\\n # image_shape=(batch_size, 50, 7, 5),\\n # filter_shape=(100, 50, 4, 2),\\n # poolsize=(2, 2),\\n # )\\n\\n layer2_input = layer0.output.flatten(2)\\n\\n # construct a fully-connected sigmoidal layer\\n layer2 = HiddenLayer(\\n rng,\\n input=layer2_input,\\n n_in=3740,\\n n_out=output_size,\\n activation=T.tanh,\\n use_bias=True\\n )\\n\\n # layer5 = HiddenLayer(\\n # rng,\\n # input=layer2.output,\\n # n_in=200,\\n # n_out=output_size,\\n # activation=T.tanh,\\n # use_bias=True\\n # )\\n\\n # classify the values of the fully-connected sigmoidal layer\\n layer3 = LogisticRegression(input=layer2.output, n_in=output_size, n_out=2)\\n\\n model_params = pickle.load(open('../model/cnn_dist_'+str(output_size)+'.pkl'))\\n #\\n layer0.W = theano.shared(\\n value=numpy.array(\\n model_params[2].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='W',\\n borrow=True\\n )\\n\\n layer0.b = theano.shared(\\n value=numpy.array(\\n model_params[3].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='b',\\n borrow=True\\n )\\n\\n # layer1.W = theano.shared(\\n # value=numpy.array(\\n # model_params[-4].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='W',\\n # borrow=True\\n # )\\n #\\n # layer1.b = theano.shared(\\n # value=numpy.array(\\n # model_params[-3].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='b',\\n # borrow=True\\n # )\\n #\\n # layer4.W = theano.shared(\\n # value=numpy.array(\\n # model_params[-6].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='W',\\n # borrow=True\\n # )\\n #\\n # layer4.b = theano.shared(\\n # value=numpy.array(\\n # model_params[-5].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='b',\\n # borrow=True\\n # )\\n\\n layer2.W = theano.shared(\\n value=numpy.array(\\n model_params[0].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='W',\\n borrow=True\\n )\\n\\n layer2.b = theano.shared(\\n value=numpy.array(\\n model_params[1].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='b',\\n borrow=True\\n )\\n\\n # layer5.W = theano.shared(\\n # value=numpy.array(\\n # model_params[-10].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='W',\\n # borrow=True\\n # )\\n #\\n # layer5.b = theano.shared(\\n # value=numpy.array(\\n # model_params[-9].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='b',\\n # borrow=True\\n # )\\n\\n layer3.W = theano.shared(\\n value=numpy.array(\\n model_params[4].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='W',\\n borrow=True\\n )\\n\\n layer3.b = theano.shared(\\n value=numpy.array(\\n model_params[5].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='b',\\n borrow=True\\n )\\n\\n # params = layer3.params + layer5.params + layer2.params + layer4.params + layer1.params + layer0.params\\n\\n datasets = load_data(None)\\n\\n sets = ['train', 'dev', 'test']\\n dimension = [20000, 20000, 20000]\\n for k in range(3):\\n if k == 0:\\n classify_set_x, classify_set_y, classify_set_z, classify_set_m, classify_set_c, classify_set_b= datasets[k]\\n else:\\n classify_set_x, classify_set_y, classify_set_z= datasets[k]\\n\\n # compute number of minibatches for training, validation and testing\\n n_classify_batches = classify_set_x.get_value(borrow=True).shape[0]\\n n_classify_batches /= batch_size\\n\\n # allocate symbolic variables for the data\\n index = T.lscalar() # index to a [mini]batch\\n classify = theano.function(\\n [index],\\n layer2.output,\\n givens={\\n x: classify_set_x[index * batch_size: (index + 1) * batch_size],\\n }\\n )\\n\\n r = []\\n\\n for i in xrange(n_classify_batches):\\n m = classify(i)\\n r.extend(m)\\n r = np.array(r)\\n print r.shape\\n r = np.append(r, np.reshape(classify_set_y.eval(),(dimension[k], 1)), 1)\\n numpy.savetxt('../extractedInformation/cnn_dist_'+str(output_size)+'/'+sets[k]+'.csv', r, delimiter=\\\",\\\")\",\n \"def build_model():\\n mdl = Sequential()\\n\\n # normalization\\n mdl.add(Lambda(lambda x: x/128. - 1, input_shape=IMAGE_SHAPE, name=\\\"input\\\"))\\n\\n # trim image\\n mdl.add(Lambda(lambda x: x[:, 10:-10, :, :]))\\n\\n # convolutions\\n mdl.add(Convolution2D(24, 5, 5, subsample=(2, 2), border_mode='same',))\\n mdl.add(MaxPooling2D(pool_size=(2, 2)))\\n mdl.add((Dropout(0.5)))\\n mdl.add(Activation('relu'))\\n\\n mdl.add(Convolution2D(36, 5, 5, subsample=(2, 2), border_mode='same',))\\n mdl.add(MaxPooling2D(pool_size=(2, 2)))\\n mdl.add((Dropout(0.5)))\\n mdl.add(Activation('relu'))\\n\\n mdl.add(Convolution2D(48, 5, 5, subsample=(2, 2), border_mode='same',))\\n mdl.add(MaxPooling2D(pool_size=(2, 2)))\\n mdl.add((Dropout(0.5)))\\n mdl.add(Activation('relu'))\\n\\n mdl.add(Convolution2D(64, 3, 3, subsample=(1, 1), border_mode='same',))\\n mdl.add((Dropout(0.5)))\\n mdl.add(Activation('relu'))\\n\\n mdl.add(Convolution2D(64, 3, 3, subsample=(1, 1), border_mode='same',))\\n mdl.add((Dropout(0.5)))\\n mdl.add(Activation('relu'))\\n\\n mdl.add(Flatten())\\n\\n mdl.add(Dense(128, activation='relu'))\\n mdl.add(Dense(64, activation='relu'))\\n mdl.add(Dense(1, name=\\\"output\\\"))\\n\\n mdl.summary()\\n\\n return mdl\",\n \"def prep_input(im, acc=4):\\n mask = cs.cartesian_mask(im.shape, acc, sample_n=8)\\n im_und, k_und = cs.undersample(im, mask, centred=False, norm='ortho')\\n im_gnd_l = to_lasagne_format(im)\\n im_und_l = to_lasagne_format(im_und)\\n k_und_l = to_lasagne_format(k_und)\\n mask_l = to_lasagne_format(mask, mask=True)\\n\\n return im_und_l, k_und_l, mask_l, im_gnd_l\",\n \"def image_inference(self, model_name: str, input_data):\\n exec_net, image_input, image_info_input, (n, c, h, w), postprocessor = self.model_loading.load_model(model_name)\\n cap, visualizer, tracker, presenter = self.image_visualizer.visualizer(input_data,model_name)\\n\\n while cap.isOpened():\\n ret, frame = cap.read()\\n if not ret:\\n break\\n # Resize the image to keep the same aspect ratio and to fit it to a window of a target size.\\n scale_x = scale_y = min(h / frame.shape[0], w / frame.shape[1])\\n input_image = cv2.resize(frame, None, fx=scale_x, fy=scale_y)\\n\\n input_image_size = input_image.shape[:2]\\n input_image = np.pad(input_image, ((0, h - input_image_size[0]),\\n (0, w - input_image_size[1]),\\n (0, 0)),\\n mode='constant', constant_values=0)\\n # Change data layout from HWC to CHW.\\n input_image = input_image.transpose((2, 0, 1))\\n input_image = input_image.reshape((n, c, h, w)).astype(np.float32)\\n input_image_info = np.asarray([[input_image_size[0], input_image_size[1], 1]], dtype=np.float32)\\n # Run the net.\\n feed_dict = {image_input: input_image}\\n if image_info_input:\\n feed_dict[image_info_input] = input_image_info\\n outputs = exec_net.infer(feed_dict)\\n # Parse detection results of the current request\\n scores, classes, boxes, masks = postprocessor(\\n outputs, scale_x, scale_y, *frame.shape[:2], h, w, 0.5)\\n os.remove(input_data.filename)\\n class_labels = self.fetch_labels.get_labels(model_name)\\n\\n t = 0\\n for key2 in [class_labels[i] for i in classes]:\\n x1 = str(boxes[t][0])\\n y1 = str(boxes[t][1])\\n x2 = str(boxes[t][2])\\n y2 = str(boxes[t][3])\\n\\n if key2 in self.prediction.keys():\\n value_init = self.prediction.get(key2)\\n self.prediction[key2] = x1, y1, x2, y2\\n value = value_init, self.prediction.get(key2)\\n self.prediction[key2] = value\\n\\n else:\\n self.prediction[key2] = x1, y1, x2, y2\\n\\n t = t + 1\\n\\n with open('./final_json.json', 'w') as file:\\n json.dump(self.prediction, file)\\n\\n with open('./final_json.json','r') as file:\\n json_object = json.load(file)\\n\\n return json_object\\n cv2.destroyAllWindows()\\n cap.release()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5769102","0.57382643","0.57309794","0.5680739","0.5673918","0.5655157","0.5644211","0.56367666","0.5591521","0.55862665","0.5567598","0.5562491","0.55506796","0.5523746","0.5522362","0.54794484","0.54794043","0.54676753","0.54660183","0.5465986","0.54633445","0.5418962","0.5415946","0.54075754","0.5407216","0.5390388","0.53879166","0.53753597","0.53632957","0.5357833","0.5343479","0.53365195","0.5331737","0.5328393","0.53271663","0.5317986","0.5307598","0.53063285","0.53025764","0.5291795","0.5291692","0.5290088","0.5289116","0.52817","0.52793723","0.52686054","0.5259683","0.525339","0.52490604","0.5248791","0.5247943","0.52410203","0.52282447","0.52113986","0.52068925","0.5204913","0.52020305","0.5201089","0.51926005","0.51912993","0.5185243","0.51849043","0.5182834","0.5180678","0.5179826","0.5177971","0.5177331","0.5173015","0.5171466","0.51700366","0.5169717","0.5166483","0.5160812","0.5158056","0.51561034","0.5155336","0.51511496","0.51479673","0.5146184","0.5137095","0.5136865","0.5126982","0.5125332","0.5124483","0.51188475","0.51187253","0.5115758","0.511446","0.5112534","0.5111728","0.5109612","0.51081675","0.5107867","0.5105292","0.5103043","0.5101095","0.510073","0.5096799","0.5091603","0.50831914","0.50803"],"string":"[\n \"0.5769102\",\n \"0.57382643\",\n \"0.57309794\",\n \"0.5680739\",\n \"0.5673918\",\n \"0.5655157\",\n \"0.5644211\",\n \"0.56367666\",\n \"0.5591521\",\n \"0.55862665\",\n \"0.5567598\",\n \"0.5562491\",\n \"0.55506796\",\n \"0.5523746\",\n \"0.5522362\",\n \"0.54794484\",\n \"0.54794043\",\n \"0.54676753\",\n \"0.54660183\",\n \"0.5465986\",\n \"0.54633445\",\n \"0.5418962\",\n \"0.5415946\",\n \"0.54075754\",\n \"0.5407216\",\n \"0.5390388\",\n \"0.53879166\",\n \"0.53753597\",\n \"0.53632957\",\n \"0.5357833\",\n \"0.5343479\",\n \"0.53365195\",\n \"0.5331737\",\n \"0.5328393\",\n \"0.53271663\",\n \"0.5317986\",\n \"0.5307598\",\n \"0.53063285\",\n \"0.53025764\",\n \"0.5291795\",\n \"0.5291692\",\n \"0.5290088\",\n \"0.5289116\",\n \"0.52817\",\n \"0.52793723\",\n \"0.52686054\",\n \"0.5259683\",\n \"0.525339\",\n \"0.52490604\",\n \"0.5248791\",\n \"0.5247943\",\n \"0.52410203\",\n \"0.52282447\",\n \"0.52113986\",\n \"0.52068925\",\n \"0.5204913\",\n \"0.52020305\",\n \"0.5201089\",\n \"0.51926005\",\n \"0.51912993\",\n \"0.5185243\",\n \"0.51849043\",\n \"0.5182834\",\n \"0.5180678\",\n \"0.5179826\",\n \"0.5177971\",\n \"0.5177331\",\n \"0.5173015\",\n \"0.5171466\",\n \"0.51700366\",\n \"0.5169717\",\n \"0.5166483\",\n \"0.5160812\",\n \"0.5158056\",\n \"0.51561034\",\n \"0.5155336\",\n \"0.51511496\",\n \"0.51479673\",\n \"0.5146184\",\n \"0.5137095\",\n \"0.5136865\",\n \"0.5126982\",\n \"0.5125332\",\n \"0.5124483\",\n \"0.51188475\",\n \"0.51187253\",\n \"0.5115758\",\n \"0.511446\",\n \"0.5112534\",\n \"0.5111728\",\n \"0.5109612\",\n \"0.51081675\",\n \"0.5107867\",\n \"0.5105292\",\n \"0.5103043\",\n \"0.5101095\",\n \"0.510073\",\n \"0.5096799\",\n \"0.5091603\",\n \"0.50831914\",\n \"0.50803\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83157,"cells":{"query":{"kind":"string","value":"vulnarable to future updates;"},"document":{"kind":"string","value":"def _reorder_features(outputs: t.Dict[str, torch.Tensor]) -> t.Dict[str, torch.Tensor]:\r\n results = collections.OrderedDict()\r\n keys = outputs.keys()\r\n\r\n res_keys: t.List = sorted([key for key in keys if 'res' in key])\r\n p_keys: t.List = sorted([key for key in keys if 'p' in key], reverse=True)\r\n\r\n new_keys = res_keys + p_keys\r\n\r\n for key in new_keys:\r\n results.update({key: outputs[key]})\r\n\r\n return results"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def update( ):\r\n pass","def update():","def update():","def _update(self):\n pass","def update(self):","def update(self):","def update(self):","def dummy_update( self ):\r\n pass","def onUpdated(self):","def update(self):\r\n pass","def update(self) -> None:\n ...","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self)->None:\n pass","def update(self, *args, **kwargs):","def update(self) -> None:\n pass","def _update(self, count=True, forced=False):","def update(self):\n\n pass","def beforeUpdate(self):","def Update(self):\r\n\r\n # does nothing\r\n pass","def update_data():\n pass","def update(self):\n raise NotImplementedError","def update(self) -> None:\n pass","def update(self) -> None:\n pass","def after_update(self, obj, st):\n pass","def before_update(self, obj, st):\n pass","def async_update(self):","def pre_update(self, **values):\r\n pass","def update(self):\n pass","def update(self):\n # default implementation is to do nothing.","def update_E(self):","def update(self):\n raise NotImplementedError()","def update(self, *args, **kw):\n pass","def update(self):\n return True","def update(*args):","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self,update_flags):\n pass","def update(self, params):","def acUpdate(deltaT):#-------------------------------- AC UPDATE\n pass # -> Delete this line if you do something here !","def gen_update(self, TL):\r\n pass","def after_update(self, *args):\n raise NotImplementedError","def update(self, *args, **kwargs):\n pass","def update(self, *args, **kwargs):\n pass","def update(self, *args, **kwargs):\n pass","def update(self, v, r):\n pass","def compute_upd(self, move):","def update(self, initial, follows):","def __upgrade(self):","def force_update(self):\n return True","def upgrade(self):","def upgrade(self):","async def async_update(self):","def update_fodder(self):\n pass","def update(self, data):\n pass","def update(self, data):\n pass","def update(self, data):\n pass","def update(self, data):\n pass","def update(self, args):\n pass","def update(src):","def test_update(self):\n # this is tested graphically, as it is UI\n pass","def _post_sync(self):","def update(self, dt):","def update(self, dt):","def updates(f):\n f.updates = True\n return f","def _measurement_update(self):\n pass","def test_update_case(self):\n pass","def on_update(self):\n raise NotImplemented(\"on_update method should be implemented.\")","def change():","def _notify_update(self, cuds_object):","def _can_do_updates(self):\n return True","def update(self, *args, **kwargs):\n # callable, but does nothing by default","def _dirty (self):\n pass","def _Refresh(self):\n raise NotImplementedError","def handle_actual_updated(self):\n self._actual_updated()","def prob_update(self):\n pass","def changed(self):\n\t\tpass","def update_original_data(self):\n pass","def update(cls) -> None:\n raise NotImplementedError","def Update(self) -> T:","def exogenous_change(self):\n pass","def exogenous_change(self):\n pass","def exogenous_change(self):\n pass","def update(self, iteration):\n pass"],"string":"[\n \"def update( ):\\r\\n pass\",\n \"def update():\",\n \"def update():\",\n \"def _update(self):\\n pass\",\n \"def update(self):\",\n \"def update(self):\",\n \"def update(self):\",\n \"def dummy_update( self ):\\r\\n pass\",\n \"def onUpdated(self):\",\n \"def update(self):\\r\\n pass\",\n \"def update(self) -> None:\\n ...\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self)->None:\\n pass\",\n \"def update(self, *args, **kwargs):\",\n \"def update(self) -> None:\\n pass\",\n \"def _update(self, count=True, forced=False):\",\n \"def update(self):\\n\\n pass\",\n \"def beforeUpdate(self):\",\n \"def Update(self):\\r\\n\\r\\n # does nothing\\r\\n pass\",\n \"def update_data():\\n pass\",\n \"def update(self):\\n raise NotImplementedError\",\n \"def update(self) -> None:\\n pass\",\n \"def update(self) -> None:\\n pass\",\n \"def after_update(self, obj, st):\\n pass\",\n \"def before_update(self, obj, st):\\n pass\",\n \"def async_update(self):\",\n \"def pre_update(self, **values):\\r\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n # default implementation is to do nothing.\",\n \"def update_E(self):\",\n \"def update(self):\\n raise NotImplementedError()\",\n \"def update(self, *args, **kw):\\n pass\",\n \"def update(self):\\n return True\",\n \"def update(*args):\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self,update_flags):\\n pass\",\n \"def update(self, params):\",\n \"def acUpdate(deltaT):#-------------------------------- AC UPDATE\\n pass # -> Delete this line if you do something here !\",\n \"def gen_update(self, TL):\\r\\n pass\",\n \"def after_update(self, *args):\\n raise NotImplementedError\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def update(self, v, r):\\n pass\",\n \"def compute_upd(self, move):\",\n \"def update(self, initial, follows):\",\n \"def __upgrade(self):\",\n \"def force_update(self):\\n return True\",\n \"def upgrade(self):\",\n \"def upgrade(self):\",\n \"async def async_update(self):\",\n \"def update_fodder(self):\\n pass\",\n \"def update(self, data):\\n pass\",\n \"def update(self, data):\\n pass\",\n \"def update(self, data):\\n pass\",\n \"def update(self, data):\\n pass\",\n \"def update(self, args):\\n pass\",\n \"def update(src):\",\n \"def test_update(self):\\n # this is tested graphically, as it is UI\\n pass\",\n \"def _post_sync(self):\",\n \"def update(self, dt):\",\n \"def update(self, dt):\",\n \"def updates(f):\\n f.updates = True\\n return f\",\n \"def _measurement_update(self):\\n pass\",\n \"def test_update_case(self):\\n pass\",\n \"def on_update(self):\\n raise NotImplemented(\\\"on_update method should be implemented.\\\")\",\n \"def change():\",\n \"def _notify_update(self, cuds_object):\",\n \"def _can_do_updates(self):\\n return True\",\n \"def update(self, *args, **kwargs):\\n # callable, but does nothing by default\",\n \"def _dirty (self):\\n pass\",\n \"def _Refresh(self):\\n raise NotImplementedError\",\n \"def handle_actual_updated(self):\\n self._actual_updated()\",\n \"def prob_update(self):\\n pass\",\n \"def changed(self):\\n\\t\\tpass\",\n \"def update_original_data(self):\\n pass\",\n \"def update(cls) -> None:\\n raise NotImplementedError\",\n \"def Update(self) -> T:\",\n \"def exogenous_change(self):\\n pass\",\n \"def exogenous_change(self):\\n pass\",\n \"def exogenous_change(self):\\n pass\",\n \"def update(self, iteration):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7782488","0.77389413","0.77389413","0.7653784","0.75854903","0.75854903","0.75854903","0.7537543","0.73864686","0.7356516","0.7338992","0.72717035","0.72717035","0.72717035","0.72717035","0.72717035","0.72717035","0.72717035","0.72717035","0.72717035","0.72717035","0.72717035","0.72717035","0.72717035","0.72717035","0.72717035","0.7228914","0.7049527","0.70449686","0.69872534","0.69782424","0.6965266","0.6906798","0.6859927","0.6846466","0.6834176","0.6834176","0.68073","0.6801649","0.67767","0.6775882","0.6736804","0.67277855","0.6723655","0.66741043","0.6674053","0.66185373","0.65948224","0.6579744","0.6579744","0.6579744","0.6579744","0.6579744","0.6579744","0.6511702","0.65111625","0.6484298","0.64305615","0.6407214","0.6406406","0.6406406","0.6406406","0.6401494","0.639542","0.6371802","0.6364795","0.63546073","0.6319103","0.6319103","0.63074857","0.6303163","0.6294669","0.6294669","0.6294669","0.6294669","0.6279079","0.6267391","0.6265749","0.6231539","0.6214805","0.6214805","0.6208051","0.62020797","0.61891776","0.61877245","0.6186314","0.6158839","0.61434156","0.6143068","0.61254936","0.6123451","0.61109936","0.6082729","0.6066472","0.60638577","0.60616076","0.60531753","0.6049796","0.6049796","0.6049796","0.60479945"],"string":"[\n \"0.7782488\",\n \"0.77389413\",\n \"0.77389413\",\n \"0.7653784\",\n \"0.75854903\",\n \"0.75854903\",\n \"0.75854903\",\n \"0.7537543\",\n \"0.73864686\",\n \"0.7356516\",\n \"0.7338992\",\n \"0.72717035\",\n \"0.72717035\",\n \"0.72717035\",\n \"0.72717035\",\n \"0.72717035\",\n \"0.72717035\",\n \"0.72717035\",\n \"0.72717035\",\n \"0.72717035\",\n \"0.72717035\",\n \"0.72717035\",\n \"0.72717035\",\n \"0.72717035\",\n \"0.72717035\",\n \"0.72717035\",\n \"0.7228914\",\n \"0.7049527\",\n \"0.70449686\",\n \"0.69872534\",\n \"0.69782424\",\n \"0.6965266\",\n \"0.6906798\",\n \"0.6859927\",\n \"0.6846466\",\n \"0.6834176\",\n \"0.6834176\",\n \"0.68073\",\n \"0.6801649\",\n \"0.67767\",\n \"0.6775882\",\n \"0.6736804\",\n \"0.67277855\",\n \"0.6723655\",\n \"0.66741043\",\n \"0.6674053\",\n \"0.66185373\",\n \"0.65948224\",\n \"0.6579744\",\n \"0.6579744\",\n \"0.6579744\",\n \"0.6579744\",\n \"0.6579744\",\n \"0.6579744\",\n \"0.6511702\",\n \"0.65111625\",\n \"0.6484298\",\n \"0.64305615\",\n \"0.6407214\",\n \"0.6406406\",\n \"0.6406406\",\n \"0.6406406\",\n \"0.6401494\",\n \"0.639542\",\n \"0.6371802\",\n \"0.6364795\",\n \"0.63546073\",\n \"0.6319103\",\n \"0.6319103\",\n \"0.63074857\",\n \"0.6303163\",\n \"0.6294669\",\n \"0.6294669\",\n \"0.6294669\",\n \"0.6294669\",\n \"0.6279079\",\n \"0.6267391\",\n \"0.6265749\",\n \"0.6231539\",\n \"0.6214805\",\n \"0.6214805\",\n \"0.6208051\",\n \"0.62020797\",\n \"0.61891776\",\n \"0.61877245\",\n \"0.6186314\",\n \"0.6158839\",\n \"0.61434156\",\n \"0.6143068\",\n \"0.61254936\",\n \"0.6123451\",\n \"0.61109936\",\n \"0.6082729\",\n \"0.6066472\",\n \"0.60638577\",\n \"0.60616076\",\n \"0.60531753\",\n \"0.6049796\",\n \"0.6049796\",\n \"0.6049796\",\n \"0.60479945\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83158,"cells":{"query":{"kind":"string","value":"unsafe to use, will download all models;"},"document":{"kind":"string","value":"def _create_model_out_dictkeys():\r\n model_names = []\r\n result_keys = []\r\n for model_name in model_zoo._ModelZooUrls.CONFIG_PATH_TO_URL_SUFFIX.keys():\r\n try:\r\n print(model_name, \":\")\r\n select_model(model_name)\r\n result = get_features_by_image_path(\"./sample.jpg\")\r\n model_names.append(model_name)\r\n result_keys.append(list(result.keys()))\r\n except RuntimeError as t:\r\n print(t)\r\n\r\n pd.DataFrame(list(zip(model_names, result_keys))).to_csv(\"d2_model_out_dictkeys.csv\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def download_all_models() -> None:\n model_keys = ModelInfo.get_all_models()\n for model_key in model_keys:\n download_model(model_key)","def download_models_and_data():\n\n for file in DATA_FILES:\n download_file(file[\"url\"], file[\"path\"])","def _retrieve_models(local=True):\n # Check if the download folder exists\n def _get_meta_data(model_name, file):\n return {\n \"data\": {\n \"id\": model_name,\n \"name\": model_name,\n \"description\": model_name,\n \"filename\": os.path.join(\n app.config[\"DOWNLOAD_DIR\"], file),\n \"created\": time.ctime(os.path.getctime(\n os.path.join(\n app.config[\"DOWNLOAD_DIR\"],\n file))),\n \"modified\": time.ctime(os.path.getmtime(\n os.path.join(\n app.config[\"DOWNLOAD_DIR\"],\n file)))\n }\n }\n\n if not os.path.exists(app.config[\"DOWNLOAD_DIR\"]):\n os.makedirs(app.config[\"DOWNLOAD_DIR\"])\n\n if not local:\n # Fetch from a Nexus-hosted catalog\n resources = app.forge.search({\"type\": \"EmbeddingModel\"})\n for resource in resources:\n app.models[resource.name] = {\n \"data\": digest_model_data(resource),\n }\n app.forge.download(\n resource, \"distribution.contentUrl\",\n app.config[\"DOWNLOAD_DIR\"])\n\n pipeline_path = os.path.join(\n app.config[\"DOWNLOAD_DIR\"],\n resource.distribution.name)\n app.models[resource.name][\"object\"] = EmbeddingPipeline.load(\n pipeline_path,\n embedder_interface=GraphElementEmbedder,\n embedder_ext=\"zip\")\n\n # Clear the downloads dir\n for f in os.listdir(app.config[\"DOWNLOAD_DIR\"]):\n try:\n os.remove(os.path.join(app.config[\"DOWNLOAD_DIR\"], f))\n except Exception:\n shutil.rmtree(os.path.join(app.config[\"DOWNLOAD_DIR\"], f))\n else:\n # Fetch from a local dir\n for (_, dirs, files) in os.walk(app.config[\"DOWNLOAD_DIR\"]):\n for path in dirs + files:\n if path[0] != \".\":\n match = re.match(r\"(.*)\\.zip\", path)\n if match:\n model_name = match.groups()[0]\n else:\n model_name = path\n app.models[model_name] = _get_meta_data(model_name, path)\n pipeline_path = os.path.join(\n app.config[\"DOWNLOAD_DIR\"], path)\n app.models[model_name][\"object\"] = EmbeddingPipeline.load(\n pipeline_path,\n embedder_interface=GraphElementEmbedder,\n embedder_ext=\"zip\")\n break","def test_downloadAllModels(self):\n\t\tmodelOptions = cancerscope.config.getmodelsdict() ## MODIFIED FROM cancerscope.getmodelsdict() on March 17 2020\n\t\tassert len(modelOptions.keys()) == 5\n\t\tscope_ensemble_obj = cancerscope.scope_ensemble.scope() ## MODIFIED FROM cancerscope.scope() on March 17 2020\n\t\t#my_downloaded_models = cancerscope.get_models.getmodel() ## This should retrieve all models\n\t\tmy_downloaded_models = scope_ensemble_obj.downloaded_models_dict\n\t\tassert len(my_downloaded_models.keys()) == 5\n\t\tfor k_model in my_downloaded_models.keys():\n\t\t\tmodelname_address = my_downloaded_models[k_model]\n\t\t\t\"\"\"For each model, test if model dir exists, then set up the model once\"\"\"\n\t\t\tself.assertTrue(os.path.isdir(modelname_address))\n\t\t\tself.assertTrue(os.path.exists(\"\".join([modelname_address, \"/lasagne_bestparams.npz\"])))\n\t\t\t\"\"\"TO BE FIXED: THEN SET UP MODEL (memory issues in travis (3 GB RAM there)\"\"\"\n\t\t\t#lmodel = cancerscope.scopemodel(modelname_address_pair[k_model])\n\t\t\t#lmodel.fit()\n\t\t\t#self.assertEqual(len(lmodel.features), 17688)\n\t\t\t#del lmodel; lmodel=None\n\t\t\t#for i in range(3):\n\t\t\t#\tgc.collect()","def download_files(self):","def test_downloadModel(self):\n\t\tmodel_in = \"\"\n\t\tquery_localdirs = cancerscope.get_models.findmodel(os.path.dirname(cancerscope.__file__), \"v1_rm500\")\n\t\tif query_localdirs is not None:\n\t\t\tmodel_in = query_localdirs[\"v1_rm500\"]\n\t\telse:\n\t\t\tmodel_in = cancerscope.get_models.downloadmodel(model_label=\"v1_rm500\")\n\t\t\n\t\tself.assertTrue(os.path.isdir(model_in))\n\t\tself.assertTrue(os.path.exists(\"\".join([model_in, \"/lasagne_bestparams.npz\"])))\n\t\t\n\t\t\"\"\"Test if model can be setup correctly\"\"\"\n\t\tlmodel = cancerscope.scopemodel(model_in)\n\t\tlmodel.fit()\n\t\n\t\tself.assertEqual(len(lmodel.features), 17688)","def download_model():\n logging.info(\"[genreml] Downloading model...\")\n with urllib.request.urlopen(config.FMAModelConfig.FMA_MODEL_URL) as f:\n data = f.read()\n open(config.FMAModelConfig.FMA_MODEL_PATH, 'wb').write(data)\n logging.info(\"[genreml] Model download complete\")","def download_all(): #@save\n for name in DATA_HUB:\n download(name)","def maybe_download():\n\n print(\"Downloading Inception 5h Model ...\")\n download.maybe_download_and_extract(url=data_url, download_dir=data_dir)","def load_models(self, models, iteration = None):\n print(\"NOT IMPLEMENTED YET\")","def download_model(\\\n download_base='http://download.tensorflow.org/models/object_detection/', \\\n model_name='ssd_mobilenet_v1_coco_11_06_2017'\\\n ):\n\n # add tar gz to the end of file name\n model_file = model_name + '.tar.gz'\n\n try:\n opener = urllib.request.URLopener()\n opener.retrieve(download_base + model_file, \\\n model_file)\n tar_file = tarfile.open(model_file)\n for f in tar_file.getmembers():\n file_name = os.path.basename(f.name)\n if 'frozen_inference_graph.pb' in file_name:\n tar_file.extract(f, os.getcwd())\n except Exception as e:\n raise","def opt_get_all_models_rest_api():\n return retrieve_all_models()","def fetch_data():\n for category in CHEATSHEETS.items():\n subprocess.call(f'curl -o {PATH}{category[0] + \".csv\"} {category[1]}', shell=True)\n\n index = -1\n for filename in os.listdir(PATH):\n for idx, row in pd.read_csv(PATH + filename, on_bad_lines='skip').replace(np.nan, '').iterrows():\n name = row['Model']\n url = REDIRECT_URL + name.lower()\n category = filename.split('.')[0]\n featurizers = row['Acceptable Featurizers'].split(' ') if row['Acceptable Featurizers'] != '' else []\n backends = ['PyTorch' if item in {\"PTorch\", \"Torch\", \"PyTorch \"} else item for item in row['Backend'].split('/')]\n types = row['Type'] if filename != 'general.csv' else row['Classifier/Regressor']\n types = types.split('/') if filename == 'material.csv' else types.split('/ ')\n index += 1\n\n backend_list.append(backends)\n type_list.append(types)\n featurizer_list.append(featurizers)\n model_list.append(Model(name, url, category, featurizers, backends, types, index))","def build_models():\n train_models()\n return build_response.sent_ok()","def download_model(name: str) -> str:\n model_name, model_type, model_url = ModelInfo.get_model_info(name)\n model_path = _create_dirs(model_name)\n if model_type == \"single\":\n model_path = _download_file(model_url, model_path)\n elif model_type == \"zip\":\n model_path = _download_zip_model(model_url, model_path)\n else:\n print(f\"model type {model_type} not yet implemented\")\n model_path = \"\"\n return model_path","def download(self):\n if not os.path.exists(self.pkg_dir):\n os.makedirs(self.pkg_dir)\n\n url = self.metadata_pkg[\"url\"]\n\n # Download modelpkg only if not already downloaded.\n if os.path.exists(self.file_path):\n self.is_downloaded = True\n else:\n print(f\"Fetching {os.path.basename(self.file_path)} model package from {url} to {self.file_path}\", flush=True)\n r = requests.get(url, stream=True)\n with open(self.file_path, \"wb\") as file_out:\n for chunk in r.iter_content(chunk_size=2048):\n file_out.write(chunk)\n r.close()\n self.is_downloaded = True","def fetch_models(self):\n if self.model_pool is None:\n print(\"Please train a model first.\", file=STDE)\n EXIT(1)\n else:\n return [copy.deepcopy(m.steps[-1][-1]) for m in self.model_pool]","def models() -> list[str]:\n return list(models_url.keys())","def download(fnames):\n download_path = Path('./models')\n if not download_path.exists() or not download_path.is_dir():\n print('The directory \\'models\\' does not exist!')\n print('Please ensure you are in the top level of the visual-attention-networks repository')\n print(' and that the \\'models\\' directory exists')\n sys.exit()\n\n server_url = 'https://github.com/davidmascharka/tbd-nets/releases/download/v1.0/'\n if isinstance(fnames, str): # a single file\n fnames = [fnames]\n for fname in fnames:\n if (download_path / fname).exists():\n print('Skipping {}: the file already exists'.format(fname))\n continue\n\n print('Downloading {}'.format(fname))\n urlretrieve(server_url + fname, str((download_path/fname).absolute()), _download_info)\n print('Finished')","def download_ckpt(model_name):\n with open (\"./utils/models.json\", \"r\") as f:\n url = json.loads(f.read())[model_name] \n model_name_tar = url.split(\"/\")[-1]\n model_name_dir = url.split(\"/\")[-1].split(\".\")[0]\n if not chk_model(model_name_dir):\n try: \n print('Downloading %s to %s...' % (url, model_name_tar))\n os.system(\"wget {}\".format(str(url))) \n os.system(\"tar xvf {}\".format(str(model_name_tar))) \n os.remove(model_name_tar)\n # assert os.path.exists()# check \n return model_name_dir\n except Exception as e:\n print(e)\n return model_name_dir","def download_models_from_modbase( query ,\n out_directory = 'modbase_models' , root_filename = '' ,\n dataset = '' , get_alignment = True , write_summary = True ,\n display = True ):\n # url\n url = 'http://salilab.org/modbase/retrieve/modbase'\n \n # format the search query\n print 'searching modbase for \\\"' + query +'\\\"'\n url += '?databaseID=' + query\n # currently unused...so why put it here?\n #for i in search_options.keys():\n # url += '&' + i +'='+ search_options[i]\n \n # the dataset\n# if not 'dataset' in search_options.keys() and dataset:\n if dataset:\n url += '&dataset=' + dataset\n\n # go get the results\n print 'obtaining model results from:\\n\\t' + url\n raw_stream = urllib2.urlopen( url + '&type=model' ) \n print 'finished downloading models, summarizing the results...'\n \n # parse the results\n results = xml_parse( raw_stream )\n\n # check if empty\n if not len( results.toxml() ) > 100: # ahhh! I hate arbitrary numbers!!!\n print 'no models exist in ModBase for this protein...'\n return {}\n \n # get the ids\n #ids = get_str_from_xml_tag( results , 'model_id' )\n # no need, in the header of the model\n \n # get the models\n models = get_str_from_xml_tag( results , 'content' )\n \n # extract the details\n details , text = get_modbase_model_details( models , display or write_summary , export = True )\n \n # defaults for writing files\n if not root_filename:\n root_filename = 'modbase_' + query\n \n # optionally write the models\n if out_directory:\n create_directory( out_directory , ' to store the models as PDB files' )\n print 'writing the downloaded models to ' + out_directory\n count = 1\n filenames = []\n for i in models:\n # write it\n filename = out_directory + '/' + root_filename + '_model_' + str( count ) + '.pdb'\n filenames.append( os.path.abspath( filename ) )\n\n # write the alignment\n f = open( filename , 'w' )\n f.write( i.strip() )\n f.close()\n count += 1\n \n # change this in this case\n models = filenames\n \n # SOOO HACKY!!!!\n # for later safety...\n out_directory += '/'\n\n # optionally grab the alignment too\n if get_alignment:\n print 'also downloading the alignments...'\n raw_aln_stream = urllib2.urlopen( url + '&type=alignment' )\n\n # parse the results\n aln_results = xml_parse( raw_aln_stream )\n \n # get the files\n aln_results = aln_results.getElementsByTagName( 'alignmentfile' )\n \n # ...for now, just get the text itself\n # don't worry about the other details in the XML file\n print 'writing the alignments as PIR files...'\n count = 1\n for i in aln_results:\n i = get_str_from_xml_tag( i , 'content' )[0] # just 1, always the first\n \n # if out_directory is empty...this will just do as we want\n filename = out_directory + root_filename + '_model_' + str( count ) + '_alignment.pir'\n f = open( filename , 'w' )\n f.write( i )\n f.close()\n \n # convert them?\n # doesn't seem to load these \"pir\" files...? :(\n \n # save in the details?\n details[count - 1]['alignment'] = i\n \n count += 1\n \n # put the models (filenames) into details...cleaner output, just 1 dict\n for i in xrange( len( models ) ):\n details[i]['coordinates'] = models[i]\n \n # find the \"best\" model\n temp = '\\nevaluating the \\\"best\\\" model by comparing:\\n\\t1. sequence identity\\n\\t2. model score\\n\\t3. target length'\n print temp\n text += temp +'\\n'\n best_score = max( [i['sequence identity'] for i in details] )\n matches = [i for i in details if i['sequence identity'] == best_score]\n if len( matches ) > 1 and sum( [not i['model score'] == matches[0]['model score'] for i in matches[1:]] ):\n # find the best model score\n best_score = max( [i['model score'] for i in details] )\n matches = [i for i in details if i['model score'] == best_score]\n \n if len( matches ) > 1 and sum( [not i['target length'] == matches[0]['target length'] for i in matches[1:]] ):\n best_score = max( [i['target length'] for i in details] )\n matches = [i for i in details if i['target length'] == best_score]\n \n # debug output\n if len( matches ) > 1:\n temp = 'multiple models are \\\"equally the best\\\":'\n print temp\n text += temp +'\\n'\n for i in matches:\n temp = '\\t'+ i['coordinates']\n print temp\n text += temp +'\\n'\n temp = 'copying the first on to best_model.pdb'\n print temp\n text += temp +'\\n'\n else:\n temp = 'best model: ' + matches[0]['coordinates']\n print temp\n text += temp\n # move it to a indicative filename\n copy_file( matches[0]['coordinates'] , out_directory + '/best_model.pdb' )\n\n # optionally write a summary file\n if write_summary:\n # if out_directory is empty...this will just do as we want\n filename = out_directory + root_filename + '_summary.txt'\n f = open( filename , 'w' )\n f.write( text )\n f.close()\n \n # just the details, has everything else...\n return details","def GetModels(self, request, context):\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)","def download_and_prepare(self):\n self._download_and_prepare()","def download(\n self,\n overwrite: bool = False,\n refresh_token: bool = False,\n show_progress: bool = True,\n ):\n _LOGGER.info(f\"Downloading model {self.stub}\")\n\n if self.card_file:\n _LOGGER.info(f\"Downloading model card {self.stub}\")\n self.card_file.download(\n overwrite=overwrite,\n refresh_token=refresh_token,\n show_progress=show_progress,\n )\n\n if self.onnx_file:\n _LOGGER.info(f\"Downloading model onnx {self.stub}\")\n self.onnx_file.download(\n overwrite=overwrite,\n refresh_token=refresh_token,\n show_progress=show_progress,\n )\n\n if self.onnx_file_gz:\n _LOGGER.info(f\"Downloading model onnx gz {self.stub}\")\n self.onnx_file_gz.download(\n overwrite=overwrite,\n refresh_token=refresh_token,\n show_progress=show_progress,\n )\n\n self.download_framework_files(\n overwrite=overwrite,\n refresh_token=refresh_token,\n show_progress=show_progress,\n )\n\n for data in self._data.values():\n _LOGGER.info(f\"Downloading model data {data.name} {self.stub}\")\n data.download(\n overwrite=overwrite,\n refresh_token=refresh_token,\n show_progress=show_progress,\n )\n\n for recipe in self._recipes:\n _LOGGER.info(f\"Downloading model recipe {recipe.display_name} {self.stub}\")\n recipe.download(\n overwrite=overwrite,\n refresh_token=refresh_token,\n show_progress=show_progress,\n )","def download(all):\n print(\"Downloading\")","def download_all_data(self) -> None:\n print(\"Download in progress.\")\n self.download_data(os.environ[\"NC_TOKEN_TRAIN_CHARACTERS\"], \"nextcloud\")\n self.download_data(os.environ[\"NC_TOKEN_TRAIN_FRAGMENTS\"], \"nextcloud\")\n self.download_data(os.environ[\"HABBAKUK_URL\"], \"generic_url\")\n print(\"Download complete!\")","def download_model(source, target, filename):\n if not os.path.exists(target):\n os.mkdir(target) \n target_file = str(Path(target).joinpath(filename))\n if os.path.exists(target_file):\n print('model already exists, skipping download')\n return\n print(\"Downloading from {} to {}\".format(source, target))\n wget.download(source, target_file) \n print(\"\\nDone!\")","def _download_all(update_path=True, verbose=None):\n\n # iterate over dataset\n for ds in dataset_list:\n # call download\n ds().download(update_path=True, verbose=verbose, accept=True)","def download_pre_trained_model (model_name):\n model_url = cfg.LIST_MODEL_TO_DOWNLOAD[model_name]\n\n file_name = (model_url.split(\"/\")[-1]).split(\".\")[0] # get file name from url\n\n # create directory if not exit\n if not os.path.exists(os.path.join(cfg.PATH_PRE_TRAINED_MODELS,file_name)):\n if not os.path.exists(cfg.PATH_PRE_TRAINED_MODELS):\n os.mkdir(cfg.PATH_PRE_TRAINED_MODELS)\n try:\n click.echo(click.style(f\"\\n Downloading the {file_name} model \\n\", bg='green', bold=True, fg='white'))\n file_location = save_zip_from_url(model_url, cfg.PATH_PRE_TRAINED_MODELS)\n \n click.echo(click.style(f'\\n Extraction of {file_name} ...\\n', bg='blue', bold=True, fg='white'))\n\n # Extract tar-file to annotation directory\n with tarfile.open(name=file_location) as tar:\n for member in tqdm(iterable=tar.getmembers(), total=len(tar.getmembers())):\n tar.extract(member=member, path=cfg.PATH_PRE_TRAINED_MODELS)\n # delete tar-file\n os.remove(file_location)\n return 0\n\n except expression as identifier:\n return -1\n else:\n click.echo(click.style(f\"\\n {file_name} have been downloaded \\n\", bg='blue', bold=True, fg='white'))\n return 1","def download_model(\n self, model_name: str, save_path: Union[str, Path] = \"./zoo/model.pth\"\n ):\n # check if the model name is valide\n assert model_name in list(\n self.meta.name\n ), f\"requested model {model_name} does not exist\"\n # TODO: fix, using pathlib\n # check if save_path already has the model\n save_dir = os.path.dirname(save_path)\n if not os.path.exists(save_dir):\n os.mkdir(save_dir)\n else:\n assert not os.path.exists(\n save_path\n ), f\"the save_path {save_path} is already used\"\n\n # fetch the model file\n model_id = self.meta[self.meta[\"name\"] == model_name][\"models\"].iloc[0]\n model_path = model_id.split(\"/\")\n self.pkg[model_path[0]][model_path[1]].fetch(save_path)","def download_all_datasets():\n print(\"Downloading all datasets ...\")\n for dataset in get_available_datasets():\n download_dataset(dataset)","def download(self, force: bool = False):\n # hide this import, since we'll only ever need it _once_ (per model version)\n from .. import io as tio\n\n model_fname = self.model_fpath.name\n url = urllib.parse.urljoin(\n \"https://github.com/bdewilde/textacy-data/releases/download/\",\n self.model_id + \"/\" + model_fname,\n )\n tio.utils.download_file(\n url, filename=model_fname, dirpath=self.data_dir, force=force,\n )","def download_model_from_gcs(self):\n # download model\n download_file_from_gcs(self.config.model_bucket_name,\n self.config.model_gcs_path,\n self.config.model_local_path)\n\n # download lable columns\n download_file_from_gcs(self.config.model_bucket_name,\n self.config.labels_gcs_path,\n self.config.labels_local_path)","def load_model(self, model_name, model_url):\n\n fname = join(self.root, model_name)\n if not isfile(fname):\n if self.verbose:\n print(\"Could not find \" + fname + \".. attempt download\")\n with urllib.request.urlopen(model_url) as res, open(fname, 'wb') as f:\n shutil.copyfileobj(res, f)\n if self.verbose:\n print(\"Download complete.. model: \" + fname)\n elif self.verbose:\n print(\"Found model \" + fname + \"! :)\")\n\n model = load_model(fname)\n self.model = model","def download_all(self):\r\n # Fetch website list\r\n self.fetch_website_list()\r\n\r\n for website in self.website_list:\r\n self.download(website['id'])","def download_pretrained_models(\n models_root_dir='/tmp/sketch_rnn/models',\n pretrained_models_url=PRETRAINED_MODELS_URL):\n tf.gfile.MakeDirs(models_root_dir)\n zip_path = os.path.join(\n models_root_dir, os.path.basename(pretrained_models_url))\n if os.path.isfile(zip_path):\n tf.logging.info('%s already exists, using cached copy', zip_path)\n else:\n tf.logging.info('Downloading pretrained models from %s...',\n pretrained_models_url)\n urlretrieve(pretrained_models_url, zip_path)\n tf.logging.info('Download complete.')\n tf.logging.info('Unzipping %s...', zip_path)\n with zipfile.ZipFile(zip_path) as models_zip:\n models_zip.extractall(models_root_dir)\n tf.logging.info('Unzipping complete.')","def download():\n raise NotImplementedError","def _download_model_version_files(self):\n model_version = self.client.get_model_version(name=self.model_name, version=self.model_version)\n artifact_uri = model_version.source\n return _download_artifact_from_uri(artifact_uri)","def download(self):\n pass","def download(self):\n pass","def downloadModel(url):\n print('Model download started...')\n fileName = url.split('/')[-1]\n filePath = f'../kerasModels/{fileName}'\n\n if not os.path.exists(os.path.dirname(filePath)):\n try:\n os.makedirs(os.path.dirname(fileName))\n except OSError as exc:\n if exc.errno != errno.EXIST:\n raise\n\n urlretrieve(url, fileName)\n print('Model download completed')\n return fileName","def import_all():\n\n # count the number of files loaded\n count = 0\n\n # get model name\n model_name_list = [model for data_models in settings.OBJECT_DATA_MODELS\n for model in data_models]\n\n model_name_list += [model for model in settings.OTHER_DATA_MODELS]\n\n # import models one by one\n for model_name in model_name_list:\n import_model(model_name)\n\n # import localized strings\n import_localized_strings(settings.LANGUAGE_CODE)","def download():\n return response.download(request,db)","def download():\n return response.download(request,db)","def download():\n return response.download(request,db)","def download():\n return response.download(request,db)","def download():\n return response.download(request,db)","def download():\n return response.download(request,db)","def loadParts(self):\n for i in range(15):\n self.model_parts[i] = loadModel(\"ato_{}.pkl\".format(str(i)))","def load_all_models(save_models_dir: str, model_type: str, model_i: int):\n\n try:\n with open(os.path.join(save_models_dir, f\"{model_type}_{model_i}.pkl\"), \"rb\") as save_model:\n model = pickle.load(save_model)\n except Exception as e:\n logger.error(f\"Error is: {e}\")\n return None\n\n return model","def download_model(\n model: str,\n force: bool = False,\n) -> str:\n if model in {\"small\", \"medium\", \"large\"}:\n latest_version = get_latest_version(model)\n model = f\"da_dacy_{model}_trf-{latest_version}\"\n mdl_version = model.split(\"-\")[-1]\n\n if model not in models_url:\n raise ValueError(\n f\"The model '{model}' is not available in DaCy. Please use dacy.models() to see a\"\n + \" list of all models\",\n )\n\n mdl = model.split(\"-\")[0]\n if mdl in get_installed_models() and not force and version(mdl) == mdl_version:\n return mdl\n install(models_url[model])\n return mdl","def _get_models(self, req, is_detail):\n context = req.environ['meteos.context']\n\n search_opts = {}\n search_opts.update(req.GET)\n\n # Remove keys that are not related to model attrs\n search_opts.pop('limit', None)\n search_opts.pop('offset', None)\n sort_key = search_opts.pop('sort_key', 'created_at')\n sort_dir = search_opts.pop('sort_dir', 'desc')\n\n models = self.engine_api.get_all_models(\n context, search_opts=search_opts, sort_key=sort_key,\n sort_dir=sort_dir)\n\n limited_list = common.limited(models, req)\n\n if is_detail:\n models = self._view_builder.detail_list(req, limited_list)\n else:\n models = self._view_builder.summary_list(req, limited_list)\n return models","def download_all_files(self):\n self.server_handler.get_sensor_data_from_server()","def downloadAll(self, force=False):\n if self.minutesSinceLastUpdate() == 0 and force == False:\n self.log(\"TOO SOON SINCE LAST DOWNLOAD!\")\n return\n for grabber in self.grabbers:\n self.downloadGrab(grabber[\"url\"], grabber[\"ID\"])+\"\\n\"","def download_files(self) -> None:\n\n for name, url in self.files.items():\n print(f\"Download {name.split('/')[-1]}\")\n wget.download(url, os.path.join(\"data\", name))","def check_models():\n # Check if Models exist\n if request.method == 'GET':\n if models_exist():\n return jsonify({'message': 'models found'})\n else:\n return jsonify({'message': 'one or more models missing'}), 409\n\n # Post Method, download models\n else:\n task = download_models.apply_async()\n task_url = url_for('model_download_status', task_id=task.id)\n return jsonify({'message': 'download started', 'location': task_url}), 202, {'Location': task_url}","def GetModels(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","async def list(request):\n dict_answer = {'models': [item[1]+' '+item[0]+str(item[2:]) for item in models_db],\n 'datasets': [conv_time(d.stat().st_atime)+' '+str(d.name) for d in Path('data/datasets/').glob('*')],\n }\n return web.json_response(dict_answer)","def train(self, absList, modelFilename):\n pass","def load_model(self) -> Any:","def _download_model(download_url):\n\n pip_args = [\"--no-cache-dir\"]\n cmd = [sys.executable, \"-m\", \"pip\", \"install\"] + pip_args + [download_url]\n\n return subprocess.call(cmd, env=os.environ.copy())","def GetModels(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def download_model(model, model_hash, model_dir):\n if not os.path.isdir(model_dir):\n os.mkdir(model_dir)\n filename = os.path.join(model_dir, model)\n\n logger.info(f\"Downloading {model} to {filename}...\")\n urllib.request.urlretrieve(\n os.path.join(\"http://genesis.ugent.be/uvpublicdata/ms2pip/\", model), filename\n )\n if not check_model_integrity(filename, model_hash):\n raise InvalidXGBoostModelError()","def import_all_model_modules():\r\n import brokerage.model\r\n # ensure that these imports don't get auto-deleted! they have side effects.\r\n brokerage.model","def download():\n basedir = os.path.dirname(os.path.dirname(__file__))\n print(basedir)\n datadir = os.path.join(basedir,\"data/NeonTreeEvaluation/\")\n print(\"Downloading data files to {}\".format(datadir)) \n eval_url = zenodo_url(concept_rec_id=\"3723356\", datadir=datadir)","def download_model(key, output_path):\n print(\"Looking fro model in {}\".format(output_path))\n if os.path.exists(output_path):\n print('File at: {} already exists'.format(output_path))\n else:\n download_file_from_s3(key, output_path)","def _get_model_list(self):\n self.model_arch_file = os.path.join(self.model_dir, self.model_name + '.prototxt')\n self.model_weight_file = os.path.join(self.model_dir, self.model_name + '.caffemodel')\n self.filelist.append(self.model_arch_file)\n self.filelist.append(self.model_weight_file)","def download_tf_params():\n\n if not os.path.exists(MODEL_DIR):\n os.makedirs(MODEL_DIR)\n filename = DATA_URL.split('/')[-1]\n filepath = os.path.join(MODEL_DIR, filename)\n\n if not os.path.exists(filepath):\n def _progress(count, block_size, total_size):\n sys.stdout.write('\\r>> Downloading %s %.1f%%' % (\n filename, float(count * block_size) / float(total_size) * 100.0))\n sys.stdout.flush()\n\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\n statinfo = os.stat(filepath)\n print()\n print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.')\n\n tarfile.open(filepath, 'r:gz').extractall(MODEL_DIR)","def _fetch_large():\n # Large training data:\n resource(\n target=data_path(\"eeg\", \"SMNI_CMI_TRAIN.tar.gz\"),\n url=\"https://kdd.ics.uci.edu/databases/eeg/SMNI_CMI_TRAIN.tar.gz\",\n )\n dependency(\n target=data_path(\"eeg\", \"train\"),\n source=data_path(\"eeg\", \"SMNI_CMI_TRAIN.tar.gz\"),\n commands=[\n \"tar xzf SMNI_CMI_TRAIN.tar.gz\",\n \"mv SMNI_CMI_TRAIN train\",\n \"find train | grep gz$ | xargs gunzip\",\n ],\n )\n # Large test data:\n resource(\n target=data_path(\"eeg\", \"SMNI_CMI_TEST.tar.gz\"),\n url=\"https://kdd.ics.uci.edu/databases/eeg/SMNI_CMI_TEST.tar.gz\",\n )\n dependency(\n target=data_path(\"eeg\", \"test\"),\n source=data_path(\"eeg\", \"SMNI_CMI_TEST.tar.gz\"),\n commands=[\n \"tar xzf SMNI_CMI_TEST.tar.gz\",\n \"mv SMNI_CMI_TEST test\",\n \"find test | grep gz$ | xargs gunzip\",\n ],\n )","def download_entire_dataset(dataset_name, num_data, labels, method, cache_dir):\n\n print('Downloading {}...'.format(dataset_name))\n preprocessor = preprocess_method_dict[method]()\n\n # Select the first `num_data` samples from the dataset.\n target_index = numpy.arange(num_data) if num_data >= 0 else None\n dataset_parts = D.molnet.get_molnet_dataset(dataset_name, preprocessor,\n labels=labels,\n target_index=target_index)\n dataset_parts = dataset_parts['dataset']\n\n # Cache the downloaded dataset.\n if not os.path.exists(cache_dir):\n os.makedirs(cache_dir)\n\n for i, part in enumerate(['train', 'valid', 'test']):\n filename = dataset_part_filename(part, num_data)\n path = os.path.join(cache_dir, filename)\n NumpyTupleDataset.save(path, dataset_parts[i])\n return dataset_parts","def list_models():\n\n cmd = dict()\n cmd[\"type_\"] = \"list_models\"\n cmd[\"name_\"] = \"\"\n \n s = comm.send_and_receive_socket(cmd)\n\n msg = comm.recv_string(s)\n\n if msg != \"Success!\":\n raise Exception(msg)\n \n json_str = comm.recv_string(s) \n \n s.close() \n\n return json.loads(json_str)","def download_pretrained_weights(env_name):\n print('Downloading model weights to ')\n os.system('mkdir -p %s' % MODEL_CACHE_DIR)\n os.system('cd \"%s\" && curl -s -S \"%s\" > %s' %\n (MODEL_CACHE_DIR, ENV_TO_URL[env_name], ENV_TO_FNAME[env_name]))","def ListModels(self, request, context):\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)","def _get_or_download_model(self, download: bool) -> Optional[str]:\n home_dir = home_directory()\n downloaded_models_dir = os.path.join(home_dir, MODELS_DIR)\n\n if not os.path.exists(downloaded_models_dir):\n os.makedirs(downloaded_models_dir)\n\n model_hashed_name = get_hashed_name(self.embedding + self.model)\n model_path = os.path.join(downloaded_models_dir, model_hashed_name)\n\n if not os.path.exists(model_path):\n if not download:\n return\n\n model_download_path = model_path + '.' + self.embedding_cls.EMBEDDING_MODELS[self.model].format\n model_download_url = self.embedding_cls.EMBEDDING_MODELS[self.model].download_url\n print(f\"Model does not exists, Downloading model: {self.model}\")\n download_from_url(model_download_url, model_download_path)\n extract_file(model_download_path, model_path)\n if os.path.exists(model_download_path):\n os.remove(model_download_path)\n print(f\"Model downloaded successfully!\")\n return model_path","def _pc_load_models(model_name = None, mod_list = None, n_sample = None, verbose = False, **kwargs):\n\n if model_name is not None:\n mod_list = glob.glob(model_name + '*.out')\n if mod_list is None or mod_list == []:\n pc.log_.error('No model found', calling='load models')\n return None\n if n_sample is not None:\n if n_sample > len(mod_list):\n pc.log_.error('less models {0:d} than n_sample {1:d}'.format(len(mod_list), n_sample),\n calling='load models')\n return None\n mod_list = random.sample(mod_list, n_sample)\n m = []\n for outfile in mod_list:\n if outfile[-4::] == '.out':\n model_name = outfile[0:-4]\n else:\n model_name = outfile\n try:\n cm = pc.CloudyModel(model_name, verbose=0, **kwargs)\n if not cm.aborted:\n m.append(cm)\n if verbose:\n print('{0} model read'.format(outfile[0:-4]))\n except:\n pass\n pc.log_.message('{0} models read'.format(len(m)), calling='load_models')\n return m","def load_model(self, filename):\r\n pass","def get_models(make):\n api_url = 'https://api.edmunds.com/api/vehicle/v2/{}/models?fmt=json&api_key={}'\\\n .format(make, API_KEY)\n r = requests.get(api_url).json()\n all_models = [model['name'] for model in r['models']]\n return all_models","def get_data( name=None, force_download=False, version=19, target_extension='.csv' ):\n os.makedirs(DATA_PATH, exist_ok=True)\n\n def download_data( version ):\n url = \"https://ndownloader.figshare.com/articles/14766102/versions/\" + str(version)\n target_file_name = \"14766102.zip\"\n target_file_name_path = tf.keras.utils.get_file(target_file_name, url,\n cache_subdir=DATA_PATH, extract = True )\n os.remove( DATA_PATH + target_file_name )\n\n if force_download:\n download_data( version = version )\n\n\n files = []\n for fname in os.listdir(DATA_PATH):\n if ( fname.endswith(target_extension) ) :\n fname = os.path.join(DATA_PATH, fname)\n files.append(fname)\n\n if len( files ) == 0 :\n download_data( version = version )\n for fname in os.listdir(DATA_PATH):\n if ( fname.endswith(target_extension) ) :\n fname = os.path.join(DATA_PATH, fname)\n files.append(fname)\n\n if name == 'all':\n return files\n\n datapath = None\n\n for fname in os.listdir(DATA_PATH):\n mystem = (Path(fname).resolve().stem)\n mystem = (Path(mystem).resolve().stem)\n mystem = (Path(mystem).resolve().stem)\n if ( name == mystem and fname.endswith(target_extension) ) :\n datapath = os.path.join(DATA_PATH, fname)\n\n if datapath is None:\n raise ValueError('File doesnt exist. Options: ' , os.listdir(DATA_PATH))\n return datapath","def get_model_list():\n with open(os.path.join(MODELS_FOLDER, \"models.json\"), \"r\") as model_file:\n model_list = json.load(model_file)\n return model_list","def load_model(self, **params):\n \t# file_name = params['name']\n # return pickle.load(gzip.open(file_name, 'rb'))","def models():\n if flask.request.args.get('refresh') == '1':\n app.config['store_cache'].reset()\n cached_data = app.config['store_cache'].read()\n if cached_data is not None:\n return json.dumps(cached_data)\n\n store_urls = app.config['store_url_list']\n aggregated_dict = dict()\n for i, store_url in enumerate(store_urls):\n if len(store_url) == 0:\n continue\n model_list = list()\n if store_url[-1] != '/':\n store_base_url = store_url + '/'\n else:\n store_base_url = store_url\n try:\n page = requests.get(store_base_url)\n except requests.exceptions.RequestException as e:\n logger.warning('Skip %s due to error %s' % (store_base_url, e))\n continue\n parser = StoreParser()\n parser.feed(page.content)\n msg = 'Thanks for visiting {}'.format(store_base_url)\n if len(parser.get_child_dirs()) > 0:\n dirs = [d[:-1] for d in parser.get_child_dirs()]\n else:\n response = requests.get(os.path.join(store_base_url,'master.json'))\n if response.status_code == 200:\n json_response = json.loads(response.content)\n dirs = json_response['children']\n msg = json_response['msg']\n else:\n continue\n for subdir in dirs:\n tmp_dict = {'dir_name': subdir}\n response = requests.get(os.path.join(store_base_url,subdir,'info.json'))\n if response.status_code == 200:\n tmp_dict['info'] = json.loads(response.content)\n tmp_dict['id'] = str(uuid.uuid4())\n response = requests.get(os.path.join(store_base_url,subdir,'aux.json'))\n if response.status_code == 200:\n tmp_dict['aux'] = json.loads(response.content)\n model_list.append(tmp_dict)\n store_info = {'base_url': store_base_url, 'welcome_msg': msg,\n 'model_list': model_list}\n aggregated_dict[store_base_url] = store_info\n app.config['store_cache'].write(aggregated_dict)\n return json.dumps(aggregated_dict)","def load_models():\n vectorizer = ModelStorage.objects.all().values_list(\"vectorizer\", flat = True)[0]\n classifier = ModelStorage.objects.all().values_list(\"classifier\", flat = True)[0]\n\n return vectorizer, classifier","def _load_model(self):\n self._load_scaler('scaler.save')\n self._load_encoder('encoder0.save', 0)\n self._load_encoder('encoder1.save', 1)\n self._load_neural_network('model.json', 'model.h5')\n return","def model_fn(model_dir):\n ctx = mx.cpu()\n net = unet.Unet()\n print (\"Loading\", model_dir)\n if path.exists(model_dir+\"/unet_RGB.params\"):\n print (\"Loading RGB Model\")\n net.load_params(model_dir+\"/unet_RGB.params\", ctx)\n print (\"RGB Model Loaded\")\n \n elif path.exists(model_dir+\"/unet_ALL_BANDS.params\"):\n print (\"Loading ALL_BANDS Model\")\n net.load_params(model_dir+\"/unet_ALL_BANDS.params\", ctx)\n print (\"ALL_BANDS Model Loaded\")\n \n else:\n print (\"Model Missing\")\n net=None\n return (net)","def download_data(self):\r\n \r\n for file in self.__files:\r\n file_to_download = os.path.join(self.__folder, os.path.basename(file))\r\n if not os.path.isfile(file_to_download):\r\n self.__download_file(file)","def download_english(paths):\n language_path = os.path.join(paths[\"languages\"], \"English\")\n\n if not os.path.isdir(language_path):\n print(\"DOWNLOADING ENGLISH MODEL\")\n os.makedirs(language_path)\n r = requests.get(ENGLISH_MODEL_URL)\n with open(os.path.join(language_path, TRANSCRIPTION_MODEL), \"wb\") as f:\n f.write(r.content)\n\n r = requests.get(ENGLISH_ALPHABET_URL)\n with open(os.path.join(language_path, ALPHABET_FILE), \"wb\") as f:\n f.write(r.content)","def get_all_models() -> list:\n\n conn = database_connect()\n if(conn is None):\n return None\n cur = conn.cursor()\n\n try:\n # SQL statement and execute\n sql = \"\"\"SELECT manufacturer, description, modelnumber, weight\n FROM Model\"\"\"\n cur.execute(sql, ())\n\n # Attempt to fetch first row\n result = cur.fetchall()\n\n if result == None:\n cur.close()\n conn.close()\n return []\n\n models = []\n for row in result:\n models.append(\n [row[0], row[1], row[2], row[3]]\n )\n\n cur.close()\n conn.close()\n return models\n except Exception as e:\n print(\"fff\")\n print(e)\n # If login failed, return None\n cur.close()\n conn.close()\n return []","def download_trained_weights(coco_model_path, verbose=1):\n if verbose > 0:\n print(\"Downloading pretrained model to \" + coco_model_path + \" ...\")\n with urllib.request.urlopen(COCO_MODEL_URL) as resp, open(coco_model_path, 'wb') as out:\n shutil.copyfileobj(resp, out)\n if verbose > 0:\n print(\"... done downloading pretrained model!\")","def model_files(cmd_args):\n if cmd_args.learning_file_list:\n learning_files_list = files_constructor(cmd_args, file_type='learning')\n else:\n learning_files_list = None\n\n if cmd_args.prediction_file:\n prediction_file = files_constructor(cmd_args, file_type='prediction')\n else:\n prediction_file = None\n\n\n return learning_files_list, prediction_file","def import_data(self):\n self.models = []\n for o in self.loader.load():\n klass = self.type_for(o)\n if hasattr(klass, \"from_api\"):\n self.models.append(klass.from_api(o))\n else:\n self.models.append(klass(o))\n return self.models","def download(self,**attrs):\n\t\treturn super().download(**attrs)","def _get_model_list(self):\n model_filelist = os.listdir(os.path.join(self.pack_file_path, self.model_dir))\n for i in model_filelist:\n model_file = os.path.join(self.model_dir, i)\n self.filelist.append(model_file)","def ListModels(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def ListModels(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)"],"string":"[\n \"def download_all_models() -> None:\\n model_keys = ModelInfo.get_all_models()\\n for model_key in model_keys:\\n download_model(model_key)\",\n \"def download_models_and_data():\\n\\n for file in DATA_FILES:\\n download_file(file[\\\"url\\\"], file[\\\"path\\\"])\",\n \"def _retrieve_models(local=True):\\n # Check if the download folder exists\\n def _get_meta_data(model_name, file):\\n return {\\n \\\"data\\\": {\\n \\\"id\\\": model_name,\\n \\\"name\\\": model_name,\\n \\\"description\\\": model_name,\\n \\\"filename\\\": os.path.join(\\n app.config[\\\"DOWNLOAD_DIR\\\"], file),\\n \\\"created\\\": time.ctime(os.path.getctime(\\n os.path.join(\\n app.config[\\\"DOWNLOAD_DIR\\\"],\\n file))),\\n \\\"modified\\\": time.ctime(os.path.getmtime(\\n os.path.join(\\n app.config[\\\"DOWNLOAD_DIR\\\"],\\n file)))\\n }\\n }\\n\\n if not os.path.exists(app.config[\\\"DOWNLOAD_DIR\\\"]):\\n os.makedirs(app.config[\\\"DOWNLOAD_DIR\\\"])\\n\\n if not local:\\n # Fetch from a Nexus-hosted catalog\\n resources = app.forge.search({\\\"type\\\": \\\"EmbeddingModel\\\"})\\n for resource in resources:\\n app.models[resource.name] = {\\n \\\"data\\\": digest_model_data(resource),\\n }\\n app.forge.download(\\n resource, \\\"distribution.contentUrl\\\",\\n app.config[\\\"DOWNLOAD_DIR\\\"])\\n\\n pipeline_path = os.path.join(\\n app.config[\\\"DOWNLOAD_DIR\\\"],\\n resource.distribution.name)\\n app.models[resource.name][\\\"object\\\"] = EmbeddingPipeline.load(\\n pipeline_path,\\n embedder_interface=GraphElementEmbedder,\\n embedder_ext=\\\"zip\\\")\\n\\n # Clear the downloads dir\\n for f in os.listdir(app.config[\\\"DOWNLOAD_DIR\\\"]):\\n try:\\n os.remove(os.path.join(app.config[\\\"DOWNLOAD_DIR\\\"], f))\\n except Exception:\\n shutil.rmtree(os.path.join(app.config[\\\"DOWNLOAD_DIR\\\"], f))\\n else:\\n # Fetch from a local dir\\n for (_, dirs, files) in os.walk(app.config[\\\"DOWNLOAD_DIR\\\"]):\\n for path in dirs + files:\\n if path[0] != \\\".\\\":\\n match = re.match(r\\\"(.*)\\\\.zip\\\", path)\\n if match:\\n model_name = match.groups()[0]\\n else:\\n model_name = path\\n app.models[model_name] = _get_meta_data(model_name, path)\\n pipeline_path = os.path.join(\\n app.config[\\\"DOWNLOAD_DIR\\\"], path)\\n app.models[model_name][\\\"object\\\"] = EmbeddingPipeline.load(\\n pipeline_path,\\n embedder_interface=GraphElementEmbedder,\\n embedder_ext=\\\"zip\\\")\\n break\",\n \"def test_downloadAllModels(self):\\n\\t\\tmodelOptions = cancerscope.config.getmodelsdict() ## MODIFIED FROM cancerscope.getmodelsdict() on March 17 2020\\n\\t\\tassert len(modelOptions.keys()) == 5\\n\\t\\tscope_ensemble_obj = cancerscope.scope_ensemble.scope() ## MODIFIED FROM cancerscope.scope() on March 17 2020\\n\\t\\t#my_downloaded_models = cancerscope.get_models.getmodel() ## This should retrieve all models\\n\\t\\tmy_downloaded_models = scope_ensemble_obj.downloaded_models_dict\\n\\t\\tassert len(my_downloaded_models.keys()) == 5\\n\\t\\tfor k_model in my_downloaded_models.keys():\\n\\t\\t\\tmodelname_address = my_downloaded_models[k_model]\\n\\t\\t\\t\\\"\\\"\\\"For each model, test if model dir exists, then set up the model once\\\"\\\"\\\"\\n\\t\\t\\tself.assertTrue(os.path.isdir(modelname_address))\\n\\t\\t\\tself.assertTrue(os.path.exists(\\\"\\\".join([modelname_address, \\\"/lasagne_bestparams.npz\\\"])))\\n\\t\\t\\t\\\"\\\"\\\"TO BE FIXED: THEN SET UP MODEL (memory issues in travis (3 GB RAM there)\\\"\\\"\\\"\\n\\t\\t\\t#lmodel = cancerscope.scopemodel(modelname_address_pair[k_model])\\n\\t\\t\\t#lmodel.fit()\\n\\t\\t\\t#self.assertEqual(len(lmodel.features), 17688)\\n\\t\\t\\t#del lmodel; lmodel=None\\n\\t\\t\\t#for i in range(3):\\n\\t\\t\\t#\\tgc.collect()\",\n \"def download_files(self):\",\n \"def test_downloadModel(self):\\n\\t\\tmodel_in = \\\"\\\"\\n\\t\\tquery_localdirs = cancerscope.get_models.findmodel(os.path.dirname(cancerscope.__file__), \\\"v1_rm500\\\")\\n\\t\\tif query_localdirs is not None:\\n\\t\\t\\tmodel_in = query_localdirs[\\\"v1_rm500\\\"]\\n\\t\\telse:\\n\\t\\t\\tmodel_in = cancerscope.get_models.downloadmodel(model_label=\\\"v1_rm500\\\")\\n\\t\\t\\n\\t\\tself.assertTrue(os.path.isdir(model_in))\\n\\t\\tself.assertTrue(os.path.exists(\\\"\\\".join([model_in, \\\"/lasagne_bestparams.npz\\\"])))\\n\\t\\t\\n\\t\\t\\\"\\\"\\\"Test if model can be setup correctly\\\"\\\"\\\"\\n\\t\\tlmodel = cancerscope.scopemodel(model_in)\\n\\t\\tlmodel.fit()\\n\\t\\n\\t\\tself.assertEqual(len(lmodel.features), 17688)\",\n \"def download_model():\\n logging.info(\\\"[genreml] Downloading model...\\\")\\n with urllib.request.urlopen(config.FMAModelConfig.FMA_MODEL_URL) as f:\\n data = f.read()\\n open(config.FMAModelConfig.FMA_MODEL_PATH, 'wb').write(data)\\n logging.info(\\\"[genreml] Model download complete\\\")\",\n \"def download_all(): #@save\\n for name in DATA_HUB:\\n download(name)\",\n \"def maybe_download():\\n\\n print(\\\"Downloading Inception 5h Model ...\\\")\\n download.maybe_download_and_extract(url=data_url, download_dir=data_dir)\",\n \"def load_models(self, models, iteration = None):\\n print(\\\"NOT IMPLEMENTED YET\\\")\",\n \"def download_model(\\\\\\n download_base='http://download.tensorflow.org/models/object_detection/', \\\\\\n model_name='ssd_mobilenet_v1_coco_11_06_2017'\\\\\\n ):\\n\\n # add tar gz to the end of file name\\n model_file = model_name + '.tar.gz'\\n\\n try:\\n opener = urllib.request.URLopener()\\n opener.retrieve(download_base + model_file, \\\\\\n model_file)\\n tar_file = tarfile.open(model_file)\\n for f in tar_file.getmembers():\\n file_name = os.path.basename(f.name)\\n if 'frozen_inference_graph.pb' in file_name:\\n tar_file.extract(f, os.getcwd())\\n except Exception as e:\\n raise\",\n \"def opt_get_all_models_rest_api():\\n return retrieve_all_models()\",\n \"def fetch_data():\\n for category in CHEATSHEETS.items():\\n subprocess.call(f'curl -o {PATH}{category[0] + \\\".csv\\\"} {category[1]}', shell=True)\\n\\n index = -1\\n for filename in os.listdir(PATH):\\n for idx, row in pd.read_csv(PATH + filename, on_bad_lines='skip').replace(np.nan, '').iterrows():\\n name = row['Model']\\n url = REDIRECT_URL + name.lower()\\n category = filename.split('.')[0]\\n featurizers = row['Acceptable Featurizers'].split(' ') if row['Acceptable Featurizers'] != '' else []\\n backends = ['PyTorch' if item in {\\\"PTorch\\\", \\\"Torch\\\", \\\"PyTorch \\\"} else item for item in row['Backend'].split('/')]\\n types = row['Type'] if filename != 'general.csv' else row['Classifier/Regressor']\\n types = types.split('/') if filename == 'material.csv' else types.split('/ ')\\n index += 1\\n\\n backend_list.append(backends)\\n type_list.append(types)\\n featurizer_list.append(featurizers)\\n model_list.append(Model(name, url, category, featurizers, backends, types, index))\",\n \"def build_models():\\n train_models()\\n return build_response.sent_ok()\",\n \"def download_model(name: str) -> str:\\n model_name, model_type, model_url = ModelInfo.get_model_info(name)\\n model_path = _create_dirs(model_name)\\n if model_type == \\\"single\\\":\\n model_path = _download_file(model_url, model_path)\\n elif model_type == \\\"zip\\\":\\n model_path = _download_zip_model(model_url, model_path)\\n else:\\n print(f\\\"model type {model_type} not yet implemented\\\")\\n model_path = \\\"\\\"\\n return model_path\",\n \"def download(self):\\n if not os.path.exists(self.pkg_dir):\\n os.makedirs(self.pkg_dir)\\n\\n url = self.metadata_pkg[\\\"url\\\"]\\n\\n # Download modelpkg only if not already downloaded.\\n if os.path.exists(self.file_path):\\n self.is_downloaded = True\\n else:\\n print(f\\\"Fetching {os.path.basename(self.file_path)} model package from {url} to {self.file_path}\\\", flush=True)\\n r = requests.get(url, stream=True)\\n with open(self.file_path, \\\"wb\\\") as file_out:\\n for chunk in r.iter_content(chunk_size=2048):\\n file_out.write(chunk)\\n r.close()\\n self.is_downloaded = True\",\n \"def fetch_models(self):\\n if self.model_pool is None:\\n print(\\\"Please train a model first.\\\", file=STDE)\\n EXIT(1)\\n else:\\n return [copy.deepcopy(m.steps[-1][-1]) for m in self.model_pool]\",\n \"def models() -> list[str]:\\n return list(models_url.keys())\",\n \"def download(fnames):\\n download_path = Path('./models')\\n if not download_path.exists() or not download_path.is_dir():\\n print('The directory \\\\'models\\\\' does not exist!')\\n print('Please ensure you are in the top level of the visual-attention-networks repository')\\n print(' and that the \\\\'models\\\\' directory exists')\\n sys.exit()\\n\\n server_url = 'https://github.com/davidmascharka/tbd-nets/releases/download/v1.0/'\\n if isinstance(fnames, str): # a single file\\n fnames = [fnames]\\n for fname in fnames:\\n if (download_path / fname).exists():\\n print('Skipping {}: the file already exists'.format(fname))\\n continue\\n\\n print('Downloading {}'.format(fname))\\n urlretrieve(server_url + fname, str((download_path/fname).absolute()), _download_info)\\n print('Finished')\",\n \"def download_ckpt(model_name):\\n with open (\\\"./utils/models.json\\\", \\\"r\\\") as f:\\n url = json.loads(f.read())[model_name] \\n model_name_tar = url.split(\\\"/\\\")[-1]\\n model_name_dir = url.split(\\\"/\\\")[-1].split(\\\".\\\")[0]\\n if not chk_model(model_name_dir):\\n try: \\n print('Downloading %s to %s...' % (url, model_name_tar))\\n os.system(\\\"wget {}\\\".format(str(url))) \\n os.system(\\\"tar xvf {}\\\".format(str(model_name_tar))) \\n os.remove(model_name_tar)\\n # assert os.path.exists()# check \\n return model_name_dir\\n except Exception as e:\\n print(e)\\n return model_name_dir\",\n \"def download_models_from_modbase( query ,\\n out_directory = 'modbase_models' , root_filename = '' ,\\n dataset = '' , get_alignment = True , write_summary = True ,\\n display = True ):\\n # url\\n url = 'http://salilab.org/modbase/retrieve/modbase'\\n \\n # format the search query\\n print 'searching modbase for \\\\\\\"' + query +'\\\\\\\"'\\n url += '?databaseID=' + query\\n # currently unused...so why put it here?\\n #for i in search_options.keys():\\n # url += '&' + i +'='+ search_options[i]\\n \\n # the dataset\\n# if not 'dataset' in search_options.keys() and dataset:\\n if dataset:\\n url += '&dataset=' + dataset\\n\\n # go get the results\\n print 'obtaining model results from:\\\\n\\\\t' + url\\n raw_stream = urllib2.urlopen( url + '&type=model' ) \\n print 'finished downloading models, summarizing the results...'\\n \\n # parse the results\\n results = xml_parse( raw_stream )\\n\\n # check if empty\\n if not len( results.toxml() ) > 100: # ahhh! I hate arbitrary numbers!!!\\n print 'no models exist in ModBase for this protein...'\\n return {}\\n \\n # get the ids\\n #ids = get_str_from_xml_tag( results , 'model_id' )\\n # no need, in the header of the model\\n \\n # get the models\\n models = get_str_from_xml_tag( results , 'content' )\\n \\n # extract the details\\n details , text = get_modbase_model_details( models , display or write_summary , export = True )\\n \\n # defaults for writing files\\n if not root_filename:\\n root_filename = 'modbase_' + query\\n \\n # optionally write the models\\n if out_directory:\\n create_directory( out_directory , ' to store the models as PDB files' )\\n print 'writing the downloaded models to ' + out_directory\\n count = 1\\n filenames = []\\n for i in models:\\n # write it\\n filename = out_directory + '/' + root_filename + '_model_' + str( count ) + '.pdb'\\n filenames.append( os.path.abspath( filename ) )\\n\\n # write the alignment\\n f = open( filename , 'w' )\\n f.write( i.strip() )\\n f.close()\\n count += 1\\n \\n # change this in this case\\n models = filenames\\n \\n # SOOO HACKY!!!!\\n # for later safety...\\n out_directory += '/'\\n\\n # optionally grab the alignment too\\n if get_alignment:\\n print 'also downloading the alignments...'\\n raw_aln_stream = urllib2.urlopen( url + '&type=alignment' )\\n\\n # parse the results\\n aln_results = xml_parse( raw_aln_stream )\\n \\n # get the files\\n aln_results = aln_results.getElementsByTagName( 'alignmentfile' )\\n \\n # ...for now, just get the text itself\\n # don't worry about the other details in the XML file\\n print 'writing the alignments as PIR files...'\\n count = 1\\n for i in aln_results:\\n i = get_str_from_xml_tag( i , 'content' )[0] # just 1, always the first\\n \\n # if out_directory is empty...this will just do as we want\\n filename = out_directory + root_filename + '_model_' + str( count ) + '_alignment.pir'\\n f = open( filename , 'w' )\\n f.write( i )\\n f.close()\\n \\n # convert them?\\n # doesn't seem to load these \\\"pir\\\" files...? :(\\n \\n # save in the details?\\n details[count - 1]['alignment'] = i\\n \\n count += 1\\n \\n # put the models (filenames) into details...cleaner output, just 1 dict\\n for i in xrange( len( models ) ):\\n details[i]['coordinates'] = models[i]\\n \\n # find the \\\"best\\\" model\\n temp = '\\\\nevaluating the \\\\\\\"best\\\\\\\" model by comparing:\\\\n\\\\t1. sequence identity\\\\n\\\\t2. model score\\\\n\\\\t3. target length'\\n print temp\\n text += temp +'\\\\n'\\n best_score = max( [i['sequence identity'] for i in details] )\\n matches = [i for i in details if i['sequence identity'] == best_score]\\n if len( matches ) > 1 and sum( [not i['model score'] == matches[0]['model score'] for i in matches[1:]] ):\\n # find the best model score\\n best_score = max( [i['model score'] for i in details] )\\n matches = [i for i in details if i['model score'] == best_score]\\n \\n if len( matches ) > 1 and sum( [not i['target length'] == matches[0]['target length'] for i in matches[1:]] ):\\n best_score = max( [i['target length'] for i in details] )\\n matches = [i for i in details if i['target length'] == best_score]\\n \\n # debug output\\n if len( matches ) > 1:\\n temp = 'multiple models are \\\\\\\"equally the best\\\\\\\":'\\n print temp\\n text += temp +'\\\\n'\\n for i in matches:\\n temp = '\\\\t'+ i['coordinates']\\n print temp\\n text += temp +'\\\\n'\\n temp = 'copying the first on to best_model.pdb'\\n print temp\\n text += temp +'\\\\n'\\n else:\\n temp = 'best model: ' + matches[0]['coordinates']\\n print temp\\n text += temp\\n # move it to a indicative filename\\n copy_file( matches[0]['coordinates'] , out_directory + '/best_model.pdb' )\\n\\n # optionally write a summary file\\n if write_summary:\\n # if out_directory is empty...this will just do as we want\\n filename = out_directory + root_filename + '_summary.txt'\\n f = open( filename , 'w' )\\n f.write( text )\\n f.close()\\n \\n # just the details, has everything else...\\n return details\",\n \"def GetModels(self, request, context):\\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)\",\n \"def download_and_prepare(self):\\n self._download_and_prepare()\",\n \"def download(\\n self,\\n overwrite: bool = False,\\n refresh_token: bool = False,\\n show_progress: bool = True,\\n ):\\n _LOGGER.info(f\\\"Downloading model {self.stub}\\\")\\n\\n if self.card_file:\\n _LOGGER.info(f\\\"Downloading model card {self.stub}\\\")\\n self.card_file.download(\\n overwrite=overwrite,\\n refresh_token=refresh_token,\\n show_progress=show_progress,\\n )\\n\\n if self.onnx_file:\\n _LOGGER.info(f\\\"Downloading model onnx {self.stub}\\\")\\n self.onnx_file.download(\\n overwrite=overwrite,\\n refresh_token=refresh_token,\\n show_progress=show_progress,\\n )\\n\\n if self.onnx_file_gz:\\n _LOGGER.info(f\\\"Downloading model onnx gz {self.stub}\\\")\\n self.onnx_file_gz.download(\\n overwrite=overwrite,\\n refresh_token=refresh_token,\\n show_progress=show_progress,\\n )\\n\\n self.download_framework_files(\\n overwrite=overwrite,\\n refresh_token=refresh_token,\\n show_progress=show_progress,\\n )\\n\\n for data in self._data.values():\\n _LOGGER.info(f\\\"Downloading model data {data.name} {self.stub}\\\")\\n data.download(\\n overwrite=overwrite,\\n refresh_token=refresh_token,\\n show_progress=show_progress,\\n )\\n\\n for recipe in self._recipes:\\n _LOGGER.info(f\\\"Downloading model recipe {recipe.display_name} {self.stub}\\\")\\n recipe.download(\\n overwrite=overwrite,\\n refresh_token=refresh_token,\\n show_progress=show_progress,\\n )\",\n \"def download(all):\\n print(\\\"Downloading\\\")\",\n \"def download_all_data(self) -> None:\\n print(\\\"Download in progress.\\\")\\n self.download_data(os.environ[\\\"NC_TOKEN_TRAIN_CHARACTERS\\\"], \\\"nextcloud\\\")\\n self.download_data(os.environ[\\\"NC_TOKEN_TRAIN_FRAGMENTS\\\"], \\\"nextcloud\\\")\\n self.download_data(os.environ[\\\"HABBAKUK_URL\\\"], \\\"generic_url\\\")\\n print(\\\"Download complete!\\\")\",\n \"def download_model(source, target, filename):\\n if not os.path.exists(target):\\n os.mkdir(target) \\n target_file = str(Path(target).joinpath(filename))\\n if os.path.exists(target_file):\\n print('model already exists, skipping download')\\n return\\n print(\\\"Downloading from {} to {}\\\".format(source, target))\\n wget.download(source, target_file) \\n print(\\\"\\\\nDone!\\\")\",\n \"def _download_all(update_path=True, verbose=None):\\n\\n # iterate over dataset\\n for ds in dataset_list:\\n # call download\\n ds().download(update_path=True, verbose=verbose, accept=True)\",\n \"def download_pre_trained_model (model_name):\\n model_url = cfg.LIST_MODEL_TO_DOWNLOAD[model_name]\\n\\n file_name = (model_url.split(\\\"/\\\")[-1]).split(\\\".\\\")[0] # get file name from url\\n\\n # create directory if not exit\\n if not os.path.exists(os.path.join(cfg.PATH_PRE_TRAINED_MODELS,file_name)):\\n if not os.path.exists(cfg.PATH_PRE_TRAINED_MODELS):\\n os.mkdir(cfg.PATH_PRE_TRAINED_MODELS)\\n try:\\n click.echo(click.style(f\\\"\\\\n Downloading the {file_name} model \\\\n\\\", bg='green', bold=True, fg='white'))\\n file_location = save_zip_from_url(model_url, cfg.PATH_PRE_TRAINED_MODELS)\\n \\n click.echo(click.style(f'\\\\n Extraction of {file_name} ...\\\\n', bg='blue', bold=True, fg='white'))\\n\\n # Extract tar-file to annotation directory\\n with tarfile.open(name=file_location) as tar:\\n for member in tqdm(iterable=tar.getmembers(), total=len(tar.getmembers())):\\n tar.extract(member=member, path=cfg.PATH_PRE_TRAINED_MODELS)\\n # delete tar-file\\n os.remove(file_location)\\n return 0\\n\\n except expression as identifier:\\n return -1\\n else:\\n click.echo(click.style(f\\\"\\\\n {file_name} have been downloaded \\\\n\\\", bg='blue', bold=True, fg='white'))\\n return 1\",\n \"def download_model(\\n self, model_name: str, save_path: Union[str, Path] = \\\"./zoo/model.pth\\\"\\n ):\\n # check if the model name is valide\\n assert model_name in list(\\n self.meta.name\\n ), f\\\"requested model {model_name} does not exist\\\"\\n # TODO: fix, using pathlib\\n # check if save_path already has the model\\n save_dir = os.path.dirname(save_path)\\n if not os.path.exists(save_dir):\\n os.mkdir(save_dir)\\n else:\\n assert not os.path.exists(\\n save_path\\n ), f\\\"the save_path {save_path} is already used\\\"\\n\\n # fetch the model file\\n model_id = self.meta[self.meta[\\\"name\\\"] == model_name][\\\"models\\\"].iloc[0]\\n model_path = model_id.split(\\\"/\\\")\\n self.pkg[model_path[0]][model_path[1]].fetch(save_path)\",\n \"def download_all_datasets():\\n print(\\\"Downloading all datasets ...\\\")\\n for dataset in get_available_datasets():\\n download_dataset(dataset)\",\n \"def download(self, force: bool = False):\\n # hide this import, since we'll only ever need it _once_ (per model version)\\n from .. import io as tio\\n\\n model_fname = self.model_fpath.name\\n url = urllib.parse.urljoin(\\n \\\"https://github.com/bdewilde/textacy-data/releases/download/\\\",\\n self.model_id + \\\"/\\\" + model_fname,\\n )\\n tio.utils.download_file(\\n url, filename=model_fname, dirpath=self.data_dir, force=force,\\n )\",\n \"def download_model_from_gcs(self):\\n # download model\\n download_file_from_gcs(self.config.model_bucket_name,\\n self.config.model_gcs_path,\\n self.config.model_local_path)\\n\\n # download lable columns\\n download_file_from_gcs(self.config.model_bucket_name,\\n self.config.labels_gcs_path,\\n self.config.labels_local_path)\",\n \"def load_model(self, model_name, model_url):\\n\\n fname = join(self.root, model_name)\\n if not isfile(fname):\\n if self.verbose:\\n print(\\\"Could not find \\\" + fname + \\\".. attempt download\\\")\\n with urllib.request.urlopen(model_url) as res, open(fname, 'wb') as f:\\n shutil.copyfileobj(res, f)\\n if self.verbose:\\n print(\\\"Download complete.. model: \\\" + fname)\\n elif self.verbose:\\n print(\\\"Found model \\\" + fname + \\\"! :)\\\")\\n\\n model = load_model(fname)\\n self.model = model\",\n \"def download_all(self):\\r\\n # Fetch website list\\r\\n self.fetch_website_list()\\r\\n\\r\\n for website in self.website_list:\\r\\n self.download(website['id'])\",\n \"def download_pretrained_models(\\n models_root_dir='/tmp/sketch_rnn/models',\\n pretrained_models_url=PRETRAINED_MODELS_URL):\\n tf.gfile.MakeDirs(models_root_dir)\\n zip_path = os.path.join(\\n models_root_dir, os.path.basename(pretrained_models_url))\\n if os.path.isfile(zip_path):\\n tf.logging.info('%s already exists, using cached copy', zip_path)\\n else:\\n tf.logging.info('Downloading pretrained models from %s...',\\n pretrained_models_url)\\n urlretrieve(pretrained_models_url, zip_path)\\n tf.logging.info('Download complete.')\\n tf.logging.info('Unzipping %s...', zip_path)\\n with zipfile.ZipFile(zip_path) as models_zip:\\n models_zip.extractall(models_root_dir)\\n tf.logging.info('Unzipping complete.')\",\n \"def download():\\n raise NotImplementedError\",\n \"def _download_model_version_files(self):\\n model_version = self.client.get_model_version(name=self.model_name, version=self.model_version)\\n artifact_uri = model_version.source\\n return _download_artifact_from_uri(artifact_uri)\",\n \"def download(self):\\n pass\",\n \"def download(self):\\n pass\",\n \"def downloadModel(url):\\n print('Model download started...')\\n fileName = url.split('/')[-1]\\n filePath = f'../kerasModels/{fileName}'\\n\\n if not os.path.exists(os.path.dirname(filePath)):\\n try:\\n os.makedirs(os.path.dirname(fileName))\\n except OSError as exc:\\n if exc.errno != errno.EXIST:\\n raise\\n\\n urlretrieve(url, fileName)\\n print('Model download completed')\\n return fileName\",\n \"def import_all():\\n\\n # count the number of files loaded\\n count = 0\\n\\n # get model name\\n model_name_list = [model for data_models in settings.OBJECT_DATA_MODELS\\n for model in data_models]\\n\\n model_name_list += [model for model in settings.OTHER_DATA_MODELS]\\n\\n # import models one by one\\n for model_name in model_name_list:\\n import_model(model_name)\\n\\n # import localized strings\\n import_localized_strings(settings.LANGUAGE_CODE)\",\n \"def download():\\n return response.download(request,db)\",\n \"def download():\\n return response.download(request,db)\",\n \"def download():\\n return response.download(request,db)\",\n \"def download():\\n return response.download(request,db)\",\n \"def download():\\n return response.download(request,db)\",\n \"def download():\\n return response.download(request,db)\",\n \"def loadParts(self):\\n for i in range(15):\\n self.model_parts[i] = loadModel(\\\"ato_{}.pkl\\\".format(str(i)))\",\n \"def load_all_models(save_models_dir: str, model_type: str, model_i: int):\\n\\n try:\\n with open(os.path.join(save_models_dir, f\\\"{model_type}_{model_i}.pkl\\\"), \\\"rb\\\") as save_model:\\n model = pickle.load(save_model)\\n except Exception as e:\\n logger.error(f\\\"Error is: {e}\\\")\\n return None\\n\\n return model\",\n \"def download_model(\\n model: str,\\n force: bool = False,\\n) -> str:\\n if model in {\\\"small\\\", \\\"medium\\\", \\\"large\\\"}:\\n latest_version = get_latest_version(model)\\n model = f\\\"da_dacy_{model}_trf-{latest_version}\\\"\\n mdl_version = model.split(\\\"-\\\")[-1]\\n\\n if model not in models_url:\\n raise ValueError(\\n f\\\"The model '{model}' is not available in DaCy. Please use dacy.models() to see a\\\"\\n + \\\" list of all models\\\",\\n )\\n\\n mdl = model.split(\\\"-\\\")[0]\\n if mdl in get_installed_models() and not force and version(mdl) == mdl_version:\\n return mdl\\n install(models_url[model])\\n return mdl\",\n \"def _get_models(self, req, is_detail):\\n context = req.environ['meteos.context']\\n\\n search_opts = {}\\n search_opts.update(req.GET)\\n\\n # Remove keys that are not related to model attrs\\n search_opts.pop('limit', None)\\n search_opts.pop('offset', None)\\n sort_key = search_opts.pop('sort_key', 'created_at')\\n sort_dir = search_opts.pop('sort_dir', 'desc')\\n\\n models = self.engine_api.get_all_models(\\n context, search_opts=search_opts, sort_key=sort_key,\\n sort_dir=sort_dir)\\n\\n limited_list = common.limited(models, req)\\n\\n if is_detail:\\n models = self._view_builder.detail_list(req, limited_list)\\n else:\\n models = self._view_builder.summary_list(req, limited_list)\\n return models\",\n \"def download_all_files(self):\\n self.server_handler.get_sensor_data_from_server()\",\n \"def downloadAll(self, force=False):\\n if self.minutesSinceLastUpdate() == 0 and force == False:\\n self.log(\\\"TOO SOON SINCE LAST DOWNLOAD!\\\")\\n return\\n for grabber in self.grabbers:\\n self.downloadGrab(grabber[\\\"url\\\"], grabber[\\\"ID\\\"])+\\\"\\\\n\\\"\",\n \"def download_files(self) -> None:\\n\\n for name, url in self.files.items():\\n print(f\\\"Download {name.split('/')[-1]}\\\")\\n wget.download(url, os.path.join(\\\"data\\\", name))\",\n \"def check_models():\\n # Check if Models exist\\n if request.method == 'GET':\\n if models_exist():\\n return jsonify({'message': 'models found'})\\n else:\\n return jsonify({'message': 'one or more models missing'}), 409\\n\\n # Post Method, download models\\n else:\\n task = download_models.apply_async()\\n task_url = url_for('model_download_status', task_id=task.id)\\n return jsonify({'message': 'download started', 'location': task_url}), 202, {'Location': task_url}\",\n \"def GetModels(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"async def list(request):\\n dict_answer = {'models': [item[1]+' '+item[0]+str(item[2:]) for item in models_db],\\n 'datasets': [conv_time(d.stat().st_atime)+' '+str(d.name) for d in Path('data/datasets/').glob('*')],\\n }\\n return web.json_response(dict_answer)\",\n \"def train(self, absList, modelFilename):\\n pass\",\n \"def load_model(self) -> Any:\",\n \"def _download_model(download_url):\\n\\n pip_args = [\\\"--no-cache-dir\\\"]\\n cmd = [sys.executable, \\\"-m\\\", \\\"pip\\\", \\\"install\\\"] + pip_args + [download_url]\\n\\n return subprocess.call(cmd, env=os.environ.copy())\",\n \"def GetModels(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def download_model(model, model_hash, model_dir):\\n if not os.path.isdir(model_dir):\\n os.mkdir(model_dir)\\n filename = os.path.join(model_dir, model)\\n\\n logger.info(f\\\"Downloading {model} to {filename}...\\\")\\n urllib.request.urlretrieve(\\n os.path.join(\\\"http://genesis.ugent.be/uvpublicdata/ms2pip/\\\", model), filename\\n )\\n if not check_model_integrity(filename, model_hash):\\n raise InvalidXGBoostModelError()\",\n \"def import_all_model_modules():\\r\\n import brokerage.model\\r\\n # ensure that these imports don't get auto-deleted! they have side effects.\\r\\n brokerage.model\",\n \"def download():\\n basedir = os.path.dirname(os.path.dirname(__file__))\\n print(basedir)\\n datadir = os.path.join(basedir,\\\"data/NeonTreeEvaluation/\\\")\\n print(\\\"Downloading data files to {}\\\".format(datadir)) \\n eval_url = zenodo_url(concept_rec_id=\\\"3723356\\\", datadir=datadir)\",\n \"def download_model(key, output_path):\\n print(\\\"Looking fro model in {}\\\".format(output_path))\\n if os.path.exists(output_path):\\n print('File at: {} already exists'.format(output_path))\\n else:\\n download_file_from_s3(key, output_path)\",\n \"def _get_model_list(self):\\n self.model_arch_file = os.path.join(self.model_dir, self.model_name + '.prototxt')\\n self.model_weight_file = os.path.join(self.model_dir, self.model_name + '.caffemodel')\\n self.filelist.append(self.model_arch_file)\\n self.filelist.append(self.model_weight_file)\",\n \"def download_tf_params():\\n\\n if not os.path.exists(MODEL_DIR):\\n os.makedirs(MODEL_DIR)\\n filename = DATA_URL.split('/')[-1]\\n filepath = os.path.join(MODEL_DIR, filename)\\n\\n if not os.path.exists(filepath):\\n def _progress(count, block_size, total_size):\\n sys.stdout.write('\\\\r>> Downloading %s %.1f%%' % (\\n filename, float(count * block_size) / float(total_size) * 100.0))\\n sys.stdout.flush()\\n\\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\\n statinfo = os.stat(filepath)\\n print()\\n print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.')\\n\\n tarfile.open(filepath, 'r:gz').extractall(MODEL_DIR)\",\n \"def _fetch_large():\\n # Large training data:\\n resource(\\n target=data_path(\\\"eeg\\\", \\\"SMNI_CMI_TRAIN.tar.gz\\\"),\\n url=\\\"https://kdd.ics.uci.edu/databases/eeg/SMNI_CMI_TRAIN.tar.gz\\\",\\n )\\n dependency(\\n target=data_path(\\\"eeg\\\", \\\"train\\\"),\\n source=data_path(\\\"eeg\\\", \\\"SMNI_CMI_TRAIN.tar.gz\\\"),\\n commands=[\\n \\\"tar xzf SMNI_CMI_TRAIN.tar.gz\\\",\\n \\\"mv SMNI_CMI_TRAIN train\\\",\\n \\\"find train | grep gz$ | xargs gunzip\\\",\\n ],\\n )\\n # Large test data:\\n resource(\\n target=data_path(\\\"eeg\\\", \\\"SMNI_CMI_TEST.tar.gz\\\"),\\n url=\\\"https://kdd.ics.uci.edu/databases/eeg/SMNI_CMI_TEST.tar.gz\\\",\\n )\\n dependency(\\n target=data_path(\\\"eeg\\\", \\\"test\\\"),\\n source=data_path(\\\"eeg\\\", \\\"SMNI_CMI_TEST.tar.gz\\\"),\\n commands=[\\n \\\"tar xzf SMNI_CMI_TEST.tar.gz\\\",\\n \\\"mv SMNI_CMI_TEST test\\\",\\n \\\"find test | grep gz$ | xargs gunzip\\\",\\n ],\\n )\",\n \"def download_entire_dataset(dataset_name, num_data, labels, method, cache_dir):\\n\\n print('Downloading {}...'.format(dataset_name))\\n preprocessor = preprocess_method_dict[method]()\\n\\n # Select the first `num_data` samples from the dataset.\\n target_index = numpy.arange(num_data) if num_data >= 0 else None\\n dataset_parts = D.molnet.get_molnet_dataset(dataset_name, preprocessor,\\n labels=labels,\\n target_index=target_index)\\n dataset_parts = dataset_parts['dataset']\\n\\n # Cache the downloaded dataset.\\n if not os.path.exists(cache_dir):\\n os.makedirs(cache_dir)\\n\\n for i, part in enumerate(['train', 'valid', 'test']):\\n filename = dataset_part_filename(part, num_data)\\n path = os.path.join(cache_dir, filename)\\n NumpyTupleDataset.save(path, dataset_parts[i])\\n return dataset_parts\",\n \"def list_models():\\n\\n cmd = dict()\\n cmd[\\\"type_\\\"] = \\\"list_models\\\"\\n cmd[\\\"name_\\\"] = \\\"\\\"\\n \\n s = comm.send_and_receive_socket(cmd)\\n\\n msg = comm.recv_string(s)\\n\\n if msg != \\\"Success!\\\":\\n raise Exception(msg)\\n \\n json_str = comm.recv_string(s) \\n \\n s.close() \\n\\n return json.loads(json_str)\",\n \"def download_pretrained_weights(env_name):\\n print('Downloading model weights to ')\\n os.system('mkdir -p %s' % MODEL_CACHE_DIR)\\n os.system('cd \\\"%s\\\" && curl -s -S \\\"%s\\\" > %s' %\\n (MODEL_CACHE_DIR, ENV_TO_URL[env_name], ENV_TO_FNAME[env_name]))\",\n \"def ListModels(self, request, context):\\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)\",\n \"def _get_or_download_model(self, download: bool) -> Optional[str]:\\n home_dir = home_directory()\\n downloaded_models_dir = os.path.join(home_dir, MODELS_DIR)\\n\\n if not os.path.exists(downloaded_models_dir):\\n os.makedirs(downloaded_models_dir)\\n\\n model_hashed_name = get_hashed_name(self.embedding + self.model)\\n model_path = os.path.join(downloaded_models_dir, model_hashed_name)\\n\\n if not os.path.exists(model_path):\\n if not download:\\n return\\n\\n model_download_path = model_path + '.' + self.embedding_cls.EMBEDDING_MODELS[self.model].format\\n model_download_url = self.embedding_cls.EMBEDDING_MODELS[self.model].download_url\\n print(f\\\"Model does not exists, Downloading model: {self.model}\\\")\\n download_from_url(model_download_url, model_download_path)\\n extract_file(model_download_path, model_path)\\n if os.path.exists(model_download_path):\\n os.remove(model_download_path)\\n print(f\\\"Model downloaded successfully!\\\")\\n return model_path\",\n \"def _pc_load_models(model_name = None, mod_list = None, n_sample = None, verbose = False, **kwargs):\\n\\n if model_name is not None:\\n mod_list = glob.glob(model_name + '*.out')\\n if mod_list is None or mod_list == []:\\n pc.log_.error('No model found', calling='load models')\\n return None\\n if n_sample is not None:\\n if n_sample > len(mod_list):\\n pc.log_.error('less models {0:d} than n_sample {1:d}'.format(len(mod_list), n_sample),\\n calling='load models')\\n return None\\n mod_list = random.sample(mod_list, n_sample)\\n m = []\\n for outfile in mod_list:\\n if outfile[-4::] == '.out':\\n model_name = outfile[0:-4]\\n else:\\n model_name = outfile\\n try:\\n cm = pc.CloudyModel(model_name, verbose=0, **kwargs)\\n if not cm.aborted:\\n m.append(cm)\\n if verbose:\\n print('{0} model read'.format(outfile[0:-4]))\\n except:\\n pass\\n pc.log_.message('{0} models read'.format(len(m)), calling='load_models')\\n return m\",\n \"def load_model(self, filename):\\r\\n pass\",\n \"def get_models(make):\\n api_url = 'https://api.edmunds.com/api/vehicle/v2/{}/models?fmt=json&api_key={}'\\\\\\n .format(make, API_KEY)\\n r = requests.get(api_url).json()\\n all_models = [model['name'] for model in r['models']]\\n return all_models\",\n \"def get_data( name=None, force_download=False, version=19, target_extension='.csv' ):\\n os.makedirs(DATA_PATH, exist_ok=True)\\n\\n def download_data( version ):\\n url = \\\"https://ndownloader.figshare.com/articles/14766102/versions/\\\" + str(version)\\n target_file_name = \\\"14766102.zip\\\"\\n target_file_name_path = tf.keras.utils.get_file(target_file_name, url,\\n cache_subdir=DATA_PATH, extract = True )\\n os.remove( DATA_PATH + target_file_name )\\n\\n if force_download:\\n download_data( version = version )\\n\\n\\n files = []\\n for fname in os.listdir(DATA_PATH):\\n if ( fname.endswith(target_extension) ) :\\n fname = os.path.join(DATA_PATH, fname)\\n files.append(fname)\\n\\n if len( files ) == 0 :\\n download_data( version = version )\\n for fname in os.listdir(DATA_PATH):\\n if ( fname.endswith(target_extension) ) :\\n fname = os.path.join(DATA_PATH, fname)\\n files.append(fname)\\n\\n if name == 'all':\\n return files\\n\\n datapath = None\\n\\n for fname in os.listdir(DATA_PATH):\\n mystem = (Path(fname).resolve().stem)\\n mystem = (Path(mystem).resolve().stem)\\n mystem = (Path(mystem).resolve().stem)\\n if ( name == mystem and fname.endswith(target_extension) ) :\\n datapath = os.path.join(DATA_PATH, fname)\\n\\n if datapath is None:\\n raise ValueError('File doesnt exist. Options: ' , os.listdir(DATA_PATH))\\n return datapath\",\n \"def get_model_list():\\n with open(os.path.join(MODELS_FOLDER, \\\"models.json\\\"), \\\"r\\\") as model_file:\\n model_list = json.load(model_file)\\n return model_list\",\n \"def load_model(self, **params):\\n \\t# file_name = params['name']\\n # return pickle.load(gzip.open(file_name, 'rb'))\",\n \"def models():\\n if flask.request.args.get('refresh') == '1':\\n app.config['store_cache'].reset()\\n cached_data = app.config['store_cache'].read()\\n if cached_data is not None:\\n return json.dumps(cached_data)\\n\\n store_urls = app.config['store_url_list']\\n aggregated_dict = dict()\\n for i, store_url in enumerate(store_urls):\\n if len(store_url) == 0:\\n continue\\n model_list = list()\\n if store_url[-1] != '/':\\n store_base_url = store_url + '/'\\n else:\\n store_base_url = store_url\\n try:\\n page = requests.get(store_base_url)\\n except requests.exceptions.RequestException as e:\\n logger.warning('Skip %s due to error %s' % (store_base_url, e))\\n continue\\n parser = StoreParser()\\n parser.feed(page.content)\\n msg = 'Thanks for visiting {}'.format(store_base_url)\\n if len(parser.get_child_dirs()) > 0:\\n dirs = [d[:-1] for d in parser.get_child_dirs()]\\n else:\\n response = requests.get(os.path.join(store_base_url,'master.json'))\\n if response.status_code == 200:\\n json_response = json.loads(response.content)\\n dirs = json_response['children']\\n msg = json_response['msg']\\n else:\\n continue\\n for subdir in dirs:\\n tmp_dict = {'dir_name': subdir}\\n response = requests.get(os.path.join(store_base_url,subdir,'info.json'))\\n if response.status_code == 200:\\n tmp_dict['info'] = json.loads(response.content)\\n tmp_dict['id'] = str(uuid.uuid4())\\n response = requests.get(os.path.join(store_base_url,subdir,'aux.json'))\\n if response.status_code == 200:\\n tmp_dict['aux'] = json.loads(response.content)\\n model_list.append(tmp_dict)\\n store_info = {'base_url': store_base_url, 'welcome_msg': msg,\\n 'model_list': model_list}\\n aggregated_dict[store_base_url] = store_info\\n app.config['store_cache'].write(aggregated_dict)\\n return json.dumps(aggregated_dict)\",\n \"def load_models():\\n vectorizer = ModelStorage.objects.all().values_list(\\\"vectorizer\\\", flat = True)[0]\\n classifier = ModelStorage.objects.all().values_list(\\\"classifier\\\", flat = True)[0]\\n\\n return vectorizer, classifier\",\n \"def _load_model(self):\\n self._load_scaler('scaler.save')\\n self._load_encoder('encoder0.save', 0)\\n self._load_encoder('encoder1.save', 1)\\n self._load_neural_network('model.json', 'model.h5')\\n return\",\n \"def model_fn(model_dir):\\n ctx = mx.cpu()\\n net = unet.Unet()\\n print (\\\"Loading\\\", model_dir)\\n if path.exists(model_dir+\\\"/unet_RGB.params\\\"):\\n print (\\\"Loading RGB Model\\\")\\n net.load_params(model_dir+\\\"/unet_RGB.params\\\", ctx)\\n print (\\\"RGB Model Loaded\\\")\\n \\n elif path.exists(model_dir+\\\"/unet_ALL_BANDS.params\\\"):\\n print (\\\"Loading ALL_BANDS Model\\\")\\n net.load_params(model_dir+\\\"/unet_ALL_BANDS.params\\\", ctx)\\n print (\\\"ALL_BANDS Model Loaded\\\")\\n \\n else:\\n print (\\\"Model Missing\\\")\\n net=None\\n return (net)\",\n \"def download_data(self):\\r\\n \\r\\n for file in self.__files:\\r\\n file_to_download = os.path.join(self.__folder, os.path.basename(file))\\r\\n if not os.path.isfile(file_to_download):\\r\\n self.__download_file(file)\",\n \"def download_english(paths):\\n language_path = os.path.join(paths[\\\"languages\\\"], \\\"English\\\")\\n\\n if not os.path.isdir(language_path):\\n print(\\\"DOWNLOADING ENGLISH MODEL\\\")\\n os.makedirs(language_path)\\n r = requests.get(ENGLISH_MODEL_URL)\\n with open(os.path.join(language_path, TRANSCRIPTION_MODEL), \\\"wb\\\") as f:\\n f.write(r.content)\\n\\n r = requests.get(ENGLISH_ALPHABET_URL)\\n with open(os.path.join(language_path, ALPHABET_FILE), \\\"wb\\\") as f:\\n f.write(r.content)\",\n \"def get_all_models() -> list:\\n\\n conn = database_connect()\\n if(conn is None):\\n return None\\n cur = conn.cursor()\\n\\n try:\\n # SQL statement and execute\\n sql = \\\"\\\"\\\"SELECT manufacturer, description, modelnumber, weight\\n FROM Model\\\"\\\"\\\"\\n cur.execute(sql, ())\\n\\n # Attempt to fetch first row\\n result = cur.fetchall()\\n\\n if result == None:\\n cur.close()\\n conn.close()\\n return []\\n\\n models = []\\n for row in result:\\n models.append(\\n [row[0], row[1], row[2], row[3]]\\n )\\n\\n cur.close()\\n conn.close()\\n return models\\n except Exception as e:\\n print(\\\"fff\\\")\\n print(e)\\n # If login failed, return None\\n cur.close()\\n conn.close()\\n return []\",\n \"def download_trained_weights(coco_model_path, verbose=1):\\n if verbose > 0:\\n print(\\\"Downloading pretrained model to \\\" + coco_model_path + \\\" ...\\\")\\n with urllib.request.urlopen(COCO_MODEL_URL) as resp, open(coco_model_path, 'wb') as out:\\n shutil.copyfileobj(resp, out)\\n if verbose > 0:\\n print(\\\"... done downloading pretrained model!\\\")\",\n \"def model_files(cmd_args):\\n if cmd_args.learning_file_list:\\n learning_files_list = files_constructor(cmd_args, file_type='learning')\\n else:\\n learning_files_list = None\\n\\n if cmd_args.prediction_file:\\n prediction_file = files_constructor(cmd_args, file_type='prediction')\\n else:\\n prediction_file = None\\n\\n\\n return learning_files_list, prediction_file\",\n \"def import_data(self):\\n self.models = []\\n for o in self.loader.load():\\n klass = self.type_for(o)\\n if hasattr(klass, \\\"from_api\\\"):\\n self.models.append(klass.from_api(o))\\n else:\\n self.models.append(klass(o))\\n return self.models\",\n \"def download(self,**attrs):\\n\\t\\treturn super().download(**attrs)\",\n \"def _get_model_list(self):\\n model_filelist = os.listdir(os.path.join(self.pack_file_path, self.model_dir))\\n for i in model_filelist:\\n model_file = os.path.join(self.model_dir, i)\\n self.filelist.append(model_file)\",\n \"def ListModels(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def ListModels(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8000574","0.7724834","0.74329823","0.71786356","0.6747603","0.6745747","0.6659048","0.641336","0.63715756","0.6277509","0.6269505","0.626529","0.61694473","0.6133393","0.6132167","0.6128733","0.612146","0.6082238","0.6054536","0.6049674","0.60273546","0.60243905","0.60172665","0.6008813","0.5992585","0.5986815","0.5967681","0.5951079","0.59448475","0.5903253","0.59032494","0.5894694","0.588486","0.5879402","0.5860243","0.5848361","0.5822183","0.582092","0.5820604","0.5820604","0.5793419","0.5746455","0.57425785","0.57425785","0.57425785","0.57425785","0.57425785","0.57425785","0.5703176","0.56898826","0.56863165","0.56843436","0.56826025","0.5675924","0.56679255","0.5665205","0.5629456","0.562364","0.56171155","0.56020486","0.56016964","0.5590615","0.55904275","0.55897826","0.5581543","0.55779076","0.55775726","0.5561821","0.5553999","0.5549113","0.5547828","0.5546383","0.55348665","0.5530827","0.55277604","0.55217147","0.55202","0.5514556","0.55126023","0.55121684","0.55095303","0.550892","0.5504184","0.55017245","0.5499153","0.5488888","0.5483186","0.5477499","0.5467953","0.54657966","0.54646736","0.5456383","0.54562336","0.54562336","0.54522735","0.54522735","0.54522735","0.54522735","0.54522735","0.54522735","0.54522735"],"string":"[\n \"0.8000574\",\n \"0.7724834\",\n \"0.74329823\",\n \"0.71786356\",\n \"0.6747603\",\n \"0.6745747\",\n \"0.6659048\",\n \"0.641336\",\n \"0.63715756\",\n \"0.6277509\",\n \"0.6269505\",\n \"0.626529\",\n \"0.61694473\",\n \"0.6133393\",\n \"0.6132167\",\n \"0.6128733\",\n \"0.612146\",\n \"0.6082238\",\n \"0.6054536\",\n \"0.6049674\",\n \"0.60273546\",\n \"0.60243905\",\n \"0.60172665\",\n \"0.6008813\",\n \"0.5992585\",\n \"0.5986815\",\n \"0.5967681\",\n \"0.5951079\",\n \"0.59448475\",\n \"0.5903253\",\n \"0.59032494\",\n \"0.5894694\",\n \"0.588486\",\n \"0.5879402\",\n \"0.5860243\",\n \"0.5848361\",\n \"0.5822183\",\n \"0.582092\",\n \"0.5820604\",\n \"0.5820604\",\n \"0.5793419\",\n \"0.5746455\",\n \"0.57425785\",\n \"0.57425785\",\n \"0.57425785\",\n \"0.57425785\",\n \"0.57425785\",\n \"0.57425785\",\n \"0.5703176\",\n \"0.56898826\",\n \"0.56863165\",\n \"0.56843436\",\n \"0.56826025\",\n \"0.5675924\",\n \"0.56679255\",\n \"0.5665205\",\n \"0.5629456\",\n \"0.562364\",\n \"0.56171155\",\n \"0.56020486\",\n \"0.56016964\",\n \"0.5590615\",\n \"0.55904275\",\n \"0.55897826\",\n \"0.5581543\",\n \"0.55779076\",\n \"0.55775726\",\n \"0.5561821\",\n \"0.5553999\",\n \"0.5549113\",\n \"0.5547828\",\n \"0.5546383\",\n \"0.55348665\",\n \"0.5530827\",\n \"0.55277604\",\n \"0.55217147\",\n \"0.55202\",\n \"0.5514556\",\n \"0.55126023\",\n \"0.55121684\",\n \"0.55095303\",\n \"0.550892\",\n \"0.5504184\",\n \"0.55017245\",\n \"0.5499153\",\n \"0.5488888\",\n \"0.5483186\",\n \"0.5477499\",\n \"0.5467953\",\n \"0.54657966\",\n \"0.54646736\",\n \"0.5456383\",\n \"0.54562336\",\n \"0.54562336\",\n \"0.54522735\",\n \"0.54522735\",\n \"0.54522735\",\n \"0.54522735\",\n \"0.54522735\",\n \"0.54522735\",\n \"0.54522735\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83159,"cells":{"query":{"kind":"string","value":"Generates AppStream metadata of a specific kind"},"document":{"kind":"string","value":"def _generate_metadata_kind(filename, targets=None, qa_group=None):\n db = LvfsDatabase(os.environ)\n db_firmware = LvfsDatabaseFirmware(db)\n items = db_firmware.get_items()\n store = appstream.Store('lvfs')\n for item in items:\n\n # filter\n if item.target == 'private':\n continue\n if targets and item.target not in targets:\n continue\n if qa_group and qa_group != item.qa_group:\n continue\n\n # add each component\n for md in item.mds:\n component = appstream.Component()\n component.id = md.cid\n component.kind = 'firmware'\n component.name = md.name\n component.summary = md.summary\n component.description = md.description\n if md.url_homepage:\n component.urls['homepage'] = md.url_homepage\n component.metadata_license = md.metadata_license\n component.project_license = md.project_license\n component.developer_name = md.developer_name\n\n # add provide\n if md.guid:\n prov = appstream.Provide()\n prov.kind = 'firmware-flashed'\n prov.value = md.guid\n component.add_provide(prov)\n\n # add release\n if md.version:\n rel = appstream.Release()\n rel.version = md.version\n rel.description = md.release_description\n if md.release_timestamp:\n rel.timestamp = md.release_timestamp\n rel.checksums = []\n rel.location = 'https://secure-lvfs.rhcloud.com/downloads/' + item.filename\n rel.size_installed = md.release_installed_size\n rel.size_download = md.release_download_size\n component.add_release(rel)\n\n # add container checksum\n if md.checksum_container:\n csum = appstream.Checksum()\n csum.target = 'container'\n csum.value = md.checksum_container\n csum.filename = item.filename\n rel.add_checksum(csum)\n\n # add content checksum\n if md.checksum_contents:\n csum = appstream.Checksum()\n csum.target = 'content'\n csum.value = md.checksum_contents\n csum.filename = md.filename_contents\n rel.add_checksum(csum)\n\n # add component\n store.add(component)\n\n # dump to file\n if not os.path.exists(DOWNLOAD_DIR):\n os.mkdir(DOWNLOAD_DIR)\n filename = os.path.join(DOWNLOAD_DIR, filename)\n store.to_file(filename)\n return filename"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _generate_metadata_kind(filename, items, affidavit=None):\n store = appstream.Store('lvfs')\n for item in items:\n\n # add each component\n for md in item.mds:\n component = appstream.Component()\n component.id = md.cid\n component.kind = 'firmware'\n component.name = md.name\n component.summary = md.summary\n component.description = md.description\n if md.url_homepage:\n component.urls['homepage'] = md.url_homepage\n component.metadata_license = md.metadata_license\n component.project_license = md.project_license\n component.developer_name = md.developer_name\n\n # add provide\n for guid in md.guids:\n prov = appstream.Provide()\n prov.kind = 'firmware-flashed'\n prov.value = guid\n component.add_provide(prov)\n\n # add release\n if md.version:\n rel = appstream.Release()\n rel.version = md.version\n rel.description = md.release_description\n if md.release_timestamp:\n rel.timestamp = md.release_timestamp\n rel.checksums = []\n rel.location = app.config['FIRMWARE_BASEURL'] + item.filename\n rel.size_installed = md.release_installed_size\n rel.size_download = md.release_download_size\n rel.urgency = md.release_urgency\n component.add_release(rel)\n\n # add container checksum\n if md.checksum_container:\n csum = appstream.Checksum()\n csum.target = 'container'\n csum.value = md.checksum_container\n csum.filename = item.filename\n rel.add_checksum(csum)\n\n # add content checksum\n if md.checksum_contents:\n csum = appstream.Checksum()\n csum.target = 'content'\n csum.value = md.checksum_contents\n csum.filename = md.filename_contents\n rel.add_checksum(csum)\n\n # add screenshot\n if md.screenshot_caption:\n ss = appstream.Screenshot()\n ss.caption = md.screenshot_caption\n if md.screenshot_url:\n im = appstream.Image()\n im.url = md.screenshot_url\n ss.add_image(im)\n component.add_screenshot(ss)\n\n # add requires for each allowed vendor_ids\n group = db.groups.get_item(item.group_id)\n if group.vendor_ids:\n req = appstream.Require()\n req.kind = 'firmware'\n req.value = 'vendor-id'\n if len(group.vendor_ids) == 1:\n req.compare = 'eq'\n else:\n req.compare = 'regex'\n req.version = '|'.join(group.vendor_ids)\n component.add_require(req)\n\n # add manual firmware or fwupd version requires\n for req_txt in md.requirements:\n split = req_txt.split('/', 4)\n req = appstream.Require()\n req.kind = split[0]\n req.value = split[1]\n req.compare = split[2]\n req.version = split[3]\n component.add_require(req)\n\n # add component\n store.add(component)\n\n # dump to file\n download_dir = app.config['DOWNLOAD_DIR']\n if not os.path.exists(download_dir):\n os.mkdir(download_dir)\n filename = os.path.join(download_dir, filename)\n store.to_file(filename)\n\n # upload to the CDN\n blob = open(filename, 'rb').read()\n _upload_to_cdn(filename, blob)\n\n # generate and upload the detached signature\n if affidavit:\n blob_asc = affidavit.create(blob)\n _upload_to_cdn(filename + '.asc', blob_asc)","def gen_file_metadata_summary(self, metadata):\n title = sub('[\\W_]+', '', metadata['title'].lower())\n season = str(metadata['season']).zfill(2)\n episode = str(metadata['episode']).zfill(2)\n\n file_metadata_summary = f'{title}.S{season}E{episode}'\n return file_metadata_summary","def generate_metadata(self):\n self.metadata = {\n 'title': os.path.basename(self.source_file).rsplit('.', 1)[0],\n 'url': self.relative_destination_file,\n 'full_path': os.path.dirname(self.relative_destination_file),\n 'short_path': self.shorten_path(\n os.path.dirname(self.relative_destination_file))\n }","def generate_custom_metadata(uuid, version, update_proto):\n COMPONENTS = E.components\n COMPONENT = E.component\n ID = E.id\n NAME = E.name\n SUMMARY = E.summary\n PROVIDES = E.provides\n FIRMWARE = E.firmware\n CUSTOM = E.custom\n VALUE = E.value\n RELEASES = E.releases\n RELEASE = E.release\n LOCATION = E.location\n CHECKSUM = E.checksum\n DESCRIPTION = E.description\n P = E.p\n SIZE = E.size\n REQUIRES = E.requires\n\n metadata_tree = COMPONENTS(\n COMPONENT(\n ID(\"com.hacker.firmware\"),\n NAME(\"TotallyNotMalicious\"),\n SUMMARY(\"This is fine\"),\n PROVIDES(\n FIRMWARE(\n uuid,\n type=\"flashed\",\n ),\n ),\n CUSTOM(\n VALUE(\n update_proto,\n key=\"LVFS::UpdateProtocol\",\n ),\n ),\n RELEASES(\n RELEASE(\n LOCATION(\n url_for(\"serve_cab\", _external=True, uuid=uuid, version=version, update_proto=update_proto)\n ),\n DESCRIPTION(\n P(\"Totally not malicious ;)\"),\n ),\n CHECKSUM(\n hashlib.sha1(generate_cab(uuid=uuid, version=version, update_proto=update_proto)).hexdigest(),\n type=\"sha1\", filename=\"poc.cab\", target=\"container\",\n ),\n SIZE(\"1337\", type=\"download\"),\n SIZE(\"0\", type=\"installed\"),\n urgency=\"high\", version=version, timestamp=\"1587399600\", install_duration=\"120\",\n ),\n ),\n REQUIRES(),\n type=\"firmware\",\n ),\n origin=\"lvfs\", version=\"0.9\",\n )\n\n metadata = etree.tostring(metadata_tree, pretty_print=True, xml_declaration=True, encoding=\"UTF-8\")\n\n return gzip.compress(metadata)","def construct_metadata(song):\n print(song) #temp","def create_metadata(scene: \"Scenemaker\") -> None:\r\n create_datadir()\r\n\r\n with open(dirpath / cng.GENERATED_DATA_DIR / cng.METADATA_FILE, \"w+\") as f:\r\n f.write(str(scene.num2name))","def gen_metadata(args):\n with open(args.bibfile) as bibfile:\n bib_db = BibTexParser(common_strings=True).parse_file(bibfile)\n entries = sorted(list(bib_db.entries),\n key=lambda x: x['year'], reverse=True)\n list([update_file(entry) for entry in entries])\n annotations = [entry_to_annotation(entry, args.PI) for entry in entries]\n stream = open(args.metadata, 'w')\n yaml.dump(annotations, stream, width=192, default_flow_style=False)\n stream.close()","def metadata(self) -> global___SummaryMetadata:","def _create_output_metadata(self):\n\n # Create output info.\n output_meta = _metadata_fb.TensorMetadataT()\n output_meta.name = \"probability\"\n output_meta.description = \"Probabilities of labels respectively.\"\n output_meta.content = _metadata_fb.ContentT()\n output_meta.content.contentProperties = _metadata_fb.FeaturePropertiesT()\n output_meta.content.contentPropertiesType = (\n _metadata_fb.ContentProperties.FeatureProperties)\n label_file = _metadata_fb.AssociatedFileT()\n label_file.name = os.path.basename(self.model_info.label_file)\n label_file.description = (\"Labels for classification categories.\")\n label_file.type = _metadata_fb.AssociatedFileType.TENSOR_AXIS_LABELS\n output_meta.associatedFiles = [label_file]\n return [output_meta]","def build_ns_file_metadata(file_type):\r\n file_description = f\"Your Nightscout {file_type} data, last updated at {datetime.utcnow()} UTC.\"\r\n file_tags = [\"open-aps\", \"Nightscout\", file_type, \"json\"]\r\n file_updated = str(datetime.now())\r\n return {\"tags\": file_tags, \"description\": file_description, \"updated_at\": file_updated}","def metadata(self): # -> None:\n ...","def generate_metadata(\n source_name,\n source_version\n):\n now = datetime.utcnow()\n write_recipt = str(uuid.uuid1())\n metadata_obj = {\n 'write_recipt': write_recipt,\n 'data_source': source_name,\n 'machine_source': platform.node(),\n 'version': source_version,\n 'package_version': _version.__version__,\n 'cron_datetime': now.isoformat()\n }\n\n return metadata_obj","def build_meta(self, root):\n ns_dc = {\"dc\": self.namespace_dc, }\n metadata = ET.SubElement(root, \"metadata\", nsmap=ns_dc)\n ET.SubElement(metadata,\n '{%s}title' % self.namespace_dc).text = self.title\n ET.SubElement(metadata,\n '{%s}creator' % self.namespace_dc).text = self.author\n ET.SubElement(metadata,\n '{%s}identifier' % self.namespace_dc,\n id='bookid').text = \"urn:uuid:%s\" % self.bookid\n ET.SubElement(metadata,\n '{%s}language' % self.namespace_dc).text = self.language\n ET.SubElement(metadata, 'meta', name=\"cover\", content=\"cover-image\")","def populate_metadata(case, config):\n return {\"Type\": \"Summary\",\n \"Title\": \"Verification\",\n \"Headers\": [\"Bit for Bit\", \"Configurations\", \"Std. Out Files\"]}","def define_metadata(cls, pcm):\n raise NotImplementedError()","def gen_meta(self, filename):\n nf_meta = {}\n nf_meta['filename'] = filename\n nf_meta['deleted'] = 0\n\n # http://stackoverflow.com/a/5297483\n nf_meta['key'] = hashlib.md5(str(filename).encode('utf-8')).hexdigest()\n self.log.debug(\"Note File Meta Key: %s\", nf_meta['key'])\n\n path = self.config.get_config('cfg_nt_path')\n\n # WARNING THIS IS PLATFORM SPECIFIC\n nf_meta['createdate'] = os.stat(path + \"/\" + filename).st_birthtime\n self.log.debug(\"Note File Meta Created: %s [%s]\", nf_meta['createdate'], time.ctime(nf_meta['createdate']))\n\n nf_meta['modifydate'] = os.stat(path + \"/\" + filename).st_mtime\n self.log.debug(\"Note File Meta Modified: %s [%s]\", nf_meta['modifydate'], time.ctime(nf_meta['modifydate']))\n\n return nf_meta","def assemble(metadata_file):\n\n def read(file):\n with open(file) as yaml:\n return load(yaml.read())\n\n def add_name(info):\n info['name'] = slugify(info['title'], separator='_')\n return info\n\n def get_files(filetype):\n filename = metadata_file.replace('metadata', filetype)\n folder = dirname(metadata_file)\n schema_files_pattern = join(folder, filename)\n return glob(schema_files_pattern)\n\n descriptor = add_name(read(metadata_file))\n resources = [add_name(read(file)) for file in get_files('resource')]\n model = get_files('model')\n\n descriptor['resources'] = resources\n if model and len(model) == 1:\n descriptor['model'] = model.pop()\n\n return DataPackage(descriptor)","def getMetadata(self):\n metadata = {}\n document_properties = self.document_loaded.getDocumentProperties()\n user_defined_properties = document_properties.getUserDefinedProperties()\n for container in [document_properties, user_defined_properties]:\n for property_name in dir(container):\n if property_name in ('SupportedServiceNames',):\n continue\n property_value = getattr(container, property_name, '')\n if property_value:\n if isinstance(property_value, basestring):\n metadata[property_name] = property_value\n elif isinstance(property_value, tuple) and isinstance(property_value[0], basestring):\n metadata[property_name] = property_value\n else:\n try:\n if property_value.typeName == 'com.sun.star.util.DateTime':\n # It is a local time and we have no timezone information.\n datetime = \"%02d/%02d/%04d %02d:%02d:%02d\" % (property_value.Day, property_value.Month,\n property_value.Year, property_value.Hours, property_value.Minutes, property_value.Seconds)\n metadata[property_name] = datetime\n except AttributeError:\n pass\n\n service_manager = helper_util.getServiceManager(self.hostname, self.port,\n self.uno_path,\n self.office_binary_path)\n type_detection = service_manager.createInstance(\"com.sun.star.document.TypeDetection\")\n uno_file_access = service_manager.createInstance(\"com.sun.star.ucb.SimpleFileAccess\")\n doc = uno_file_access.openFileRead(self.systemPathToFileUrl(self.document_url))\n input_stream = self._createProperty(\"InputStream\", doc)\n open_new_view = self._createProperty(\"OpenNewView\", True)\n filter_name = type_detection.queryTypeByDescriptor((input_stream,\n open_new_view), True)[0]\n doc.closeInput()\n metadata['MIMEType'] = mimemapper[\"mimetype_by_filter_type\"].get(filter_name)\n return metadata","def app_metadata_url():\n return \"https://raw.githubusercontent.com/aiidalab/aiidalab-hello-world/master/metadata.json\"","def metadata(self) -> global___SnippetConfigMetadata:","def write_metadata(zip, datapack):\n zip.writestr('pack.mcmeta', json.dumps({'pack':{'pack_format':1, 'description':datapack.desc}}, indent=4))\n zip.writestr('data/minecraft/tags/functions/load.json', json.dumps({'values':['{}:reset'.format(datapack.name)]}))\n zip.writestr('data/{}/functions/reset.mcfunction'.format(datapack.name), 'tellraw @a [\"\",{\"text\":\"Loot table randomizer by SethBling, modified by Joelius300\",\"color\":\"green\"}]')","def metadata(self) -> dict:\n meta = {}\n meta['filename'] = self.filename\n meta['label'] = self.label\n meta['url'] = self.url\n\n return meta","def _store_package_metadata(self):","def create_file_meta_data(vk4_container, args):\n log.debug(\"Entering create_file_meta_data()\")\n\n header_list = list()\n header_list.append(args.layer)\n header_list.append('\\n')\n header_list.append('File name')\n header_list.append(args.input)\n header_list.append('Title')\n header_list.append(args.input[:-4])\n header_list.append('Measurement date')\n header_list.append(str(vk4_container.measurement_conditions['month']) + '\\\\' +\n str(vk4_container.measurement_conditions['day']) + '\\\\' +\n str(vk4_container.measurement_conditions['year']))\n header_list.append('Measurement time')\n header_list.append(str(vk4_container.measurement_conditions['hour']) + ':' +\n str(vk4_container.measurement_conditions['minute']) + ':' +\n str(vk4_container.measurement_conditions['second']))\n # User mode?\n header_list.append('Objective lens')\n header_list.append(vk4_container.string_data['lens_name'] + ' ' +\n str(vk4_container.measurement_conditions['lens_magnification'] / 10.0) + 'x')\n header_list.append('Numerical Aperture')\n header_list.append(vk4_container.measurement_conditions['num_aperture'] / 1000.0)\n # Size? Standard?\n # Mode? Surface profile?\n # RPD? OFF?\n header_list.append('Quality')\n header_list.append('Skip 4 lines')\n header_list.append('Pitch (um)')\n header_list.append(vk4_container.measurement_conditions['pitch'] / 1000.0)\n header_list.append('Z measurement distance (um)')\n header_list.append(vk4_container.measurement_conditions['distance'] / 1000.0)\n # Double scan? OFF?\n header_list.append('Brightness 1')\n header_list.append(vk4_container.measurement_conditions['PMT_gain'])\n header_list.append('Brightness 2')\n br_2 = vk4_container.measurement_conditions['PMT_gain_2']\n header_list.append('---') if br_2 == 0 else header_list.append(br_2)\n # Not sure how they got ND filter to 30% in example csv\n header_list.append('ND filter (%)')\n header_list.append(vk4_container.measurement_conditions['ND_filter'] * 30)\n header_list.append('Optical zoom')\n header_list.append(vk4_container.measurement_conditions['optical_zoom'] / 10.0)\n # Average count? 1 time?\n # Filter? OFF?\n # Fine mode? ON?\n header_list.append('Line count')\n l_count = vk4_container.measurement_conditions['number_of_lines']\n header_list.append(l_count)\n\n header_list.append('Line position1')\n if l_count == 0:\n header_list.append('---')\n else:\n header_list.append(vk4_container.measurement_conditions['reserved_1'][0])\n\n header_list.append('Line position2')\n if l_count == 0:\n header_list.append('---')\n else:\n header_list.append(vk4_container.measurement_conditions['reserved_1'][1])\n\n header_list.append('Line position3')\n if l_count == 0:\n header_list.append('---')\n else:\n header_list.append(vk4_container.measurement_conditions['reserved_1'][2])\n\n header_list.append('Camera gain (db)')\n header_list.append(vk4_container.measurement_conditions['camera_gain'] * 6)\n header_list.append('Shutter speed')\n header_list.append(vk4_container.measurement_conditions['shutter_speed'])\n header_list.append('White balance mode')\n wb_mode = vk4_container.measurement_conditions['white_balance_mode']\n header_list.append('Auto') if wb_mode == 1 else header_list.append(wb_mode)\n header_list.append('White balance R')\n header_list.append(vk4_container.measurement_conditions['white_balance_red'])\n header_list.append('White balance B')\n header_list.append(vk4_container.measurement_conditions['white_balance_blue'])\n header_list.append('Intensity correction mode')\n header_list.append('Gamma correction')\n header_list.append('Gamma correction value')\n header_list.append(vk4_container.measurement_conditions['gamma'] / 100.0)\n header_list.append('Gamma offset (%)')\n header_list.append(vk4_container.measurement_conditions['gamma_correction_offset'] /\n 65536.0)\n # W/B inversion? OFF?\n # Head type? VK-X110?\n # Correct intensity eccentricity? OFF?\n # Correct field curvature? OFF?\n header_list.append('XY calibration (nm/pixel)')\n header_list.append(vk4_container.measurement_conditions['x_length_per_pixel'] / 1000.0)\n header_list.append('Z calibration (nm/digit)')\n header_list.append(vk4_container.measurement_conditions['z_length_per_digit'] / 1000.0)\n # Saturation?\n # Contrast?\n # Brightness?\n # AI noise elimination? Auto(ON)?\n # Angled surface noise filter? Auto(OFF)?\n header_list.append('Width')\n header_list.append(vk4_container.image_width)\n header_list.append('Height')\n header_list.append(vk4_container.image_height)\n # Skip amount? 1?\n\n out_type = args.type\n if out_type == 'hcsv':\n log.debug(\"Exiting create_file_meta_data() where out_type == %s\" % out_type)\n return np.reshape(header_list, (len(header_list) // 2, 2))\n else:\n # Can use a dict to attach info to an image using PILs Image module\n meta_dict = dict()\n for n in range(0, len(header_list), 2):\n meta_dict[header_list[n]] = header_list[n + 1]\n\n log.debug(\"Exiting create_file_meta_data() where out_type == %s\" % out_type)\n return meta_dict","def publish_metadata_in_ipfs(self):\n self._printout(self._publish_metadata_in_ipfs(self.args.metadata_file))","def serve_metadata():\n xml = generate_xml_metadata()\n return Response(xml, mimetype=\"application/gzip\")","def get_meta(meta):\n thumb_url = '{}{}?X-Plex-Token={}'.format(\n meta._server._baseurl, meta.thumb, meta._server._token)\n\n meta_dict = {'title': meta.title,\n 'rating': meta.rating if\n meta.rating is not None else 0.0,\n 'genres': [x.tag for x in meta.genres],\n 'server': [meta._server.friendlyName],\n 'thumb': [thumb_url]\n }\n if meta.guid:\n # guid will return (com.plexapp.agents.imdb://tt4302938?lang=en)\n # Agents will differ between servers.\n agent = meta.guid\n source_name = agent.split('://')[0].split('.')[-1]\n source_id = agent.split('://')[1].split('?')[0]\n meta_dict[source_name] = source_id\n\n if meta.type == 'movie':\n # For movies with same titles\n meta_dict['title'] = u'{} ({})'.format(meta.title, meta.year)\n return meta_dict","def writeToMetadata(self, context):\n pass","def make_image_metadata(metadata, suffix, outdir, i, rname, desc, rmsnoise):\n meta_suffix = copy.deepcopy(metadata)\n out_file = metadata['FITSImageFilename'][i]\n\n out_filebase = os.path.splitext(out_file)[0]\n out_filebase_suffix = out_filebase + suffix\n _update_metadata_imagedata(meta_suffix, out_filebase_suffix, i)\n\n meta_suffix['ProductType']['ReductionName'] = rname\n desc_prefix = meta_suffix['Description'].split(':')[0]\n meta_suffix['Description'] = desc_prefix + f': {desc}'\n\n meta_suffix['RMSNoise'] = [str(rmsnoise)]\n write_metadata(meta_suffix, outdir)","def addMetadata(*args, channelName: Union[AnyStr, bool]=\"\", channelType: Union[AnyStr, bool]=\"\",\n indexType: Union[AnyStr, bool]=\"\", scene: bool=True, streamName: Union[AnyStr,\n bool]=\"\", structure: Union[AnyStr, bool]=\"\", q=True, query=True,\n **kwargs)->Union[List[AnyStr], Any]:\n pass","def build_metadata(meta):\n\n ret = copy.copy(meta) if meta else dict()\n\n ret['name'] = meta.get('name', '')\n\n if 'index' in meta:\n if isinstance(meta.get('index'), str):\n ret['index'] = Index(meta.get('index'))\n elif isinstance(meta.get('index'), Index):\n ret['index'] = meta.get('index')\n\n ret['utc'] = True\n if 'utc' in meta and isinstance(meta.get('utc'), bool):\n ret['utc'] = meta.get('utc')\n\n return pmap(ret)","def get_metadata(sf):\r\n data = {}\r\n all_describe = sf.describe()\r\n\r\n s_objs = all_describe['sobjects']\r\n # scan the objects and save to a list...\r\n for obj in s_objs:\r\n row = {}\r\n row['name'] = obj['name']\r\n row['label'] = obj['label']\r\n row['custom'] = obj['custom']\r\n row['activateable'] = obj['activateable']\r\n row['keyPrefix'] = obj['keyPrefix']\r\n row['labelPlural'] = obj['labelPlural']\r\n\r\n row['raw'] = obj\r\n\r\n logger.info('\\t{}\\t-> {}'.format(obj['label'], obj['name']))\r\n data[row['name']] = row\r\n\r\n return data","def PrintMetadata(self):\n def PrintTrack(trackno, track):\n output = [f\"File {str(trackno + 1).zfill(2)}:\"]\n with IgnoreKeyError:\n output.append(f\"Disc {track['disc']}\")\n with IgnoreKeyError:\n output.append(f\"Side {track['side']}\")\n output.append(f\"Track {track['track'].ljust(2)}\")\n with IgnoreKeyError:\n output.append(f\"Phase {track['phase']}\")\n with IgnoreKeyError:\n output.append(f\"Subindex {track['subindex']}\")\n output.append(f\"Time {track['start_time']}\")\n output.append(f'\"{track[\"title\"]}\"')\n with IgnoreKeyError:\n output[-1] = f'{output[-1][:-1]}: {track[\"subtitle\"]}\"'\n print(' '.join(output))\n\n print(self)\n for trackno, track in enumerate(self.tracks):\n PrintTrack(trackno, track)\n filename = self.GetOutputFilename().replace(ext.WAV, ext.MKA)\n print(\"Filename:\", filename)","def app_metadata(requests_mock):\n return {\n \"description\": \"A test app that does not really exist.\",\n \"title\": \"Test App\",\n \"version\": \"1.0.0\",\n \"authors\": \"AiiDAlab team\",\n \"state\": \"development\",\n }","def metadata(self):\n return {\n \"wildtype\" : self.wildtype,\n \"genotypes\" : self.genotypes,\n \"phenotypes\" : self.Raw.phenotypes,\n \"stdeviations\" : self.stdeviations,\n \"n_replicates\" : self.n_replicates,\n \"mutations\" : self.mutations,\n \"log_transform\" : self.log_transform,\n \"order\" : self.order,\n \"epistasis\" : {\n \"keys\" : self.epistasis.keys,\n \"values\" : self.epistasis.values,\n }\n }","def write_stewicombo_metadata(file_name, metadata_dict, category=''):\n meta = set_stewicombo_meta(file_name, category=category)\n meta.tool_meta = metadata_dict\n write_metadata_to_file(paths, meta)","def metadata_reporter(self):\n logging.info('Creating summary report')\n header = '{}\\n'.format(','.join(self.headers))\n # Create a string to store all the results\n data = str()\n for sample in self.metadata:\n # Add the value of the appropriate attribute to the results string\n data += GenObject.returnattr(sample, 'name')\n # SampleName\n data += GenObject.returnattr(sample.run, 'SamplePlate')\n # Genus\n data += GenObject.returnattr(sample.general, 'closestrefseqgenus')\n # SamplePurity\n data += GenObject.returnattr(sample.confindr, 'num_contaminated_snvs')\n # N50\n n50 = GenObject.returnattr(sample.quast, 'N50',\n number=True)\n if n50 != '-,':\n data += n50\n else:\n data += '0,'\n # NumContigs\n data += GenObject.returnattr(sample.quast, 'num_contigs',\n number=True)\n # TotalLength\n data += GenObject.returnattr(sample.quast, 'Total_length',\n number=True)\n # MeanInsertSize\n data += GenObject.returnattr(sample.quast, 'mean_insert',\n number=True)\n # InsertSizeSTD\n data += GenObject.returnattr(sample.quast, 'std_insert',\n number=True)\n # AverageCoverageDepth\n data += GenObject.returnattr(sample.qualimap, 'MeanCoveragedata',\n number=True)\n # CoverageDepthSTD\n data += GenObject.returnattr(sample.qualimap, 'StdCoveragedata',\n number=True)\n # PercentGC\n data += GenObject.returnattr(sample.quast, 'GC',\n number=True)\n # MASH_ReferenceGenome\n data += GenObject.returnattr(sample.mash, 'closestrefseq')\n # MASH_NumMatchingHashes\n data += GenObject.returnattr(sample.mash, 'nummatches')\n # 16S_result\n data += GenObject.returnattr(sample.sixteens_full, 'sixteens_match')\n # 16S PercentID\n data += GenObject.returnattr(sample.sixteens_full, 'percent_id')\n # CoreGenesPresent\n data += GenObject.returnattr(sample.gdcs, 'coreresults')\n # rMLST_Result\n try:\n # If the number of matches to the closest reference profile is 53, return the profile number\n if sample.rmlst.matches == 53:\n if type(sample.rmlst.sequencetype) is list:\n rmlst_seq_type = ';'.join(sorted(sample.rmlst.sequencetype)).rstrip(';') + ','\n else:\n rmlst_seq_type = GenObject.returnattr(sample.rmlst, 'sequencetype')\n rmlst_seq_type = rmlst_seq_type if rmlst_seq_type != 'ND,' else 'new,'\n data += rmlst_seq_type\n else:\n # Otherwise the profile is set to new\n data += 'new,'\n except AttributeError:\n data += 'new,'\n # MLST_Result\n try:\n if sample.mlst.matches == 7:\n if type(sample.mlst.sequencetype) is list:\n mlst_seq_type = ';'.join(sorted(sample.mlst.sequencetype)).rstrip(';') + ','\n else:\n mlst_seq_type = GenObject.returnattr(sample.mlst, 'sequencetype')\n mlst_seq_type = mlst_seq_type if mlst_seq_type != 'ND,' else 'new,'\n data += mlst_seq_type\n else:\n data += 'new,'\n except AttributeError:\n data += 'new,'\n # MLST_gene_X_alleles\n try:\n # Create a set of all the genes present in the results (gene name split from allele)\n gene_set = {gene.split('_')[0] for gene in sample.mlst.combined_metadata_results}\n for gene in sorted(gene_set):\n allele_list = list()\n # Determine all the alleles that are present for each gene\n for allele in sample.mlst.combined_metadata_results:\n if gene in allele:\n allele_list.append(allele.replace(' ', '_'))\n # If there is more than one allele in the sample, add both to the string separated by a ';'\n if len(allele_list) > 1:\n data += '{},'.format(';'.join(allele_list))\n # Otherwise add the only allele\n else:\n data += allele_list[0] + ','\n # If there are fewer than seven matching alleles, add a ND for each missing result\n if len(gene_set) < 7:\n data += (7 - len(gene_set)) * 'ND,'\n except AttributeError:\n # data += '-,-,-,-,-,-,-,'\n data += 'ND,ND,ND,ND,ND,ND,ND,'\n # E_coli_Serotype\n try:\n # If no O-type was found, set the output to be O-untypeable\n if ';'.join(sample.ectyper.o_type) == '-':\n otype = 'O-untypeable'\n else:\n otype = sample.ectyper.o_type\n # Same as above for the H-type\n if ';'.join(sample.ectyper.h_type) == '-':\n htype = 'H-untypeable'\n\n else:\n htype = sample.ectyper.h_type\n serotype = '{otype}:{htype},'.format(otype=otype,\n htype=htype)\n # Add the serotype to the data string unless neither O-type not H-type were found; add ND instead\n data += serotype if serotype != 'O-untypeable:H-untypeable,' else 'ND,'\n except AttributeError:\n data += 'ND,'\n # SISTR_serovar_antigen\n data += GenObject.returnattr(sample.sistr, 'serovar_antigen').rstrip(';')\n # SISTR_serovar_cgMLST\n data += GenObject.returnattr(sample.sistr, 'serovar_cgmlst')\n # SISTR_serogroup\n data += GenObject.returnattr(sample.sistr, 'serogroup')\n # SISTR_h1\n data += GenObject.returnattr(sample.sistr, 'h1').rstrip(';')\n # SISTR_h2\n data += GenObject.returnattr(sample.sistr, 'h2').rstrip(';')\n # SISTR_serovar\n data += GenObject.returnattr(sample.sistr, 'serovar')\n # GeneSeekr_Profile\n try:\n if sample.genesippr.report_output:\n data += ';'.join(sample.genesippr.report_output) + ','\n else:\n data += 'ND,'\n except AttributeError:\n data += 'ND,'\n # Vtyper_Profile\n data += GenObject.returnattr(sample.verotoxin, 'verotoxin_subtypes_set')\n # AMR_Profile and resistant/sensitive status\n if sample.resfinder_assembled.pipelineresults:\n # Profile\n for resistance, resistance_set in sorted(sample.resfinder_assembled.pipelineresults.items()):\n data += '{res}({r_set});'.format(res=resistance.replace(',', ';'),\n r_set=';'.join(sorted(list(resistance_set))))\n data += ','\n # Resistant/Sensitive\n data += 'Resistant,'\n else:\n # Profile\n data += 'ND,'\n # Resistant/Sensitive\n data += 'Sensitive,'\n # Plasmid Result'\n if sample.mobrecon.pipelineresults:\n for plasmid, details in sorted(sample.mobrecon.pipelineresults.items()):\n data += '{plasmid}({details});'.format(plasmid=plasmid,\n details=details)\n data += ','\n else:\n data += 'ND,'\n # TotalPredictedGenes\n data += GenObject.returnattr(sample.prodigal, 'predictedgenestotal',\n number=True)\n # PredictedGenesOver3000bp\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesover3000bp',\n number=True)\n # PredictedGenesOver1000bp\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesover1000bp',\n number=True)\n # PredictedGenesOver500bp\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesover500bp',\n number=True)\n # PredictedGenesUnder500bp\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesunder500bp',\n number=True)\n # AssemblyDate\n data += datetime.now().strftime('%Y-%m-%d') + ','\n # PipelineVersion\n data += self.commit + ','\n # Name of the database used in the analyses\n data += os.path.split(self.reffilepath)[-1] + ','\n # Database download date\n data += self.download_date\n # Append a new line to the end of the results for this sample\n data += '\\n'\n # Replace any NA values with ND\n cleandata = data.replace('NA', 'ND')\n with open(os.path.join(self.reportpath, 'combinedMetadata.csv'), 'w') as metadatareport:\n metadatareport.write(header)\n metadatareport.write(cleandata)","def extract_meta_data(video_file_name, output_file=meta.txt, *args, **kwargs):","def get_stream_type(self) -> str:","def build_metadata(results):\n\n print('Building metadata...')\n\n fields = set(['name', 'timestamp', 'value', 'scrape_timestamp'])\n metadata = connector_pb2.GetDataResponse()\n\n for result in results:\n for metric in result['metric'].keys():\n if metric != '__name__':\n fields.add(metric)\n\n for field in fields:\n metadata.fieldInfo.extend([connector_pb2.FieldInfo(name = field)])\n\n return metadata","def meta_info_feats(self, output_path, file_types):\n return self.build_meta(output_path, file_types)","def metadataDirectory(self):\n guid_hash = utils.sha1hash(self.guid)\n return str(Path('Metadata') / 'TV Shows' / guid_hash[0] / f'{guid_hash[1:]}.bundle')","def metadata_for_mode(self, player_mode, additional_data=None):\r\n metadata = {}\r\n\r\n if player_mode == 'html5':\r\n metadata.update({\r\n 'youtube_id_1_0': '',\r\n 'youtube_id_0_75': '',\r\n 'youtube_id_1_25': '',\r\n 'youtube_id_1_5': '',\r\n 'html5_sources': HTML5_SOURCES\r\n })\r\n\r\n if player_mode == 'youtube_html5':\r\n metadata.update({\r\n 'html5_sources': HTML5_SOURCES,\r\n })\r\n\r\n if player_mode == 'youtube_html5_unsupported_video':\r\n metadata.update({\r\n 'html5_sources': HTML5_SOURCES_INCORRECT\r\n })\r\n\r\n if player_mode == 'html5_unsupported_video':\r\n metadata.update({\r\n 'youtube_id_1_0': '',\r\n 'youtube_id_0_75': '',\r\n 'youtube_id_1_25': '',\r\n 'youtube_id_1_5': '',\r\n 'html5_sources': HTML5_SOURCES_INCORRECT\r\n })\r\n\r\n if additional_data:\r\n metadata.update(additional_data)\r\n\r\n return metadata","def output_metadata(self, metadata = None):\n return True","def _construct_standardized_metadata(self):\n return None","def metadata_obj(filelike):\n\tif test_hachoir_extension(filelike.name):\n\t\tmetadata = metadata_for_filelike(filelike)\n\t\tif metadata:\n\t\t\tdata = dict([\n\t\t\t\t(data.key, data.values[0].value)\n\t\t\t\tfor data in metadata\n\t\t\t\tif data.values\n\t\t\t\t])\n\t\telse:\n\t\t\tdata=None\n\telif test_3D_extension(filelike.name):# 3D not in the extention \n\t\tdata = {'mime_type':'model'}\n\telse:\n\t\tdata = None\n\t\t\n\treturn data","def generateAudio(audiotype: str, audiometadata: dict):\n try:\n audiotype = audiotype.lower()\n\n if audiotype == \"song\":\n file = Song(audiometadata)\n elif audiotype == \"podcast\":\n file = Podcast(audiometadata)\n elif audiotype == \"audiobook\":\n file = Audiobook(audiometadata)\n else:\n return None\n\n return file\n\n except MetadataValueError as error:\n raise MetadataValueError(error)\n\n except MetadataGenerationError as error:\n raise MetadataGenerationError(error)","def get_metadata_v2(session):\n LOG.debug(\"Exporting metadata for SFS augur build\")\n\n metadata = datastore.fetch_rows_from_table(session, (\"shipping\", \"metadata_for_augur_build_v2\"))\n\n return Response((row[0] + '\\n' for row in metadata), mimetype=\"application/x-ndjson\")","def create_stream_definition():\n stream_def = StreamDefinition()\n stream_def.name = HealthStatisticsPublisherManager.STREAM_NAME\n stream_def.version = HealthStatisticsPublisherManager.STREAM_VERSION\n stream_def.nickname = HealthStatisticsPublisherManager.STREAM_NICKNAME\n stream_def.description = HealthStatisticsPublisherManager.STREAM_DESCRIPTION\n\n # stream_def.add_payloaddata_attribute()\n stream_def.add_payloaddata_attribute(\"timestamp\", StreamDefinition.LONG)\n stream_def.add_payloaddata_attribute(\"cluster_id\", StreamDefinition.STRING)\n stream_def.add_payloaddata_attribute(\"cluster_instance_id\", StreamDefinition.STRING)\n stream_def.add_payloaddata_attribute(\"network_partition_id\", StreamDefinition.STRING)\n stream_def.add_payloaddata_attribute(\"member_id\", StreamDefinition.STRING)\n stream_def.add_payloaddata_attribute(\"partition_id\", StreamDefinition.STRING)\n stream_def.add_payloaddata_attribute(\"health_description\", StreamDefinition.STRING)\n stream_def.add_payloaddata_attribute(\"value\", StreamDefinition.DOUBLE)\n\n return stream_def","def metadata(self): # -> list[Unknown]:\n ...","def metadata(self): # -> list[Unknown]:\n ...","def __metadata__(self):\n raise NotImplementedError","def generate_petastorm_metadata(spark, dataset_url, unischema_class=None, use_summary_metadata=False,\n hdfs_driver='libhdfs3'):\n sc = spark.sparkContext\n\n resolver = FilesystemResolver(dataset_url, sc._jsc.hadoopConfiguration(), hdfs_driver=hdfs_driver,\n user=spark.sparkContext.sparkUser())\n fs = resolver.filesystem()\n dataset = pq.ParquetDataset(\n resolver.get_dataset_path(),\n filesystem=fs,\n validate_schema=False)\n\n if unischema_class:\n schema = locate(unischema_class)\n if not isinstance(schema, Unischema):\n raise ValueError('The specified class %s is not an instance of a petastorm.Unischema object.',\n unischema_class)\n else:\n\n try:\n schema = get_schema(dataset)\n except ValueError:\n raise ValueError('Unischema class could not be located in existing dataset,'\n ' please specify it')\n\n # In order to be backwards compatible, we retrieve the common metadata from the dataset before\n # overwriting the metadata to keep row group indexes and the old row group per file index\n arrow_metadata = dataset.common_metadata or None\n\n with materialize_dataset(spark, dataset_url, schema, use_summary_metadata=use_summary_metadata,\n filesystem_factory=resolver.filesystem_factory()):\n if use_summary_metadata:\n # Inside the materialize dataset context we just need to write the metadata file as the schema will\n # be written by the context manager.\n # We use the java ParquetOutputCommitter to write the metadata file for the existing dataset\n # which will read all the footers of the dataset in parallel and merge them.\n hadoop_config = sc._jsc.hadoopConfiguration()\n Path = sc._gateway.jvm.org.apache.hadoop.fs.Path\n parquet_output_committer = sc._gateway.jvm.org.apache.parquet.hadoop.ParquetOutputCommitter\n parquet_output_committer.writeMetaDataFile(hadoop_config, Path(dataset_url))\n\n spark.stop()\n\n if use_summary_metadata and arrow_metadata:\n # When calling writeMetaDataFile it will overwrite the _common_metadata file which could have schema information\n # or row group indexers. Therefore we want to retain this information and will add it to the new\n # _common_metadata file. If we were using the old legacy metadata method this file wont be deleted\n base_schema = arrow_metadata.schema.to_arrow_schema()\n metadata_dict = base_schema.metadata\n if ROW_GROUPS_PER_FILE_KEY in metadata_dict:\n add_to_dataset_metadata(dataset, ROW_GROUPS_PER_FILE_KEY, metadata_dict[ROW_GROUPS_PER_FILE_KEY])\n if ROWGROUPS_INDEX_KEY in metadata_dict:\n add_to_dataset_metadata(dataset, ROWGROUPS_INDEX_KEY, metadata_dict[ROWGROUPS_INDEX_KEY])","def set_stewi_meta(file_name, stewiformat=''):\n stewi_meta = FileMeta()\n stewi_meta.name_data = file_name\n stewi_meta.category = stewiformat\n stewi_meta.tool = \"StEWI\"\n stewi_meta.tool_version = STEWI_VERSION\n stewi_meta.ext = WRITE_FORMAT\n stewi_meta.git_hash = GIT_HASH\n stewi_meta.date_created = datetime.now().strftime('%d-%b-%Y')\n return stewi_meta","def transfer2meta():\n for i in ekindicts:\n e=ekindicts[i]\n t.showMeta(e)\n #t.transfer2meta(e)\n #t.returnData()\n\n return","def write_metadata(self, data_set, io=None, location=None):\n if not hasattr(data_set, '_h5_base_group'):\n # added here because loop writes metadata before data itself\n data_set._h5_base_group = self._create_data_object(data_set)\n if 'metadata' in data_set._h5_base_group.keys():\n del data_set._h5_base_group['metadata']\n metadata_group = data_set._h5_base_group.create_group('metadata')\n self.write_dict_to_hdf5(data_set.metadata, metadata_group)","def extract_metadata(self):\n metadata_file_path = self.create_metadata_file(\".metadata.txt\")\n mt = self.mimetype\n metadata_processing_method = self.metadata_mimetype_methods.get(mt)\n if metadata_processing_method:\n # TODO: should we return metadata and write it here instead of in processing method?\n metadata_processing_method(metadata_file_path)","def GetMetadata(self):\n return self.dict['meta']","def make_report_metadata(metadata, out_dir):\n metadata_qa = {}\n # Edit the product type and description\n metadata_qa[\"ProductType\"] = {\"ProductTypeName\": \"MeerKATReductionProduct\",\n \"ReductionName\": \"Continuum Image Quality Report\"}\n\n desc_prefix = metadata[\"Description\"].split(':')[0]\n metadata_qa[\"Description\"] = desc_prefix + \": Continuum image quality report\"\n\n # Copy remaining keys from original metadata\n report_keys = [\"StartTime\", \"CaptureBlockId\",\n \"ProposalId\", \"Observer\", \"ScheduleBlockIdCode\",\n \"Run\"]\n for key in report_keys:\n metadata_qa[key] = metadata[key]\n\n write_metadata(metadata_qa, out_dir)","def get_metadata(self, idx=0):\n meta_data = {}\n with h5py.File(self.path) as h5:\n ds = h5[str(idx)]\n attrs = dict(ds.attrs)\n for key in qpimage.meta.META_KEYS:\n if key in attrs:\n meta_data[key] = attrs[key]\n\n smeta = super(SingleRawOAHQpformatHDF5, self).get_metadata(idx)\n meta_data.update(smeta)\n return meta_data","def generate_metadata(self):\n if self.options.mbtiles:\n return\n if not os.path.exists(self.output):\n os.makedirs(self.output)\n\n if self.options.profile == 'mercator':\n\n south, west = self.mercator.MetersToLatLon( self.ominx, self.ominy)\n north, east = self.mercator.MetersToLatLon( self.omaxx, self.omaxy)\n south, west = max(-85.05112878, south), max(-180.0, west)\n north, east = min(85.05112878, north), min(180.0, east)\n self.swne = (south, west, north, east)\n\n # Generate googlemaps.html\n if self.options.webviewer in ('all','google') and self.options.profile == 'mercator':\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'googlemaps.html')):\n f = open(os.path.join(self.output, 'googlemaps.html'), 'w')\n f.write( self.generate_googlemaps() )\n f.close()\n\n # Generate openlayers.html\n if self.options.webviewer in ('all','openlayers'):\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'openlayers.html')):\n f = open(os.path.join(self.output, 'openlayers.html'), 'w')\n f.write( self.generate_openlayers() )\n f.close()\n\n elif self.options.profile == 'geodetic':\n\n west, south = self.ominx, self.ominy\n east, north = self.omaxx, self.omaxy\n south, west = max(-90.0, south), max(-180.0, west)\n north, east = min(90.0, north), min(180.0, east)\n self.swne = (south, west, north, east)\n\n # Generate openlayers.html\n if self.options.webviewer in ('all','openlayers'):\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'openlayers.html')):\n f = open(os.path.join(self.output, 'openlayers.html'), 'w')\n f.write( self.generate_openlayers() )\n f.close()\n\n elif self.options.profile in ['raster','gearth','garmin']:\n\n west, south = self.ominx, self.ominy\n east, north = self.omaxx, self.omaxy\n\n self.swne = (south, west, north, east)\n\n # Generate openlayers.html\n if self.options.webviewer in ('all','openlayers'):\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'openlayers.html')):\n f = open(os.path.join(self.output, 'openlayers.html'), 'w')\n f.write( self.generate_openlayers() )\n f.close()\n\n\n # Generate tilemapresource.xml.\n if (self.options.tile_format != 'hybrid' and self.options.profile != 'garmin'\n and (not self.options.resume or not os.path.exists(os.path.join(self.output, 'tilemapresource.xml')))):\n f = open(os.path.join(self.output, 'tilemapresource.xml'), 'w')\n f.write( self.generate_tilemapresource())\n f.close()","def metadata(self):\n return {\n \"namespace\": self.namespace,\n \"short_name\": f\"{self.namespace}_{self._dataset_metadata['DatasetCode']}\",\n \"name\": f\"{self._dataset_metadata['DatasetName']} - FAO ({self.publication_year})\",\n \"description\": self._dataset_metadata[\"DatasetDescription\"],\n \"source_name\": \"Food and Agriculture Organization of the United Nations\",\n \"publication_year\": int(self.publication_year),\n \"publication_date\": self._dataset_metadata[\"DateUpdate\"],\n \"date_accessed\": str(dt.date.today()),\n \"url\": self.url,\n \"source_data_url\": self.source_data_url,\n \"file_extension\": \"zip\",\n }","def _getMetadataName(self):\n return \"%s_processCoadd_metadata\" % (self.config.coaddName,)","def writeToMetadata(self, context):\n if self.modelType not in GenericMetadata.MODEL_TYPES:\n raise Exception(\"Model type %s is not among known model types: %s\" % (self.modelType, str(GenericMetadata.MODEL_TYPES) ) )\n \n modelRunEntries = GenericMetadata.readModelRunEntries(context)\n try:\n runs = modelRunEntries['runs'].split(GenericMetadata.VALUE_DELIM)\n except KeyError:\n runs = []\n \n # Collected model entry and keys and values into lists so we can write to metadata store in batch\n keys = []\n values = []\n \n # Generate unique identifier for this model run. Unique ID is a combination of model type and a number\n entryNumber = 1\n fqId = self.modelType + GenericMetadata.KEY_SEP + str(entryNumber)\n while fqId in runs:\n entryNumber += 1\n fqId = self.modelType + GenericMetadata.KEY_SEP + str(entryNumber)\n self.runNumber = entryNumber\n # Add new run to list of runs\n runs.append(fqId)\n runsStr = GenericMetadata.VALUE_DELIM.join(runs)\n keys.append('runs'); values.append(runsStr)\n # Write attributes for run\n keyProto = fqId + GenericMetadata.KEY_SEP\n runDate = keyProto + 'date_utc'\n keys.append(runDate); values.append( self.date.strftime(ModelRun.FMT_DATE) )\n runDesc = keyProto + 'description'\n keys.append(runDesc); values.append(self.description)\n runCmd = keyProto + 'command'\n keys.append(runCmd); values.append(self.command)\n runOutput = keyProto + 'output'\n keys.append(runOutput); values.append(self.output)\n # Write to metadata\n GenericMetadata.writeModelRunEntries(context, keys, values)","def addOutputMetaData(nnSpec):\n for i, featureMapDimension in enumerate(featureMapDimensions):\n nnSpec.description.output[i].type.multiArrayType.shape.append(1)\n nnSpec.description.output[i].type.multiArrayType.shape.append(3)\n nnSpec.description.output[i].type.multiArrayType.shape.append(\n featureMapDimension\n )\n nnSpec.description.output[i].type.multiArrayType.shape.append(\n featureMapDimension\n )\n # pc, bx, by, bh, bw, c (no of class class labels)\n nnSpec.description.output[i].type.multiArrayType.shape.append(outputSize)\n nnSpec.description.output[\n i\n ].type.multiArrayType.dataType = (\n ct.proto.FeatureTypes_pb2.ArrayFeatureType.DOUBLE\n )","def _metadata_builder(metadata: Dict, scheme) -> Dict:\n\n metadata_field_for_scheme = metadata_field_by_scheme.get(scheme)\n\n _config = kaptan.Kaptan()\n _config.import_config(metadata)\n\n return {\n **{\n metadata_field: _config.get(\n metadata_field_for_scheme[metadata_field]\n ) for metadata_field in metadata_field_for_scheme.keys()\n },\n \"ui\": UIJSONSerializer().serialize_object_to_dict(metadata).get(\"ui\")\n }","def __appendMetaData(self, filename):\n metadata = {'Model': 'LFM',\n 'Source': filename,\n 'Date processed': datetime.datetime.now(),\n 'Start date': self.startDate\n }\n \n self.data.append(key='meta',\n name='Metadata for LFM Solar Wind file',\n units='n/a',\n data=metadata)","def metadataDirectory(self):\n guid_hash = utils.sha1hash(self.parentGuid)\n return str(Path('Metadata') / 'TV Shows' / guid_hash[0] / f'{guid_hash[1:]}.bundle')","def test_metadata(self):\n self.default_kwargs['metadata_callback'] = self._metadata_callback\n self.encoder = StreamEncoder(**self.default_kwargs)\n test_samples = np.random.rand(DEFAULT_BLOCKSIZE, 1).astype('int16')\n self.encoder.process(test_samples)\n self.encoder.finish()\n self.assertTrue(self.write_callback_called)\n self.assertTrue(self.metadata_callback_called)","def publish_proto_metadata_update(self):\n metadata = load_mpe_service_metadata(self.args.metadata_file)\n ipfs_hash_base58 = ipfs_utils.publish_proto_in_ipfs(\n self._get_ipfs_client(), self.args.protodir)\n metadata.set_simple_field(\"model_ipfs_hash\", ipfs_hash_base58)\n metadata.save_pretty(self.args.metadata_file)","def init_meta(self):\n meta = {}\n # Required (core)\n meta['ra'] = dict(ext=1, card='RA')\n meta['dec'] = dict(ext=1, card='DEC')\n meta['target'] = dict(ext=1, card='OBJECT')\n meta['decker'] = dict(ext=1, card='APERTURE')\n meta['dichroic'] = dict(ext=1, card='FILTER')\n meta['binning'] = dict(ext=1, card=None, default='1,1')\n\n meta['mjd'] = dict(ext=0, card=None, compound=True)\n meta['exptime'] = dict(ext=1, card='EXPTIME')\n meta['airmass'] = dict(ext=1, card='AIRMASS')\n # Extras for config and frametyping\n meta['dispname'] = dict(ext=1, card='DISPERSE')\n meta['idname'] = dict(ext=1, card='IMAGETYP')\n\n # Ingest\n self.meta = meta","def print_metadata(value):\n print '\\nHydroShare metadata:'\n print print_recursive(value)","def _get_metadata(self) -> Metadata:\n manifest = self._get_manifest()\n\n return Metadata(**manifest[\"metadata\"])","def store_pkg_metadata(self, pkg, version):\n pass","def metadata_name(filename):\n\tif test_hachoir_extension(filename):\n\t\tmetadata = metadata_for_file(filename)\n\t\tif metadata:\n\t\t\tdata = dict([\n\t\t\t\t(data.key, data.values[0].value)\n\t\t\t\tfor data in metadata\n\t\t\t\tif data.values\n\t\t\t\t])\n\t\telse:\n\t\t\tdata=None\n\telif test_3D_extension(filename):# 3D not in the extention \n\t\tdata = {'mime_type':'model'}\n\telse:\n\t\tdata=None\n\treturn data","def _getMetadataName(self):\n pass","def create_meta(prefix, dist, info_dir, extra_info):\n # read info/index.json first\n with open(join(info_dir, 'index.json')) as fi:\n meta = json.load(fi)\n # add extra info\n meta.update(extra_info)\n # write into <prefix>/conda-meta/<dist>.json\n meta_dir = join(prefix, 'conda-meta')\n if not isdir(meta_dir):\n os.makedirs(meta_dir)\n with open(join(meta_dir, 'history'), 'w') as fo:\n fo.write('')\n with open(join(meta_dir, dist + '.json'), 'w') as fo:\n json.dump(meta, fo, indent=2, sort_keys=True)","def get_metadata_v3(session):\n LOG.debug(\"Exporting metadata for SFS augur build\")\n\n metadata = datastore.fetch_rows_from_table(session, (\"shipping\", \"metadata_for_augur_build_v3\"))\n\n return Response((row[0] + '\\n' for row in metadata), mimetype=\"application/x-ndjson\")","def run(self, info):\n\n # Write the metadata to the file's xattrs\n self._downloader.to_screen('[metadata] Writing metadata to file\\'s xattrs')\n\n filename = info['filepath']\n\n try:\n xattr_mapping = {\n 'user.xdg.referrer.url': 'webpage_url',\n # 'user.xdg.comment': 'description',\n 'user.dublincore.title': 'title',\n 'user.dublincore.date': 'upload_date',\n 'user.dublincore.description': 'description',\n 'user.dublincore.contributor': 'uploader',\n 'user.dublincore.format': 'format',\n }\n\n num_written = 0\n for xattrname, infoname in xattr_mapping.items():\n\n value = info.get(infoname)\n\n if value:\n if infoname == 'upload_date':\n value = hyphenate_date(value)\n\n byte_value = value.encode('utf-8')\n write_xattr(filename, xattrname, byte_value)\n num_written += 1\n\n return [], info\n\n except XAttrUnavailableError as e:\n self._downloader.report_error(str(e))\n return [], info\n\n except XAttrMetadataError as e:\n if e.reason == 'NO_SPACE':\n self._downloader.report_warning(\n 'There\\'s no disk space left, disk quota exceeded or filesystem xattr limit exceeded. '\n + (('Some ' if num_written else '') + 'extended attributes are not written.').capitalize())\n elif e.reason == 'VALUE_TOO_LONG':\n self._downloader.report_warning(\n 'Unable to write extended attributes due to too long values.')\n else:\n msg = 'This filesystem doesn\\'t support extended attributes. '\n if compat_os_name == 'nt':\n msg += 'You need to use NTFS.'\n else:\n msg += '(You may have to enable them in your /etc/fstab)'\n self._downloader.report_error(msg)\n return [], info","def metadataDirectory(self):\n guid_hash = utils.sha1hash(self.grandparentGuid)\n return str(Path('Metadata') / 'TV Shows' / guid_hash[0] / f'{guid_hash[1:]}.bundle')","def meta_datas(self) -> pulumi.Output[Sequence['outputs.SharedflowMetaData']]:\n return pulumi.get(self, \"meta_datas\")","def add_metadata(self, metadata: dict) -> None:","def test_create_namespaced_image_stream_mapping(self):\n pass","def metadata_factory(url, data=None):\n response = {\n 'etag': '',\n 'checked-url': url,\n 'content-length': faker.pyint(),\n 'content-disposition': '',\n 'content-md5': faker.md5(),\n 'content-location': '',\n 'expires': faker.iso8601(),\n 'final-status-code': 200,\n 'updated': faker.iso8601(),\n 'last-modified': faker.iso8601(),\n 'content-encoding': 'gzip',\n 'content-type': faker.mime_type()\n }\n if data:\n response.update(data)\n return json.dumps(response)","def export_obs_meta(obs):\n log = toast.utils.Logger.get()\n\n # Construct observation frame and dictionary\n ob = c3g.G3Frame(c3g.G3FrameType.Observation)\n obmeta = dict()\n\n session = obs.session\n log.verbose(f\"Create observation frame for session {session.name}\")\n\n ob[\"telescope_name\"] = c3g.G3String(\n obs.telescope.focalplane.detector_data.meta[\"telescope\"]\n )\n obmeta[\"telescope_name\"] = str(\n obs.telescope.focalplane.detector_data.meta[\"telescope\"]\n )\n ob[\"telescope_uid\"] = c3g.G3Int(obs.telescope.uid)\n obmeta[\"telescope_uid\"] = int(obs.telescope.uid)\n\n ob[\"observing_session\"] = c3g.G3String(session.name)\n obmeta[\"observing_session\"] = str(session.name)\n\n ob[\"observing_session_uid\"] = c3g.G3Int(session.uid)\n obmeta[\"observing_session_uid\"] = int(session.uid)\n\n ob[\"observing_session_start\"] = t3g.to_g3_time(session.start.timestamp())\n obmeta[\"observing_session_start\"] = float(session.start.timestamp())\n\n ob[\"observing_session_end\"] = t3g.to_g3_time(session.end.timestamp())\n obmeta[\"observing_session_end\"] = float(session.end.timestamp())\n\n site = obs.telescope.site\n siteclass = toast.utils.object_fullname(site.__class__)\n ob[\"site_name\"] = c3g.G3String(site.name)\n ob[\"site_class\"] = c3g.G3String(siteclass)\n ob[\"site_uid\"] = c3g.G3Int(site.uid)\n obmeta[\"site_name\"] = str(site.name)\n obmeta[\"site_class\"] = str(siteclass)\n obmeta[\"site_uid\"] = int(site.uid)\n\n if isinstance(site, toast.instrument.GroundSite):\n ob[\"site_lat_deg\"] = c3g.G3Double(site.earthloc.lat.to_value(u.degree))\n ob[\"site_lon_deg\"] = c3g.G3Double(site.earthloc.lon.to_value(u.degree))\n ob[\"site_alt_m\"] = c3g.G3Double(site.earthloc.height.to_value(u.meter))\n obmeta[\"site_lat_deg\"] = float(site.earthloc.lat.to_value(u.degree))\n obmeta[\"site_lon_deg\"] = float(site.earthloc.lon.to_value(u.degree))\n obmeta[\"site_alt_m\"] = float(site.earthloc.height.to_value(u.meter))\n\n if site.weather is not None:\n if hasattr(site.weather, \"name\"):\n # This is a simulated weather object, dump it.\n ob[\"site_weather_name\"] = c3g.G3String(site.weather.name)\n obmeta[\"site_weather_name\"] = str(site.weather.name)\n ob[\"site_weather_realization\"] = c3g.G3Int(site.weather.realization)\n obmeta[\"site_weather_realization\"] = int(site.weather.realization)\n if site.weather.max_pwv is None:\n ob[\"site_weather_max_pwv\"] = c3g.G3String(\"NONE\")\n obmeta[\"site_weather_max_pwv\"] = \"NONE\"\n else:\n ob[\"site_weather_max_pwv\"] = c3g.G3Double(site.weather.max_pwv)\n obmeta[\"site_weather_max_pwv\"] = float(site.weather.max_pwv)\n ob[\"site_weather_time\"] = t3g.to_g3_time(site.weather.time.timestamp())\n obmeta[\"site_weather_time\"] = float(site.weather.time.timestamp())\n ob[\"site_weather_uid\"] = c3g.G3Int(site.weather.site_uid)\n obmeta[\"site_weather_uid\"] = int(site.weather.site_uid)\n ob[\"site_weather_use_median\"] = c3g.G3Bool(site.weather.median_weather)\n obmeta[\"site_weather_use_median\"] = bool(site.weather.median_weather)\n return ob, obmeta","def metadata2eic(url):\n logging.info('fetching image metadata from %s' % url)\n ds = json.loads(urllib.urlopen(url).read())\n fields = ['imagename','alt','pitch','roll']\n for d in ds:\n yield map(str,[d[k] for k in fields])","def get_metadata():\n\n module = __name__.split('.', 1)\n\n try:\n pkg = pkg_resources.get_distribution(module[0])\n except pkg_resources.RequirementParseError:\n # if called from CLI, try to get pkg from the path\n distros = list(pkg_resources.find_distributions(cfg.BASE_DIR, \n only=True))\n if len(distros) == 1:\n pkg = distros[0]\n except Exception as e:\n raise HTTPBadRequest(reason=e)\n\n # deserialize key-word arguments\n train_args = _fields_to_dict(get_train_args())\n # make 'type' JSON serializable\n for key, val in train_args.items():\n train_args[key]['type'] = str(val['type'])\n\n predict_args = _fields_to_dict(get_predict_args())\n # make 'type' JSON serializable\n for key, val in predict_args.items():\n predict_args[key]['type'] = str(val['type'])\n\n meta = {\n 'name' : None,\n 'version' : None,\n 'summary' : None,\n 'home-page' : None,\n 'author' : None,\n 'author-email' : None,\n 'license' : None,\n 'help-train' : train_args,\n 'help-predict' : predict_args\n }\n for line in pkg.get_metadata_lines(\"PKG-INFO\"):\n line_low = line.lower() # to avoid inconsistency due to letter cases\n for par in meta:\n if line_low.startswith(par.lower() + \":\"):\n _, value = line.split(\": \", 1)\n meta[par] = value\n\n return meta","def write_metadata(file_name, metadata_dict, category='',\n datatype=\"inventory\", parameters=None):\n if (datatype == \"inventory\") or (datatype == \"source\"):\n meta = set_stewi_meta(file_name, stewiformat=category)\n if datatype == 'inventory':\n meta.tool_meta = {\"parameters\": parameters,\n \"sources\": metadata_dict}\n else:\n meta.tool_meta = metadata_dict\n write_metadata_to_file(paths, meta)\n elif datatype == \"validation\":\n file = (paths.local_path / 'validation' /\n f'{file_name}_validationset_metadata.json')\n with file.open('w') as fi:\n fi.write(json.dumps(metadata_dict, indent=4))","def metadata(self, run_id, data_type):\n if not data_type in self.provides:\n raise RuntimeError(f\"{data_type} not in {self.provides}?\")\n return dict(\n run_id=run_id,\n data_type=data_type,\n data_kind=self.data_kind_for(data_type),\n dtype=self.dtype_for(data_type),\n lineage_hash=strax.DataKey(\n run_id, data_type, self.lineage).lineage_hash,\n compressor=self.compressor,\n lineage=self.lineage)","def parse_metadata(self):\n micro_metadata = {}\n ext_meta = None\n self.content_type = 'text/html'\n if self.source_metadata:\n #print(self.source_metadata)\n if len(self.source_metadata)>1:\n try:\n for sm in self.source_metadata:\n if str(sm.get('type').split('/')[-1]).lower() in self.SCHEMA_ORG_CREATIVEWORKS:\n ext_meta = sm\n except:\n pass\n self.source_name = self.getEnumSourceNames().MICRODATA_EMBEDDED\n if not ext_meta:\n ext_meta = self.source_metadata[0]\n\n if ext_meta is not None:\n self.logger.info('FsF-F2-01M : Trying to extract Microdata metadata from -: {}'.format(self.source_name))\n # TODO check syntax - not ending with /, type and @type\n # TODO (important) extend mapping to detect other pids (link to related entities)?\n # TODO replace check_context_type list context comparison by regex\n check_context_type = ['Dataset', 'Collection']\n try:\n #if ext_meta['@context'] in check_context_type['@context'] and ext_meta['@type'] in check_context_type[\"@type\"]:\n if str(ext_meta.get('type')).find('schema.org') > -1:\n micro_metadata = jmespath.search(self.metadata_mapping.value, ext_meta)\n self.namespaces.append('http://schema.org/')\n else:\n self.logger.info('FsF-F2-01M : Failed to parse non schema.org type Microdata')\n except Exception as err:\n #print(err.with_traceback())\n self.logger.info('FsF-F2-01M : Failed to parse Microdata -: {}'.format(err))\n else:\n self.logger.info('FsF-F2-01M : Could not identify Microdata metadata')\n\n return self.source_name, micro_metadata","def metadata():\n req = prepare_flask_request(request)\n auth = init_saml_auth(req)\n settings = auth.get_settings()\n sp_metadata = settings.get_sp_metadata()\n errors = settings.validate_metadata(sp_metadata)\n\n if len(errors) == 0:\n resp = make_response(sp_metadata, 200)\n resp.headers[\"Content-Type\"] = \"text/xml\"\n else:\n resp = make_response(\", \".join(errors), 500)\n return resp","def compile_metadata(inventory_dict):\n inventory_meta = {}\n #inventory_meta['InventoryDictionary'] = inventory_dict\n for source, year in inventory_dict.items():\n inventory_meta[source] = stewi.getMetadata(source, year)\n return inventory_meta","def metadata():\n req = prepare_onelogin_request(request)\n saml_auth = init_saml_auth(req)\n settings = saml_auth.get_settings()\n metadata = settings.get_sp_metadata()\n errors = settings.validate_metadata(metadata)\n\n if len(errors) == 0:\n resp = make_response(metadata, 200)\n resp.headers[\"Content-Type\"] = \"text/xml\"\n else:\n resp = make_response(\", \".join(errors), 500)\n return resp","def _WriteStorageMetadata(self):\n stream_name = 'metadata.txt'\n if self._HasStream(stream_name):\n return\n\n stream_data = (\n '[plaso_storage_file]\\n'\n 'format_version: {0:d}\\n'\n 'serialization_format: {1:s}\\n'\n 'storage_type: {2:s}\\n'\n '\\n').format(\n self._FORMAT_VERSION, self.serialization_format, self.storage_type)\n\n stream_data = stream_data.encode('utf-8')\n self._WriteStream(stream_name, stream_data)","def get_metadata(self):\n meta_data = {}\n if self.beam_energy is not None:\n meta_data['beam_energy'] = self.beam_energy\n if self.collection_angle is not None:\n meta_data['collection_angle'] = self.collection_angle\n return meta_data","def add_file_metadata(self):\n metadata = self.__file.require_group(METADATA)\n self.__write_value(metadata, DATE_CREATED, date.today().strftime(\"%Y-%m-%d\"))\n self.__write_value(metadata, SDK_VERSION, __version__)","def update_metadata(self):\n parser = GenericParser(\n fn_re='{}/(e\\d+s\\d+)_.*/Production.nc'.format(self.data_folder),\n group_names=['sim'],\n group_transforms=[lambda x: x],\n top_fn='',\n step_ps=self.timestep\n )\n meta = gather_metadata('{}/e*/*nc'.format(self.data_folder), parser)\n meta['top_fn'] = sorted(glob('{}/e*/structure.prmtop'.format(self.input_folder)))\n self.meta = meta","def metadata(self):\r\n return resources.Metadata(self)","def metadata_create():\n binding = {}\n url = 'https://upload.twitter.com/1.1/media/metadata/create.json'\n return _TwitterRequest('POST',\n url,\n 'rest:media',\n 'post-media-metadata-create',\n binding)","def GetMetadataSample():\n client = CreateClient()\n # Fetch the metadata entry and display bits of it\n metadata = client.GetMetadata()\n print 'Quota'\n print ' Total:', metadata.quota_bytes_total.text\n print ' Used:', metadata.quota_bytes_used.text\n print ' Trashed:', metadata.quota_bytes_used_in_trash.text\n print 'Import / Export'\n for input_format in metadata.import_formats:\n print ' Import:', input_format.source, 'to', input_format.target\n for export_format in metadata.export_formats:\n print ' Export:', export_format.source, 'to', export_format.target\n print 'Features'\n for feature in metadata.features:\n print ' Feature:', feature.name.text\n print 'Upload Sizes'\n for upload_size in metadata.max_upload_sizes:\n print ' Kind:', upload_size.kind, upload_size.text"],"string":"[\n \"def _generate_metadata_kind(filename, items, affidavit=None):\\n store = appstream.Store('lvfs')\\n for item in items:\\n\\n # add each component\\n for md in item.mds:\\n component = appstream.Component()\\n component.id = md.cid\\n component.kind = 'firmware'\\n component.name = md.name\\n component.summary = md.summary\\n component.description = md.description\\n if md.url_homepage:\\n component.urls['homepage'] = md.url_homepage\\n component.metadata_license = md.metadata_license\\n component.project_license = md.project_license\\n component.developer_name = md.developer_name\\n\\n # add provide\\n for guid in md.guids:\\n prov = appstream.Provide()\\n prov.kind = 'firmware-flashed'\\n prov.value = guid\\n component.add_provide(prov)\\n\\n # add release\\n if md.version:\\n rel = appstream.Release()\\n rel.version = md.version\\n rel.description = md.release_description\\n if md.release_timestamp:\\n rel.timestamp = md.release_timestamp\\n rel.checksums = []\\n rel.location = app.config['FIRMWARE_BASEURL'] + item.filename\\n rel.size_installed = md.release_installed_size\\n rel.size_download = md.release_download_size\\n rel.urgency = md.release_urgency\\n component.add_release(rel)\\n\\n # add container checksum\\n if md.checksum_container:\\n csum = appstream.Checksum()\\n csum.target = 'container'\\n csum.value = md.checksum_container\\n csum.filename = item.filename\\n rel.add_checksum(csum)\\n\\n # add content checksum\\n if md.checksum_contents:\\n csum = appstream.Checksum()\\n csum.target = 'content'\\n csum.value = md.checksum_contents\\n csum.filename = md.filename_contents\\n rel.add_checksum(csum)\\n\\n # add screenshot\\n if md.screenshot_caption:\\n ss = appstream.Screenshot()\\n ss.caption = md.screenshot_caption\\n if md.screenshot_url:\\n im = appstream.Image()\\n im.url = md.screenshot_url\\n ss.add_image(im)\\n component.add_screenshot(ss)\\n\\n # add requires for each allowed vendor_ids\\n group = db.groups.get_item(item.group_id)\\n if group.vendor_ids:\\n req = appstream.Require()\\n req.kind = 'firmware'\\n req.value = 'vendor-id'\\n if len(group.vendor_ids) == 1:\\n req.compare = 'eq'\\n else:\\n req.compare = 'regex'\\n req.version = '|'.join(group.vendor_ids)\\n component.add_require(req)\\n\\n # add manual firmware or fwupd version requires\\n for req_txt in md.requirements:\\n split = req_txt.split('/', 4)\\n req = appstream.Require()\\n req.kind = split[0]\\n req.value = split[1]\\n req.compare = split[2]\\n req.version = split[3]\\n component.add_require(req)\\n\\n # add component\\n store.add(component)\\n\\n # dump to file\\n download_dir = app.config['DOWNLOAD_DIR']\\n if not os.path.exists(download_dir):\\n os.mkdir(download_dir)\\n filename = os.path.join(download_dir, filename)\\n store.to_file(filename)\\n\\n # upload to the CDN\\n blob = open(filename, 'rb').read()\\n _upload_to_cdn(filename, blob)\\n\\n # generate and upload the detached signature\\n if affidavit:\\n blob_asc = affidavit.create(blob)\\n _upload_to_cdn(filename + '.asc', blob_asc)\",\n \"def gen_file_metadata_summary(self, metadata):\\n title = sub('[\\\\W_]+', '', metadata['title'].lower())\\n season = str(metadata['season']).zfill(2)\\n episode = str(metadata['episode']).zfill(2)\\n\\n file_metadata_summary = f'{title}.S{season}E{episode}'\\n return file_metadata_summary\",\n \"def generate_metadata(self):\\n self.metadata = {\\n 'title': os.path.basename(self.source_file).rsplit('.', 1)[0],\\n 'url': self.relative_destination_file,\\n 'full_path': os.path.dirname(self.relative_destination_file),\\n 'short_path': self.shorten_path(\\n os.path.dirname(self.relative_destination_file))\\n }\",\n \"def generate_custom_metadata(uuid, version, update_proto):\\n COMPONENTS = E.components\\n COMPONENT = E.component\\n ID = E.id\\n NAME = E.name\\n SUMMARY = E.summary\\n PROVIDES = E.provides\\n FIRMWARE = E.firmware\\n CUSTOM = E.custom\\n VALUE = E.value\\n RELEASES = E.releases\\n RELEASE = E.release\\n LOCATION = E.location\\n CHECKSUM = E.checksum\\n DESCRIPTION = E.description\\n P = E.p\\n SIZE = E.size\\n REQUIRES = E.requires\\n\\n metadata_tree = COMPONENTS(\\n COMPONENT(\\n ID(\\\"com.hacker.firmware\\\"),\\n NAME(\\\"TotallyNotMalicious\\\"),\\n SUMMARY(\\\"This is fine\\\"),\\n PROVIDES(\\n FIRMWARE(\\n uuid,\\n type=\\\"flashed\\\",\\n ),\\n ),\\n CUSTOM(\\n VALUE(\\n update_proto,\\n key=\\\"LVFS::UpdateProtocol\\\",\\n ),\\n ),\\n RELEASES(\\n RELEASE(\\n LOCATION(\\n url_for(\\\"serve_cab\\\", _external=True, uuid=uuid, version=version, update_proto=update_proto)\\n ),\\n DESCRIPTION(\\n P(\\\"Totally not malicious ;)\\\"),\\n ),\\n CHECKSUM(\\n hashlib.sha1(generate_cab(uuid=uuid, version=version, update_proto=update_proto)).hexdigest(),\\n type=\\\"sha1\\\", filename=\\\"poc.cab\\\", target=\\\"container\\\",\\n ),\\n SIZE(\\\"1337\\\", type=\\\"download\\\"),\\n SIZE(\\\"0\\\", type=\\\"installed\\\"),\\n urgency=\\\"high\\\", version=version, timestamp=\\\"1587399600\\\", install_duration=\\\"120\\\",\\n ),\\n ),\\n REQUIRES(),\\n type=\\\"firmware\\\",\\n ),\\n origin=\\\"lvfs\\\", version=\\\"0.9\\\",\\n )\\n\\n metadata = etree.tostring(metadata_tree, pretty_print=True, xml_declaration=True, encoding=\\\"UTF-8\\\")\\n\\n return gzip.compress(metadata)\",\n \"def construct_metadata(song):\\n print(song) #temp\",\n \"def create_metadata(scene: \\\"Scenemaker\\\") -> None:\\r\\n create_datadir()\\r\\n\\r\\n with open(dirpath / cng.GENERATED_DATA_DIR / cng.METADATA_FILE, \\\"w+\\\") as f:\\r\\n f.write(str(scene.num2name))\",\n \"def gen_metadata(args):\\n with open(args.bibfile) as bibfile:\\n bib_db = BibTexParser(common_strings=True).parse_file(bibfile)\\n entries = sorted(list(bib_db.entries),\\n key=lambda x: x['year'], reverse=True)\\n list([update_file(entry) for entry in entries])\\n annotations = [entry_to_annotation(entry, args.PI) for entry in entries]\\n stream = open(args.metadata, 'w')\\n yaml.dump(annotations, stream, width=192, default_flow_style=False)\\n stream.close()\",\n \"def metadata(self) -> global___SummaryMetadata:\",\n \"def _create_output_metadata(self):\\n\\n # Create output info.\\n output_meta = _metadata_fb.TensorMetadataT()\\n output_meta.name = \\\"probability\\\"\\n output_meta.description = \\\"Probabilities of labels respectively.\\\"\\n output_meta.content = _metadata_fb.ContentT()\\n output_meta.content.contentProperties = _metadata_fb.FeaturePropertiesT()\\n output_meta.content.contentPropertiesType = (\\n _metadata_fb.ContentProperties.FeatureProperties)\\n label_file = _metadata_fb.AssociatedFileT()\\n label_file.name = os.path.basename(self.model_info.label_file)\\n label_file.description = (\\\"Labels for classification categories.\\\")\\n label_file.type = _metadata_fb.AssociatedFileType.TENSOR_AXIS_LABELS\\n output_meta.associatedFiles = [label_file]\\n return [output_meta]\",\n \"def build_ns_file_metadata(file_type):\\r\\n file_description = f\\\"Your Nightscout {file_type} data, last updated at {datetime.utcnow()} UTC.\\\"\\r\\n file_tags = [\\\"open-aps\\\", \\\"Nightscout\\\", file_type, \\\"json\\\"]\\r\\n file_updated = str(datetime.now())\\r\\n return {\\\"tags\\\": file_tags, \\\"description\\\": file_description, \\\"updated_at\\\": file_updated}\",\n \"def metadata(self): # -> None:\\n ...\",\n \"def generate_metadata(\\n source_name,\\n source_version\\n):\\n now = datetime.utcnow()\\n write_recipt = str(uuid.uuid1())\\n metadata_obj = {\\n 'write_recipt': write_recipt,\\n 'data_source': source_name,\\n 'machine_source': platform.node(),\\n 'version': source_version,\\n 'package_version': _version.__version__,\\n 'cron_datetime': now.isoformat()\\n }\\n\\n return metadata_obj\",\n \"def build_meta(self, root):\\n ns_dc = {\\\"dc\\\": self.namespace_dc, }\\n metadata = ET.SubElement(root, \\\"metadata\\\", nsmap=ns_dc)\\n ET.SubElement(metadata,\\n '{%s}title' % self.namespace_dc).text = self.title\\n ET.SubElement(metadata,\\n '{%s}creator' % self.namespace_dc).text = self.author\\n ET.SubElement(metadata,\\n '{%s}identifier' % self.namespace_dc,\\n id='bookid').text = \\\"urn:uuid:%s\\\" % self.bookid\\n ET.SubElement(metadata,\\n '{%s}language' % self.namespace_dc).text = self.language\\n ET.SubElement(metadata, 'meta', name=\\\"cover\\\", content=\\\"cover-image\\\")\",\n \"def populate_metadata(case, config):\\n return {\\\"Type\\\": \\\"Summary\\\",\\n \\\"Title\\\": \\\"Verification\\\",\\n \\\"Headers\\\": [\\\"Bit for Bit\\\", \\\"Configurations\\\", \\\"Std. Out Files\\\"]}\",\n \"def define_metadata(cls, pcm):\\n raise NotImplementedError()\",\n \"def gen_meta(self, filename):\\n nf_meta = {}\\n nf_meta['filename'] = filename\\n nf_meta['deleted'] = 0\\n\\n # http://stackoverflow.com/a/5297483\\n nf_meta['key'] = hashlib.md5(str(filename).encode('utf-8')).hexdigest()\\n self.log.debug(\\\"Note File Meta Key: %s\\\", nf_meta['key'])\\n\\n path = self.config.get_config('cfg_nt_path')\\n\\n # WARNING THIS IS PLATFORM SPECIFIC\\n nf_meta['createdate'] = os.stat(path + \\\"/\\\" + filename).st_birthtime\\n self.log.debug(\\\"Note File Meta Created: %s [%s]\\\", nf_meta['createdate'], time.ctime(nf_meta['createdate']))\\n\\n nf_meta['modifydate'] = os.stat(path + \\\"/\\\" + filename).st_mtime\\n self.log.debug(\\\"Note File Meta Modified: %s [%s]\\\", nf_meta['modifydate'], time.ctime(nf_meta['modifydate']))\\n\\n return nf_meta\",\n \"def assemble(metadata_file):\\n\\n def read(file):\\n with open(file) as yaml:\\n return load(yaml.read())\\n\\n def add_name(info):\\n info['name'] = slugify(info['title'], separator='_')\\n return info\\n\\n def get_files(filetype):\\n filename = metadata_file.replace('metadata', filetype)\\n folder = dirname(metadata_file)\\n schema_files_pattern = join(folder, filename)\\n return glob(schema_files_pattern)\\n\\n descriptor = add_name(read(metadata_file))\\n resources = [add_name(read(file)) for file in get_files('resource')]\\n model = get_files('model')\\n\\n descriptor['resources'] = resources\\n if model and len(model) == 1:\\n descriptor['model'] = model.pop()\\n\\n return DataPackage(descriptor)\",\n \"def getMetadata(self):\\n metadata = {}\\n document_properties = self.document_loaded.getDocumentProperties()\\n user_defined_properties = document_properties.getUserDefinedProperties()\\n for container in [document_properties, user_defined_properties]:\\n for property_name in dir(container):\\n if property_name in ('SupportedServiceNames',):\\n continue\\n property_value = getattr(container, property_name, '')\\n if property_value:\\n if isinstance(property_value, basestring):\\n metadata[property_name] = property_value\\n elif isinstance(property_value, tuple) and isinstance(property_value[0], basestring):\\n metadata[property_name] = property_value\\n else:\\n try:\\n if property_value.typeName == 'com.sun.star.util.DateTime':\\n # It is a local time and we have no timezone information.\\n datetime = \\\"%02d/%02d/%04d %02d:%02d:%02d\\\" % (property_value.Day, property_value.Month,\\n property_value.Year, property_value.Hours, property_value.Minutes, property_value.Seconds)\\n metadata[property_name] = datetime\\n except AttributeError:\\n pass\\n\\n service_manager = helper_util.getServiceManager(self.hostname, self.port,\\n self.uno_path,\\n self.office_binary_path)\\n type_detection = service_manager.createInstance(\\\"com.sun.star.document.TypeDetection\\\")\\n uno_file_access = service_manager.createInstance(\\\"com.sun.star.ucb.SimpleFileAccess\\\")\\n doc = uno_file_access.openFileRead(self.systemPathToFileUrl(self.document_url))\\n input_stream = self._createProperty(\\\"InputStream\\\", doc)\\n open_new_view = self._createProperty(\\\"OpenNewView\\\", True)\\n filter_name = type_detection.queryTypeByDescriptor((input_stream,\\n open_new_view), True)[0]\\n doc.closeInput()\\n metadata['MIMEType'] = mimemapper[\\\"mimetype_by_filter_type\\\"].get(filter_name)\\n return metadata\",\n \"def app_metadata_url():\\n return \\\"https://raw.githubusercontent.com/aiidalab/aiidalab-hello-world/master/metadata.json\\\"\",\n \"def metadata(self) -> global___SnippetConfigMetadata:\",\n \"def write_metadata(zip, datapack):\\n zip.writestr('pack.mcmeta', json.dumps({'pack':{'pack_format':1, 'description':datapack.desc}}, indent=4))\\n zip.writestr('data/minecraft/tags/functions/load.json', json.dumps({'values':['{}:reset'.format(datapack.name)]}))\\n zip.writestr('data/{}/functions/reset.mcfunction'.format(datapack.name), 'tellraw @a [\\\"\\\",{\\\"text\\\":\\\"Loot table randomizer by SethBling, modified by Joelius300\\\",\\\"color\\\":\\\"green\\\"}]')\",\n \"def metadata(self) -> dict:\\n meta = {}\\n meta['filename'] = self.filename\\n meta['label'] = self.label\\n meta['url'] = self.url\\n\\n return meta\",\n \"def _store_package_metadata(self):\",\n \"def create_file_meta_data(vk4_container, args):\\n log.debug(\\\"Entering create_file_meta_data()\\\")\\n\\n header_list = list()\\n header_list.append(args.layer)\\n header_list.append('\\\\n')\\n header_list.append('File name')\\n header_list.append(args.input)\\n header_list.append('Title')\\n header_list.append(args.input[:-4])\\n header_list.append('Measurement date')\\n header_list.append(str(vk4_container.measurement_conditions['month']) + '\\\\\\\\' +\\n str(vk4_container.measurement_conditions['day']) + '\\\\\\\\' +\\n str(vk4_container.measurement_conditions['year']))\\n header_list.append('Measurement time')\\n header_list.append(str(vk4_container.measurement_conditions['hour']) + ':' +\\n str(vk4_container.measurement_conditions['minute']) + ':' +\\n str(vk4_container.measurement_conditions['second']))\\n # User mode?\\n header_list.append('Objective lens')\\n header_list.append(vk4_container.string_data['lens_name'] + ' ' +\\n str(vk4_container.measurement_conditions['lens_magnification'] / 10.0) + 'x')\\n header_list.append('Numerical Aperture')\\n header_list.append(vk4_container.measurement_conditions['num_aperture'] / 1000.0)\\n # Size? Standard?\\n # Mode? Surface profile?\\n # RPD? OFF?\\n header_list.append('Quality')\\n header_list.append('Skip 4 lines')\\n header_list.append('Pitch (um)')\\n header_list.append(vk4_container.measurement_conditions['pitch'] / 1000.0)\\n header_list.append('Z measurement distance (um)')\\n header_list.append(vk4_container.measurement_conditions['distance'] / 1000.0)\\n # Double scan? OFF?\\n header_list.append('Brightness 1')\\n header_list.append(vk4_container.measurement_conditions['PMT_gain'])\\n header_list.append('Brightness 2')\\n br_2 = vk4_container.measurement_conditions['PMT_gain_2']\\n header_list.append('---') if br_2 == 0 else header_list.append(br_2)\\n # Not sure how they got ND filter to 30% in example csv\\n header_list.append('ND filter (%)')\\n header_list.append(vk4_container.measurement_conditions['ND_filter'] * 30)\\n header_list.append('Optical zoom')\\n header_list.append(vk4_container.measurement_conditions['optical_zoom'] / 10.0)\\n # Average count? 1 time?\\n # Filter? OFF?\\n # Fine mode? ON?\\n header_list.append('Line count')\\n l_count = vk4_container.measurement_conditions['number_of_lines']\\n header_list.append(l_count)\\n\\n header_list.append('Line position1')\\n if l_count == 0:\\n header_list.append('---')\\n else:\\n header_list.append(vk4_container.measurement_conditions['reserved_1'][0])\\n\\n header_list.append('Line position2')\\n if l_count == 0:\\n header_list.append('---')\\n else:\\n header_list.append(vk4_container.measurement_conditions['reserved_1'][1])\\n\\n header_list.append('Line position3')\\n if l_count == 0:\\n header_list.append('---')\\n else:\\n header_list.append(vk4_container.measurement_conditions['reserved_1'][2])\\n\\n header_list.append('Camera gain (db)')\\n header_list.append(vk4_container.measurement_conditions['camera_gain'] * 6)\\n header_list.append('Shutter speed')\\n header_list.append(vk4_container.measurement_conditions['shutter_speed'])\\n header_list.append('White balance mode')\\n wb_mode = vk4_container.measurement_conditions['white_balance_mode']\\n header_list.append('Auto') if wb_mode == 1 else header_list.append(wb_mode)\\n header_list.append('White balance R')\\n header_list.append(vk4_container.measurement_conditions['white_balance_red'])\\n header_list.append('White balance B')\\n header_list.append(vk4_container.measurement_conditions['white_balance_blue'])\\n header_list.append('Intensity correction mode')\\n header_list.append('Gamma correction')\\n header_list.append('Gamma correction value')\\n header_list.append(vk4_container.measurement_conditions['gamma'] / 100.0)\\n header_list.append('Gamma offset (%)')\\n header_list.append(vk4_container.measurement_conditions['gamma_correction_offset'] /\\n 65536.0)\\n # W/B inversion? OFF?\\n # Head type? VK-X110?\\n # Correct intensity eccentricity? OFF?\\n # Correct field curvature? OFF?\\n header_list.append('XY calibration (nm/pixel)')\\n header_list.append(vk4_container.measurement_conditions['x_length_per_pixel'] / 1000.0)\\n header_list.append('Z calibration (nm/digit)')\\n header_list.append(vk4_container.measurement_conditions['z_length_per_digit'] / 1000.0)\\n # Saturation?\\n # Contrast?\\n # Brightness?\\n # AI noise elimination? Auto(ON)?\\n # Angled surface noise filter? Auto(OFF)?\\n header_list.append('Width')\\n header_list.append(vk4_container.image_width)\\n header_list.append('Height')\\n header_list.append(vk4_container.image_height)\\n # Skip amount? 1?\\n\\n out_type = args.type\\n if out_type == 'hcsv':\\n log.debug(\\\"Exiting create_file_meta_data() where out_type == %s\\\" % out_type)\\n return np.reshape(header_list, (len(header_list) // 2, 2))\\n else:\\n # Can use a dict to attach info to an image using PILs Image module\\n meta_dict = dict()\\n for n in range(0, len(header_list), 2):\\n meta_dict[header_list[n]] = header_list[n + 1]\\n\\n log.debug(\\\"Exiting create_file_meta_data() where out_type == %s\\\" % out_type)\\n return meta_dict\",\n \"def publish_metadata_in_ipfs(self):\\n self._printout(self._publish_metadata_in_ipfs(self.args.metadata_file))\",\n \"def serve_metadata():\\n xml = generate_xml_metadata()\\n return Response(xml, mimetype=\\\"application/gzip\\\")\",\n \"def get_meta(meta):\\n thumb_url = '{}{}?X-Plex-Token={}'.format(\\n meta._server._baseurl, meta.thumb, meta._server._token)\\n\\n meta_dict = {'title': meta.title,\\n 'rating': meta.rating if\\n meta.rating is not None else 0.0,\\n 'genres': [x.tag for x in meta.genres],\\n 'server': [meta._server.friendlyName],\\n 'thumb': [thumb_url]\\n }\\n if meta.guid:\\n # guid will return (com.plexapp.agents.imdb://tt4302938?lang=en)\\n # Agents will differ between servers.\\n agent = meta.guid\\n source_name = agent.split('://')[0].split('.')[-1]\\n source_id = agent.split('://')[1].split('?')[0]\\n meta_dict[source_name] = source_id\\n\\n if meta.type == 'movie':\\n # For movies with same titles\\n meta_dict['title'] = u'{} ({})'.format(meta.title, meta.year)\\n return meta_dict\",\n \"def writeToMetadata(self, context):\\n pass\",\n \"def make_image_metadata(metadata, suffix, outdir, i, rname, desc, rmsnoise):\\n meta_suffix = copy.deepcopy(metadata)\\n out_file = metadata['FITSImageFilename'][i]\\n\\n out_filebase = os.path.splitext(out_file)[0]\\n out_filebase_suffix = out_filebase + suffix\\n _update_metadata_imagedata(meta_suffix, out_filebase_suffix, i)\\n\\n meta_suffix['ProductType']['ReductionName'] = rname\\n desc_prefix = meta_suffix['Description'].split(':')[0]\\n meta_suffix['Description'] = desc_prefix + f': {desc}'\\n\\n meta_suffix['RMSNoise'] = [str(rmsnoise)]\\n write_metadata(meta_suffix, outdir)\",\n \"def addMetadata(*args, channelName: Union[AnyStr, bool]=\\\"\\\", channelType: Union[AnyStr, bool]=\\\"\\\",\\n indexType: Union[AnyStr, bool]=\\\"\\\", scene: bool=True, streamName: Union[AnyStr,\\n bool]=\\\"\\\", structure: Union[AnyStr, bool]=\\\"\\\", q=True, query=True,\\n **kwargs)->Union[List[AnyStr], Any]:\\n pass\",\n \"def build_metadata(meta):\\n\\n ret = copy.copy(meta) if meta else dict()\\n\\n ret['name'] = meta.get('name', '')\\n\\n if 'index' in meta:\\n if isinstance(meta.get('index'), str):\\n ret['index'] = Index(meta.get('index'))\\n elif isinstance(meta.get('index'), Index):\\n ret['index'] = meta.get('index')\\n\\n ret['utc'] = True\\n if 'utc' in meta and isinstance(meta.get('utc'), bool):\\n ret['utc'] = meta.get('utc')\\n\\n return pmap(ret)\",\n \"def get_metadata(sf):\\r\\n data = {}\\r\\n all_describe = sf.describe()\\r\\n\\r\\n s_objs = all_describe['sobjects']\\r\\n # scan the objects and save to a list...\\r\\n for obj in s_objs:\\r\\n row = {}\\r\\n row['name'] = obj['name']\\r\\n row['label'] = obj['label']\\r\\n row['custom'] = obj['custom']\\r\\n row['activateable'] = obj['activateable']\\r\\n row['keyPrefix'] = obj['keyPrefix']\\r\\n row['labelPlural'] = obj['labelPlural']\\r\\n\\r\\n row['raw'] = obj\\r\\n\\r\\n logger.info('\\\\t{}\\\\t-> {}'.format(obj['label'], obj['name']))\\r\\n data[row['name']] = row\\r\\n\\r\\n return data\",\n \"def PrintMetadata(self):\\n def PrintTrack(trackno, track):\\n output = [f\\\"File {str(trackno + 1).zfill(2)}:\\\"]\\n with IgnoreKeyError:\\n output.append(f\\\"Disc {track['disc']}\\\")\\n with IgnoreKeyError:\\n output.append(f\\\"Side {track['side']}\\\")\\n output.append(f\\\"Track {track['track'].ljust(2)}\\\")\\n with IgnoreKeyError:\\n output.append(f\\\"Phase {track['phase']}\\\")\\n with IgnoreKeyError:\\n output.append(f\\\"Subindex {track['subindex']}\\\")\\n output.append(f\\\"Time {track['start_time']}\\\")\\n output.append(f'\\\"{track[\\\"title\\\"]}\\\"')\\n with IgnoreKeyError:\\n output[-1] = f'{output[-1][:-1]}: {track[\\\"subtitle\\\"]}\\\"'\\n print(' '.join(output))\\n\\n print(self)\\n for trackno, track in enumerate(self.tracks):\\n PrintTrack(trackno, track)\\n filename = self.GetOutputFilename().replace(ext.WAV, ext.MKA)\\n print(\\\"Filename:\\\", filename)\",\n \"def app_metadata(requests_mock):\\n return {\\n \\\"description\\\": \\\"A test app that does not really exist.\\\",\\n \\\"title\\\": \\\"Test App\\\",\\n \\\"version\\\": \\\"1.0.0\\\",\\n \\\"authors\\\": \\\"AiiDAlab team\\\",\\n \\\"state\\\": \\\"development\\\",\\n }\",\n \"def metadata(self):\\n return {\\n \\\"wildtype\\\" : self.wildtype,\\n \\\"genotypes\\\" : self.genotypes,\\n \\\"phenotypes\\\" : self.Raw.phenotypes,\\n \\\"stdeviations\\\" : self.stdeviations,\\n \\\"n_replicates\\\" : self.n_replicates,\\n \\\"mutations\\\" : self.mutations,\\n \\\"log_transform\\\" : self.log_transform,\\n \\\"order\\\" : self.order,\\n \\\"epistasis\\\" : {\\n \\\"keys\\\" : self.epistasis.keys,\\n \\\"values\\\" : self.epistasis.values,\\n }\\n }\",\n \"def write_stewicombo_metadata(file_name, metadata_dict, category=''):\\n meta = set_stewicombo_meta(file_name, category=category)\\n meta.tool_meta = metadata_dict\\n write_metadata_to_file(paths, meta)\",\n \"def metadata_reporter(self):\\n logging.info('Creating summary report')\\n header = '{}\\\\n'.format(','.join(self.headers))\\n # Create a string to store all the results\\n data = str()\\n for sample in self.metadata:\\n # Add the value of the appropriate attribute to the results string\\n data += GenObject.returnattr(sample, 'name')\\n # SampleName\\n data += GenObject.returnattr(sample.run, 'SamplePlate')\\n # Genus\\n data += GenObject.returnattr(sample.general, 'closestrefseqgenus')\\n # SamplePurity\\n data += GenObject.returnattr(sample.confindr, 'num_contaminated_snvs')\\n # N50\\n n50 = GenObject.returnattr(sample.quast, 'N50',\\n number=True)\\n if n50 != '-,':\\n data += n50\\n else:\\n data += '0,'\\n # NumContigs\\n data += GenObject.returnattr(sample.quast, 'num_contigs',\\n number=True)\\n # TotalLength\\n data += GenObject.returnattr(sample.quast, 'Total_length',\\n number=True)\\n # MeanInsertSize\\n data += GenObject.returnattr(sample.quast, 'mean_insert',\\n number=True)\\n # InsertSizeSTD\\n data += GenObject.returnattr(sample.quast, 'std_insert',\\n number=True)\\n # AverageCoverageDepth\\n data += GenObject.returnattr(sample.qualimap, 'MeanCoveragedata',\\n number=True)\\n # CoverageDepthSTD\\n data += GenObject.returnattr(sample.qualimap, 'StdCoveragedata',\\n number=True)\\n # PercentGC\\n data += GenObject.returnattr(sample.quast, 'GC',\\n number=True)\\n # MASH_ReferenceGenome\\n data += GenObject.returnattr(sample.mash, 'closestrefseq')\\n # MASH_NumMatchingHashes\\n data += GenObject.returnattr(sample.mash, 'nummatches')\\n # 16S_result\\n data += GenObject.returnattr(sample.sixteens_full, 'sixteens_match')\\n # 16S PercentID\\n data += GenObject.returnattr(sample.sixteens_full, 'percent_id')\\n # CoreGenesPresent\\n data += GenObject.returnattr(sample.gdcs, 'coreresults')\\n # rMLST_Result\\n try:\\n # If the number of matches to the closest reference profile is 53, return the profile number\\n if sample.rmlst.matches == 53:\\n if type(sample.rmlst.sequencetype) is list:\\n rmlst_seq_type = ';'.join(sorted(sample.rmlst.sequencetype)).rstrip(';') + ','\\n else:\\n rmlst_seq_type = GenObject.returnattr(sample.rmlst, 'sequencetype')\\n rmlst_seq_type = rmlst_seq_type if rmlst_seq_type != 'ND,' else 'new,'\\n data += rmlst_seq_type\\n else:\\n # Otherwise the profile is set to new\\n data += 'new,'\\n except AttributeError:\\n data += 'new,'\\n # MLST_Result\\n try:\\n if sample.mlst.matches == 7:\\n if type(sample.mlst.sequencetype) is list:\\n mlst_seq_type = ';'.join(sorted(sample.mlst.sequencetype)).rstrip(';') + ','\\n else:\\n mlst_seq_type = GenObject.returnattr(sample.mlst, 'sequencetype')\\n mlst_seq_type = mlst_seq_type if mlst_seq_type != 'ND,' else 'new,'\\n data += mlst_seq_type\\n else:\\n data += 'new,'\\n except AttributeError:\\n data += 'new,'\\n # MLST_gene_X_alleles\\n try:\\n # Create a set of all the genes present in the results (gene name split from allele)\\n gene_set = {gene.split('_')[0] for gene in sample.mlst.combined_metadata_results}\\n for gene in sorted(gene_set):\\n allele_list = list()\\n # Determine all the alleles that are present for each gene\\n for allele in sample.mlst.combined_metadata_results:\\n if gene in allele:\\n allele_list.append(allele.replace(' ', '_'))\\n # If there is more than one allele in the sample, add both to the string separated by a ';'\\n if len(allele_list) > 1:\\n data += '{},'.format(';'.join(allele_list))\\n # Otherwise add the only allele\\n else:\\n data += allele_list[0] + ','\\n # If there are fewer than seven matching alleles, add a ND for each missing result\\n if len(gene_set) < 7:\\n data += (7 - len(gene_set)) * 'ND,'\\n except AttributeError:\\n # data += '-,-,-,-,-,-,-,'\\n data += 'ND,ND,ND,ND,ND,ND,ND,'\\n # E_coli_Serotype\\n try:\\n # If no O-type was found, set the output to be O-untypeable\\n if ';'.join(sample.ectyper.o_type) == '-':\\n otype = 'O-untypeable'\\n else:\\n otype = sample.ectyper.o_type\\n # Same as above for the H-type\\n if ';'.join(sample.ectyper.h_type) == '-':\\n htype = 'H-untypeable'\\n\\n else:\\n htype = sample.ectyper.h_type\\n serotype = '{otype}:{htype},'.format(otype=otype,\\n htype=htype)\\n # Add the serotype to the data string unless neither O-type not H-type were found; add ND instead\\n data += serotype if serotype != 'O-untypeable:H-untypeable,' else 'ND,'\\n except AttributeError:\\n data += 'ND,'\\n # SISTR_serovar_antigen\\n data += GenObject.returnattr(sample.sistr, 'serovar_antigen').rstrip(';')\\n # SISTR_serovar_cgMLST\\n data += GenObject.returnattr(sample.sistr, 'serovar_cgmlst')\\n # SISTR_serogroup\\n data += GenObject.returnattr(sample.sistr, 'serogroup')\\n # SISTR_h1\\n data += GenObject.returnattr(sample.sistr, 'h1').rstrip(';')\\n # SISTR_h2\\n data += GenObject.returnattr(sample.sistr, 'h2').rstrip(';')\\n # SISTR_serovar\\n data += GenObject.returnattr(sample.sistr, 'serovar')\\n # GeneSeekr_Profile\\n try:\\n if sample.genesippr.report_output:\\n data += ';'.join(sample.genesippr.report_output) + ','\\n else:\\n data += 'ND,'\\n except AttributeError:\\n data += 'ND,'\\n # Vtyper_Profile\\n data += GenObject.returnattr(sample.verotoxin, 'verotoxin_subtypes_set')\\n # AMR_Profile and resistant/sensitive status\\n if sample.resfinder_assembled.pipelineresults:\\n # Profile\\n for resistance, resistance_set in sorted(sample.resfinder_assembled.pipelineresults.items()):\\n data += '{res}({r_set});'.format(res=resistance.replace(',', ';'),\\n r_set=';'.join(sorted(list(resistance_set))))\\n data += ','\\n # Resistant/Sensitive\\n data += 'Resistant,'\\n else:\\n # Profile\\n data += 'ND,'\\n # Resistant/Sensitive\\n data += 'Sensitive,'\\n # Plasmid Result'\\n if sample.mobrecon.pipelineresults:\\n for plasmid, details in sorted(sample.mobrecon.pipelineresults.items()):\\n data += '{plasmid}({details});'.format(plasmid=plasmid,\\n details=details)\\n data += ','\\n else:\\n data += 'ND,'\\n # TotalPredictedGenes\\n data += GenObject.returnattr(sample.prodigal, 'predictedgenestotal',\\n number=True)\\n # PredictedGenesOver3000bp\\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesover3000bp',\\n number=True)\\n # PredictedGenesOver1000bp\\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesover1000bp',\\n number=True)\\n # PredictedGenesOver500bp\\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesover500bp',\\n number=True)\\n # PredictedGenesUnder500bp\\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesunder500bp',\\n number=True)\\n # AssemblyDate\\n data += datetime.now().strftime('%Y-%m-%d') + ','\\n # PipelineVersion\\n data += self.commit + ','\\n # Name of the database used in the analyses\\n data += os.path.split(self.reffilepath)[-1] + ','\\n # Database download date\\n data += self.download_date\\n # Append a new line to the end of the results for this sample\\n data += '\\\\n'\\n # Replace any NA values with ND\\n cleandata = data.replace('NA', 'ND')\\n with open(os.path.join(self.reportpath, 'combinedMetadata.csv'), 'w') as metadatareport:\\n metadatareport.write(header)\\n metadatareport.write(cleandata)\",\n \"def extract_meta_data(video_file_name, output_file=meta.txt, *args, **kwargs):\",\n \"def get_stream_type(self) -> str:\",\n \"def build_metadata(results):\\n\\n print('Building metadata...')\\n\\n fields = set(['name', 'timestamp', 'value', 'scrape_timestamp'])\\n metadata = connector_pb2.GetDataResponse()\\n\\n for result in results:\\n for metric in result['metric'].keys():\\n if metric != '__name__':\\n fields.add(metric)\\n\\n for field in fields:\\n metadata.fieldInfo.extend([connector_pb2.FieldInfo(name = field)])\\n\\n return metadata\",\n \"def meta_info_feats(self, output_path, file_types):\\n return self.build_meta(output_path, file_types)\",\n \"def metadataDirectory(self):\\n guid_hash = utils.sha1hash(self.guid)\\n return str(Path('Metadata') / 'TV Shows' / guid_hash[0] / f'{guid_hash[1:]}.bundle')\",\n \"def metadata_for_mode(self, player_mode, additional_data=None):\\r\\n metadata = {}\\r\\n\\r\\n if player_mode == 'html5':\\r\\n metadata.update({\\r\\n 'youtube_id_1_0': '',\\r\\n 'youtube_id_0_75': '',\\r\\n 'youtube_id_1_25': '',\\r\\n 'youtube_id_1_5': '',\\r\\n 'html5_sources': HTML5_SOURCES\\r\\n })\\r\\n\\r\\n if player_mode == 'youtube_html5':\\r\\n metadata.update({\\r\\n 'html5_sources': HTML5_SOURCES,\\r\\n })\\r\\n\\r\\n if player_mode == 'youtube_html5_unsupported_video':\\r\\n metadata.update({\\r\\n 'html5_sources': HTML5_SOURCES_INCORRECT\\r\\n })\\r\\n\\r\\n if player_mode == 'html5_unsupported_video':\\r\\n metadata.update({\\r\\n 'youtube_id_1_0': '',\\r\\n 'youtube_id_0_75': '',\\r\\n 'youtube_id_1_25': '',\\r\\n 'youtube_id_1_5': '',\\r\\n 'html5_sources': HTML5_SOURCES_INCORRECT\\r\\n })\\r\\n\\r\\n if additional_data:\\r\\n metadata.update(additional_data)\\r\\n\\r\\n return metadata\",\n \"def output_metadata(self, metadata = None):\\n return True\",\n \"def _construct_standardized_metadata(self):\\n return None\",\n \"def metadata_obj(filelike):\\n\\tif test_hachoir_extension(filelike.name):\\n\\t\\tmetadata = metadata_for_filelike(filelike)\\n\\t\\tif metadata:\\n\\t\\t\\tdata = dict([\\n\\t\\t\\t\\t(data.key, data.values[0].value)\\n\\t\\t\\t\\tfor data in metadata\\n\\t\\t\\t\\tif data.values\\n\\t\\t\\t\\t])\\n\\t\\telse:\\n\\t\\t\\tdata=None\\n\\telif test_3D_extension(filelike.name):# 3D not in the extention \\n\\t\\tdata = {'mime_type':'model'}\\n\\telse:\\n\\t\\tdata = None\\n\\t\\t\\n\\treturn data\",\n \"def generateAudio(audiotype: str, audiometadata: dict):\\n try:\\n audiotype = audiotype.lower()\\n\\n if audiotype == \\\"song\\\":\\n file = Song(audiometadata)\\n elif audiotype == \\\"podcast\\\":\\n file = Podcast(audiometadata)\\n elif audiotype == \\\"audiobook\\\":\\n file = Audiobook(audiometadata)\\n else:\\n return None\\n\\n return file\\n\\n except MetadataValueError as error:\\n raise MetadataValueError(error)\\n\\n except MetadataGenerationError as error:\\n raise MetadataGenerationError(error)\",\n \"def get_metadata_v2(session):\\n LOG.debug(\\\"Exporting metadata for SFS augur build\\\")\\n\\n metadata = datastore.fetch_rows_from_table(session, (\\\"shipping\\\", \\\"metadata_for_augur_build_v2\\\"))\\n\\n return Response((row[0] + '\\\\n' for row in metadata), mimetype=\\\"application/x-ndjson\\\")\",\n \"def create_stream_definition():\\n stream_def = StreamDefinition()\\n stream_def.name = HealthStatisticsPublisherManager.STREAM_NAME\\n stream_def.version = HealthStatisticsPublisherManager.STREAM_VERSION\\n stream_def.nickname = HealthStatisticsPublisherManager.STREAM_NICKNAME\\n stream_def.description = HealthStatisticsPublisherManager.STREAM_DESCRIPTION\\n\\n # stream_def.add_payloaddata_attribute()\\n stream_def.add_payloaddata_attribute(\\\"timestamp\\\", StreamDefinition.LONG)\\n stream_def.add_payloaddata_attribute(\\\"cluster_id\\\", StreamDefinition.STRING)\\n stream_def.add_payloaddata_attribute(\\\"cluster_instance_id\\\", StreamDefinition.STRING)\\n stream_def.add_payloaddata_attribute(\\\"network_partition_id\\\", StreamDefinition.STRING)\\n stream_def.add_payloaddata_attribute(\\\"member_id\\\", StreamDefinition.STRING)\\n stream_def.add_payloaddata_attribute(\\\"partition_id\\\", StreamDefinition.STRING)\\n stream_def.add_payloaddata_attribute(\\\"health_description\\\", StreamDefinition.STRING)\\n stream_def.add_payloaddata_attribute(\\\"value\\\", StreamDefinition.DOUBLE)\\n\\n return stream_def\",\n \"def metadata(self): # -> list[Unknown]:\\n ...\",\n \"def metadata(self): # -> list[Unknown]:\\n ...\",\n \"def __metadata__(self):\\n raise NotImplementedError\",\n \"def generate_petastorm_metadata(spark, dataset_url, unischema_class=None, use_summary_metadata=False,\\n hdfs_driver='libhdfs3'):\\n sc = spark.sparkContext\\n\\n resolver = FilesystemResolver(dataset_url, sc._jsc.hadoopConfiguration(), hdfs_driver=hdfs_driver,\\n user=spark.sparkContext.sparkUser())\\n fs = resolver.filesystem()\\n dataset = pq.ParquetDataset(\\n resolver.get_dataset_path(),\\n filesystem=fs,\\n validate_schema=False)\\n\\n if unischema_class:\\n schema = locate(unischema_class)\\n if not isinstance(schema, Unischema):\\n raise ValueError('The specified class %s is not an instance of a petastorm.Unischema object.',\\n unischema_class)\\n else:\\n\\n try:\\n schema = get_schema(dataset)\\n except ValueError:\\n raise ValueError('Unischema class could not be located in existing dataset,'\\n ' please specify it')\\n\\n # In order to be backwards compatible, we retrieve the common metadata from the dataset before\\n # overwriting the metadata to keep row group indexes and the old row group per file index\\n arrow_metadata = dataset.common_metadata or None\\n\\n with materialize_dataset(spark, dataset_url, schema, use_summary_metadata=use_summary_metadata,\\n filesystem_factory=resolver.filesystem_factory()):\\n if use_summary_metadata:\\n # Inside the materialize dataset context we just need to write the metadata file as the schema will\\n # be written by the context manager.\\n # We use the java ParquetOutputCommitter to write the metadata file for the existing dataset\\n # which will read all the footers of the dataset in parallel and merge them.\\n hadoop_config = sc._jsc.hadoopConfiguration()\\n Path = sc._gateway.jvm.org.apache.hadoop.fs.Path\\n parquet_output_committer = sc._gateway.jvm.org.apache.parquet.hadoop.ParquetOutputCommitter\\n parquet_output_committer.writeMetaDataFile(hadoop_config, Path(dataset_url))\\n\\n spark.stop()\\n\\n if use_summary_metadata and arrow_metadata:\\n # When calling writeMetaDataFile it will overwrite the _common_metadata file which could have schema information\\n # or row group indexers. Therefore we want to retain this information and will add it to the new\\n # _common_metadata file. If we were using the old legacy metadata method this file wont be deleted\\n base_schema = arrow_metadata.schema.to_arrow_schema()\\n metadata_dict = base_schema.metadata\\n if ROW_GROUPS_PER_FILE_KEY in metadata_dict:\\n add_to_dataset_metadata(dataset, ROW_GROUPS_PER_FILE_KEY, metadata_dict[ROW_GROUPS_PER_FILE_KEY])\\n if ROWGROUPS_INDEX_KEY in metadata_dict:\\n add_to_dataset_metadata(dataset, ROWGROUPS_INDEX_KEY, metadata_dict[ROWGROUPS_INDEX_KEY])\",\n \"def set_stewi_meta(file_name, stewiformat=''):\\n stewi_meta = FileMeta()\\n stewi_meta.name_data = file_name\\n stewi_meta.category = stewiformat\\n stewi_meta.tool = \\\"StEWI\\\"\\n stewi_meta.tool_version = STEWI_VERSION\\n stewi_meta.ext = WRITE_FORMAT\\n stewi_meta.git_hash = GIT_HASH\\n stewi_meta.date_created = datetime.now().strftime('%d-%b-%Y')\\n return stewi_meta\",\n \"def transfer2meta():\\n for i in ekindicts:\\n e=ekindicts[i]\\n t.showMeta(e)\\n #t.transfer2meta(e)\\n #t.returnData()\\n\\n return\",\n \"def write_metadata(self, data_set, io=None, location=None):\\n if not hasattr(data_set, '_h5_base_group'):\\n # added here because loop writes metadata before data itself\\n data_set._h5_base_group = self._create_data_object(data_set)\\n if 'metadata' in data_set._h5_base_group.keys():\\n del data_set._h5_base_group['metadata']\\n metadata_group = data_set._h5_base_group.create_group('metadata')\\n self.write_dict_to_hdf5(data_set.metadata, metadata_group)\",\n \"def extract_metadata(self):\\n metadata_file_path = self.create_metadata_file(\\\".metadata.txt\\\")\\n mt = self.mimetype\\n metadata_processing_method = self.metadata_mimetype_methods.get(mt)\\n if metadata_processing_method:\\n # TODO: should we return metadata and write it here instead of in processing method?\\n metadata_processing_method(metadata_file_path)\",\n \"def GetMetadata(self):\\n return self.dict['meta']\",\n \"def make_report_metadata(metadata, out_dir):\\n metadata_qa = {}\\n # Edit the product type and description\\n metadata_qa[\\\"ProductType\\\"] = {\\\"ProductTypeName\\\": \\\"MeerKATReductionProduct\\\",\\n \\\"ReductionName\\\": \\\"Continuum Image Quality Report\\\"}\\n\\n desc_prefix = metadata[\\\"Description\\\"].split(':')[0]\\n metadata_qa[\\\"Description\\\"] = desc_prefix + \\\": Continuum image quality report\\\"\\n\\n # Copy remaining keys from original metadata\\n report_keys = [\\\"StartTime\\\", \\\"CaptureBlockId\\\",\\n \\\"ProposalId\\\", \\\"Observer\\\", \\\"ScheduleBlockIdCode\\\",\\n \\\"Run\\\"]\\n for key in report_keys:\\n metadata_qa[key] = metadata[key]\\n\\n write_metadata(metadata_qa, out_dir)\",\n \"def get_metadata(self, idx=0):\\n meta_data = {}\\n with h5py.File(self.path) as h5:\\n ds = h5[str(idx)]\\n attrs = dict(ds.attrs)\\n for key in qpimage.meta.META_KEYS:\\n if key in attrs:\\n meta_data[key] = attrs[key]\\n\\n smeta = super(SingleRawOAHQpformatHDF5, self).get_metadata(idx)\\n meta_data.update(smeta)\\n return meta_data\",\n \"def generate_metadata(self):\\n if self.options.mbtiles:\\n return\\n if not os.path.exists(self.output):\\n os.makedirs(self.output)\\n\\n if self.options.profile == 'mercator':\\n\\n south, west = self.mercator.MetersToLatLon( self.ominx, self.ominy)\\n north, east = self.mercator.MetersToLatLon( self.omaxx, self.omaxy)\\n south, west = max(-85.05112878, south), max(-180.0, west)\\n north, east = min(85.05112878, north), min(180.0, east)\\n self.swne = (south, west, north, east)\\n\\n # Generate googlemaps.html\\n if self.options.webviewer in ('all','google') and self.options.profile == 'mercator':\\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'googlemaps.html')):\\n f = open(os.path.join(self.output, 'googlemaps.html'), 'w')\\n f.write( self.generate_googlemaps() )\\n f.close()\\n\\n # Generate openlayers.html\\n if self.options.webviewer in ('all','openlayers'):\\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'openlayers.html')):\\n f = open(os.path.join(self.output, 'openlayers.html'), 'w')\\n f.write( self.generate_openlayers() )\\n f.close()\\n\\n elif self.options.profile == 'geodetic':\\n\\n west, south = self.ominx, self.ominy\\n east, north = self.omaxx, self.omaxy\\n south, west = max(-90.0, south), max(-180.0, west)\\n north, east = min(90.0, north), min(180.0, east)\\n self.swne = (south, west, north, east)\\n\\n # Generate openlayers.html\\n if self.options.webviewer in ('all','openlayers'):\\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'openlayers.html')):\\n f = open(os.path.join(self.output, 'openlayers.html'), 'w')\\n f.write( self.generate_openlayers() )\\n f.close()\\n\\n elif self.options.profile in ['raster','gearth','garmin']:\\n\\n west, south = self.ominx, self.ominy\\n east, north = self.omaxx, self.omaxy\\n\\n self.swne = (south, west, north, east)\\n\\n # Generate openlayers.html\\n if self.options.webviewer in ('all','openlayers'):\\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'openlayers.html')):\\n f = open(os.path.join(self.output, 'openlayers.html'), 'w')\\n f.write( self.generate_openlayers() )\\n f.close()\\n\\n\\n # Generate tilemapresource.xml.\\n if (self.options.tile_format != 'hybrid' and self.options.profile != 'garmin'\\n and (not self.options.resume or not os.path.exists(os.path.join(self.output, 'tilemapresource.xml')))):\\n f = open(os.path.join(self.output, 'tilemapresource.xml'), 'w')\\n f.write( self.generate_tilemapresource())\\n f.close()\",\n \"def metadata(self):\\n return {\\n \\\"namespace\\\": self.namespace,\\n \\\"short_name\\\": f\\\"{self.namespace}_{self._dataset_metadata['DatasetCode']}\\\",\\n \\\"name\\\": f\\\"{self._dataset_metadata['DatasetName']} - FAO ({self.publication_year})\\\",\\n \\\"description\\\": self._dataset_metadata[\\\"DatasetDescription\\\"],\\n \\\"source_name\\\": \\\"Food and Agriculture Organization of the United Nations\\\",\\n \\\"publication_year\\\": int(self.publication_year),\\n \\\"publication_date\\\": self._dataset_metadata[\\\"DateUpdate\\\"],\\n \\\"date_accessed\\\": str(dt.date.today()),\\n \\\"url\\\": self.url,\\n \\\"source_data_url\\\": self.source_data_url,\\n \\\"file_extension\\\": \\\"zip\\\",\\n }\",\n \"def _getMetadataName(self):\\n return \\\"%s_processCoadd_metadata\\\" % (self.config.coaddName,)\",\n \"def writeToMetadata(self, context):\\n if self.modelType not in GenericMetadata.MODEL_TYPES:\\n raise Exception(\\\"Model type %s is not among known model types: %s\\\" % (self.modelType, str(GenericMetadata.MODEL_TYPES) ) )\\n \\n modelRunEntries = GenericMetadata.readModelRunEntries(context)\\n try:\\n runs = modelRunEntries['runs'].split(GenericMetadata.VALUE_DELIM)\\n except KeyError:\\n runs = []\\n \\n # Collected model entry and keys and values into lists so we can write to metadata store in batch\\n keys = []\\n values = []\\n \\n # Generate unique identifier for this model run. Unique ID is a combination of model type and a number\\n entryNumber = 1\\n fqId = self.modelType + GenericMetadata.KEY_SEP + str(entryNumber)\\n while fqId in runs:\\n entryNumber += 1\\n fqId = self.modelType + GenericMetadata.KEY_SEP + str(entryNumber)\\n self.runNumber = entryNumber\\n # Add new run to list of runs\\n runs.append(fqId)\\n runsStr = GenericMetadata.VALUE_DELIM.join(runs)\\n keys.append('runs'); values.append(runsStr)\\n # Write attributes for run\\n keyProto = fqId + GenericMetadata.KEY_SEP\\n runDate = keyProto + 'date_utc'\\n keys.append(runDate); values.append( self.date.strftime(ModelRun.FMT_DATE) )\\n runDesc = keyProto + 'description'\\n keys.append(runDesc); values.append(self.description)\\n runCmd = keyProto + 'command'\\n keys.append(runCmd); values.append(self.command)\\n runOutput = keyProto + 'output'\\n keys.append(runOutput); values.append(self.output)\\n # Write to metadata\\n GenericMetadata.writeModelRunEntries(context, keys, values)\",\n \"def addOutputMetaData(nnSpec):\\n for i, featureMapDimension in enumerate(featureMapDimensions):\\n nnSpec.description.output[i].type.multiArrayType.shape.append(1)\\n nnSpec.description.output[i].type.multiArrayType.shape.append(3)\\n nnSpec.description.output[i].type.multiArrayType.shape.append(\\n featureMapDimension\\n )\\n nnSpec.description.output[i].type.multiArrayType.shape.append(\\n featureMapDimension\\n )\\n # pc, bx, by, bh, bw, c (no of class class labels)\\n nnSpec.description.output[i].type.multiArrayType.shape.append(outputSize)\\n nnSpec.description.output[\\n i\\n ].type.multiArrayType.dataType = (\\n ct.proto.FeatureTypes_pb2.ArrayFeatureType.DOUBLE\\n )\",\n \"def _metadata_builder(metadata: Dict, scheme) -> Dict:\\n\\n metadata_field_for_scheme = metadata_field_by_scheme.get(scheme)\\n\\n _config = kaptan.Kaptan()\\n _config.import_config(metadata)\\n\\n return {\\n **{\\n metadata_field: _config.get(\\n metadata_field_for_scheme[metadata_field]\\n ) for metadata_field in metadata_field_for_scheme.keys()\\n },\\n \\\"ui\\\": UIJSONSerializer().serialize_object_to_dict(metadata).get(\\\"ui\\\")\\n }\",\n \"def __appendMetaData(self, filename):\\n metadata = {'Model': 'LFM',\\n 'Source': filename,\\n 'Date processed': datetime.datetime.now(),\\n 'Start date': self.startDate\\n }\\n \\n self.data.append(key='meta',\\n name='Metadata for LFM Solar Wind file',\\n units='n/a',\\n data=metadata)\",\n \"def metadataDirectory(self):\\n guid_hash = utils.sha1hash(self.parentGuid)\\n return str(Path('Metadata') / 'TV Shows' / guid_hash[0] / f'{guid_hash[1:]}.bundle')\",\n \"def test_metadata(self):\\n self.default_kwargs['metadata_callback'] = self._metadata_callback\\n self.encoder = StreamEncoder(**self.default_kwargs)\\n test_samples = np.random.rand(DEFAULT_BLOCKSIZE, 1).astype('int16')\\n self.encoder.process(test_samples)\\n self.encoder.finish()\\n self.assertTrue(self.write_callback_called)\\n self.assertTrue(self.metadata_callback_called)\",\n \"def publish_proto_metadata_update(self):\\n metadata = load_mpe_service_metadata(self.args.metadata_file)\\n ipfs_hash_base58 = ipfs_utils.publish_proto_in_ipfs(\\n self._get_ipfs_client(), self.args.protodir)\\n metadata.set_simple_field(\\\"model_ipfs_hash\\\", ipfs_hash_base58)\\n metadata.save_pretty(self.args.metadata_file)\",\n \"def init_meta(self):\\n meta = {}\\n # Required (core)\\n meta['ra'] = dict(ext=1, card='RA')\\n meta['dec'] = dict(ext=1, card='DEC')\\n meta['target'] = dict(ext=1, card='OBJECT')\\n meta['decker'] = dict(ext=1, card='APERTURE')\\n meta['dichroic'] = dict(ext=1, card='FILTER')\\n meta['binning'] = dict(ext=1, card=None, default='1,1')\\n\\n meta['mjd'] = dict(ext=0, card=None, compound=True)\\n meta['exptime'] = dict(ext=1, card='EXPTIME')\\n meta['airmass'] = dict(ext=1, card='AIRMASS')\\n # Extras for config and frametyping\\n meta['dispname'] = dict(ext=1, card='DISPERSE')\\n meta['idname'] = dict(ext=1, card='IMAGETYP')\\n\\n # Ingest\\n self.meta = meta\",\n \"def print_metadata(value):\\n print '\\\\nHydroShare metadata:'\\n print print_recursive(value)\",\n \"def _get_metadata(self) -> Metadata:\\n manifest = self._get_manifest()\\n\\n return Metadata(**manifest[\\\"metadata\\\"])\",\n \"def store_pkg_metadata(self, pkg, version):\\n pass\",\n \"def metadata_name(filename):\\n\\tif test_hachoir_extension(filename):\\n\\t\\tmetadata = metadata_for_file(filename)\\n\\t\\tif metadata:\\n\\t\\t\\tdata = dict([\\n\\t\\t\\t\\t(data.key, data.values[0].value)\\n\\t\\t\\t\\tfor data in metadata\\n\\t\\t\\t\\tif data.values\\n\\t\\t\\t\\t])\\n\\t\\telse:\\n\\t\\t\\tdata=None\\n\\telif test_3D_extension(filename):# 3D not in the extention \\n\\t\\tdata = {'mime_type':'model'}\\n\\telse:\\n\\t\\tdata=None\\n\\treturn data\",\n \"def _getMetadataName(self):\\n pass\",\n \"def create_meta(prefix, dist, info_dir, extra_info):\\n # read info/index.json first\\n with open(join(info_dir, 'index.json')) as fi:\\n meta = json.load(fi)\\n # add extra info\\n meta.update(extra_info)\\n # write into <prefix>/conda-meta/<dist>.json\\n meta_dir = join(prefix, 'conda-meta')\\n if not isdir(meta_dir):\\n os.makedirs(meta_dir)\\n with open(join(meta_dir, 'history'), 'w') as fo:\\n fo.write('')\\n with open(join(meta_dir, dist + '.json'), 'w') as fo:\\n json.dump(meta, fo, indent=2, sort_keys=True)\",\n \"def get_metadata_v3(session):\\n LOG.debug(\\\"Exporting metadata for SFS augur build\\\")\\n\\n metadata = datastore.fetch_rows_from_table(session, (\\\"shipping\\\", \\\"metadata_for_augur_build_v3\\\"))\\n\\n return Response((row[0] + '\\\\n' for row in metadata), mimetype=\\\"application/x-ndjson\\\")\",\n \"def run(self, info):\\n\\n # Write the metadata to the file's xattrs\\n self._downloader.to_screen('[metadata] Writing metadata to file\\\\'s xattrs')\\n\\n filename = info['filepath']\\n\\n try:\\n xattr_mapping = {\\n 'user.xdg.referrer.url': 'webpage_url',\\n # 'user.xdg.comment': 'description',\\n 'user.dublincore.title': 'title',\\n 'user.dublincore.date': 'upload_date',\\n 'user.dublincore.description': 'description',\\n 'user.dublincore.contributor': 'uploader',\\n 'user.dublincore.format': 'format',\\n }\\n\\n num_written = 0\\n for xattrname, infoname in xattr_mapping.items():\\n\\n value = info.get(infoname)\\n\\n if value:\\n if infoname == 'upload_date':\\n value = hyphenate_date(value)\\n\\n byte_value = value.encode('utf-8')\\n write_xattr(filename, xattrname, byte_value)\\n num_written += 1\\n\\n return [], info\\n\\n except XAttrUnavailableError as e:\\n self._downloader.report_error(str(e))\\n return [], info\\n\\n except XAttrMetadataError as e:\\n if e.reason == 'NO_SPACE':\\n self._downloader.report_warning(\\n 'There\\\\'s no disk space left, disk quota exceeded or filesystem xattr limit exceeded. '\\n + (('Some ' if num_written else '') + 'extended attributes are not written.').capitalize())\\n elif e.reason == 'VALUE_TOO_LONG':\\n self._downloader.report_warning(\\n 'Unable to write extended attributes due to too long values.')\\n else:\\n msg = 'This filesystem doesn\\\\'t support extended attributes. '\\n if compat_os_name == 'nt':\\n msg += 'You need to use NTFS.'\\n else:\\n msg += '(You may have to enable them in your /etc/fstab)'\\n self._downloader.report_error(msg)\\n return [], info\",\n \"def metadataDirectory(self):\\n guid_hash = utils.sha1hash(self.grandparentGuid)\\n return str(Path('Metadata') / 'TV Shows' / guid_hash[0] / f'{guid_hash[1:]}.bundle')\",\n \"def meta_datas(self) -> pulumi.Output[Sequence['outputs.SharedflowMetaData']]:\\n return pulumi.get(self, \\\"meta_datas\\\")\",\n \"def add_metadata(self, metadata: dict) -> None:\",\n \"def test_create_namespaced_image_stream_mapping(self):\\n pass\",\n \"def metadata_factory(url, data=None):\\n response = {\\n 'etag': '',\\n 'checked-url': url,\\n 'content-length': faker.pyint(),\\n 'content-disposition': '',\\n 'content-md5': faker.md5(),\\n 'content-location': '',\\n 'expires': faker.iso8601(),\\n 'final-status-code': 200,\\n 'updated': faker.iso8601(),\\n 'last-modified': faker.iso8601(),\\n 'content-encoding': 'gzip',\\n 'content-type': faker.mime_type()\\n }\\n if data:\\n response.update(data)\\n return json.dumps(response)\",\n \"def export_obs_meta(obs):\\n log = toast.utils.Logger.get()\\n\\n # Construct observation frame and dictionary\\n ob = c3g.G3Frame(c3g.G3FrameType.Observation)\\n obmeta = dict()\\n\\n session = obs.session\\n log.verbose(f\\\"Create observation frame for session {session.name}\\\")\\n\\n ob[\\\"telescope_name\\\"] = c3g.G3String(\\n obs.telescope.focalplane.detector_data.meta[\\\"telescope\\\"]\\n )\\n obmeta[\\\"telescope_name\\\"] = str(\\n obs.telescope.focalplane.detector_data.meta[\\\"telescope\\\"]\\n )\\n ob[\\\"telescope_uid\\\"] = c3g.G3Int(obs.telescope.uid)\\n obmeta[\\\"telescope_uid\\\"] = int(obs.telescope.uid)\\n\\n ob[\\\"observing_session\\\"] = c3g.G3String(session.name)\\n obmeta[\\\"observing_session\\\"] = str(session.name)\\n\\n ob[\\\"observing_session_uid\\\"] = c3g.G3Int(session.uid)\\n obmeta[\\\"observing_session_uid\\\"] = int(session.uid)\\n\\n ob[\\\"observing_session_start\\\"] = t3g.to_g3_time(session.start.timestamp())\\n obmeta[\\\"observing_session_start\\\"] = float(session.start.timestamp())\\n\\n ob[\\\"observing_session_end\\\"] = t3g.to_g3_time(session.end.timestamp())\\n obmeta[\\\"observing_session_end\\\"] = float(session.end.timestamp())\\n\\n site = obs.telescope.site\\n siteclass = toast.utils.object_fullname(site.__class__)\\n ob[\\\"site_name\\\"] = c3g.G3String(site.name)\\n ob[\\\"site_class\\\"] = c3g.G3String(siteclass)\\n ob[\\\"site_uid\\\"] = c3g.G3Int(site.uid)\\n obmeta[\\\"site_name\\\"] = str(site.name)\\n obmeta[\\\"site_class\\\"] = str(siteclass)\\n obmeta[\\\"site_uid\\\"] = int(site.uid)\\n\\n if isinstance(site, toast.instrument.GroundSite):\\n ob[\\\"site_lat_deg\\\"] = c3g.G3Double(site.earthloc.lat.to_value(u.degree))\\n ob[\\\"site_lon_deg\\\"] = c3g.G3Double(site.earthloc.lon.to_value(u.degree))\\n ob[\\\"site_alt_m\\\"] = c3g.G3Double(site.earthloc.height.to_value(u.meter))\\n obmeta[\\\"site_lat_deg\\\"] = float(site.earthloc.lat.to_value(u.degree))\\n obmeta[\\\"site_lon_deg\\\"] = float(site.earthloc.lon.to_value(u.degree))\\n obmeta[\\\"site_alt_m\\\"] = float(site.earthloc.height.to_value(u.meter))\\n\\n if site.weather is not None:\\n if hasattr(site.weather, \\\"name\\\"):\\n # This is a simulated weather object, dump it.\\n ob[\\\"site_weather_name\\\"] = c3g.G3String(site.weather.name)\\n obmeta[\\\"site_weather_name\\\"] = str(site.weather.name)\\n ob[\\\"site_weather_realization\\\"] = c3g.G3Int(site.weather.realization)\\n obmeta[\\\"site_weather_realization\\\"] = int(site.weather.realization)\\n if site.weather.max_pwv is None:\\n ob[\\\"site_weather_max_pwv\\\"] = c3g.G3String(\\\"NONE\\\")\\n obmeta[\\\"site_weather_max_pwv\\\"] = \\\"NONE\\\"\\n else:\\n ob[\\\"site_weather_max_pwv\\\"] = c3g.G3Double(site.weather.max_pwv)\\n obmeta[\\\"site_weather_max_pwv\\\"] = float(site.weather.max_pwv)\\n ob[\\\"site_weather_time\\\"] = t3g.to_g3_time(site.weather.time.timestamp())\\n obmeta[\\\"site_weather_time\\\"] = float(site.weather.time.timestamp())\\n ob[\\\"site_weather_uid\\\"] = c3g.G3Int(site.weather.site_uid)\\n obmeta[\\\"site_weather_uid\\\"] = int(site.weather.site_uid)\\n ob[\\\"site_weather_use_median\\\"] = c3g.G3Bool(site.weather.median_weather)\\n obmeta[\\\"site_weather_use_median\\\"] = bool(site.weather.median_weather)\\n return ob, obmeta\",\n \"def metadata2eic(url):\\n logging.info('fetching image metadata from %s' % url)\\n ds = json.loads(urllib.urlopen(url).read())\\n fields = ['imagename','alt','pitch','roll']\\n for d in ds:\\n yield map(str,[d[k] for k in fields])\",\n \"def get_metadata():\\n\\n module = __name__.split('.', 1)\\n\\n try:\\n pkg = pkg_resources.get_distribution(module[0])\\n except pkg_resources.RequirementParseError:\\n # if called from CLI, try to get pkg from the path\\n distros = list(pkg_resources.find_distributions(cfg.BASE_DIR, \\n only=True))\\n if len(distros) == 1:\\n pkg = distros[0]\\n except Exception as e:\\n raise HTTPBadRequest(reason=e)\\n\\n # deserialize key-word arguments\\n train_args = _fields_to_dict(get_train_args())\\n # make 'type' JSON serializable\\n for key, val in train_args.items():\\n train_args[key]['type'] = str(val['type'])\\n\\n predict_args = _fields_to_dict(get_predict_args())\\n # make 'type' JSON serializable\\n for key, val in predict_args.items():\\n predict_args[key]['type'] = str(val['type'])\\n\\n meta = {\\n 'name' : None,\\n 'version' : None,\\n 'summary' : None,\\n 'home-page' : None,\\n 'author' : None,\\n 'author-email' : None,\\n 'license' : None,\\n 'help-train' : train_args,\\n 'help-predict' : predict_args\\n }\\n for line in pkg.get_metadata_lines(\\\"PKG-INFO\\\"):\\n line_low = line.lower() # to avoid inconsistency due to letter cases\\n for par in meta:\\n if line_low.startswith(par.lower() + \\\":\\\"):\\n _, value = line.split(\\\": \\\", 1)\\n meta[par] = value\\n\\n return meta\",\n \"def write_metadata(file_name, metadata_dict, category='',\\n datatype=\\\"inventory\\\", parameters=None):\\n if (datatype == \\\"inventory\\\") or (datatype == \\\"source\\\"):\\n meta = set_stewi_meta(file_name, stewiformat=category)\\n if datatype == 'inventory':\\n meta.tool_meta = {\\\"parameters\\\": parameters,\\n \\\"sources\\\": metadata_dict}\\n else:\\n meta.tool_meta = metadata_dict\\n write_metadata_to_file(paths, meta)\\n elif datatype == \\\"validation\\\":\\n file = (paths.local_path / 'validation' /\\n f'{file_name}_validationset_metadata.json')\\n with file.open('w') as fi:\\n fi.write(json.dumps(metadata_dict, indent=4))\",\n \"def metadata(self, run_id, data_type):\\n if not data_type in self.provides:\\n raise RuntimeError(f\\\"{data_type} not in {self.provides}?\\\")\\n return dict(\\n run_id=run_id,\\n data_type=data_type,\\n data_kind=self.data_kind_for(data_type),\\n dtype=self.dtype_for(data_type),\\n lineage_hash=strax.DataKey(\\n run_id, data_type, self.lineage).lineage_hash,\\n compressor=self.compressor,\\n lineage=self.lineage)\",\n \"def parse_metadata(self):\\n micro_metadata = {}\\n ext_meta = None\\n self.content_type = 'text/html'\\n if self.source_metadata:\\n #print(self.source_metadata)\\n if len(self.source_metadata)>1:\\n try:\\n for sm in self.source_metadata:\\n if str(sm.get('type').split('/')[-1]).lower() in self.SCHEMA_ORG_CREATIVEWORKS:\\n ext_meta = sm\\n except:\\n pass\\n self.source_name = self.getEnumSourceNames().MICRODATA_EMBEDDED\\n if not ext_meta:\\n ext_meta = self.source_metadata[0]\\n\\n if ext_meta is not None:\\n self.logger.info('FsF-F2-01M : Trying to extract Microdata metadata from -: {}'.format(self.source_name))\\n # TODO check syntax - not ending with /, type and @type\\n # TODO (important) extend mapping to detect other pids (link to related entities)?\\n # TODO replace check_context_type list context comparison by regex\\n check_context_type = ['Dataset', 'Collection']\\n try:\\n #if ext_meta['@context'] in check_context_type['@context'] and ext_meta['@type'] in check_context_type[\\\"@type\\\"]:\\n if str(ext_meta.get('type')).find('schema.org') > -1:\\n micro_metadata = jmespath.search(self.metadata_mapping.value, ext_meta)\\n self.namespaces.append('http://schema.org/')\\n else:\\n self.logger.info('FsF-F2-01M : Failed to parse non schema.org type Microdata')\\n except Exception as err:\\n #print(err.with_traceback())\\n self.logger.info('FsF-F2-01M : Failed to parse Microdata -: {}'.format(err))\\n else:\\n self.logger.info('FsF-F2-01M : Could not identify Microdata metadata')\\n\\n return self.source_name, micro_metadata\",\n \"def metadata():\\n req = prepare_flask_request(request)\\n auth = init_saml_auth(req)\\n settings = auth.get_settings()\\n sp_metadata = settings.get_sp_metadata()\\n errors = settings.validate_metadata(sp_metadata)\\n\\n if len(errors) == 0:\\n resp = make_response(sp_metadata, 200)\\n resp.headers[\\\"Content-Type\\\"] = \\\"text/xml\\\"\\n else:\\n resp = make_response(\\\", \\\".join(errors), 500)\\n return resp\",\n \"def compile_metadata(inventory_dict):\\n inventory_meta = {}\\n #inventory_meta['InventoryDictionary'] = inventory_dict\\n for source, year in inventory_dict.items():\\n inventory_meta[source] = stewi.getMetadata(source, year)\\n return inventory_meta\",\n \"def metadata():\\n req = prepare_onelogin_request(request)\\n saml_auth = init_saml_auth(req)\\n settings = saml_auth.get_settings()\\n metadata = settings.get_sp_metadata()\\n errors = settings.validate_metadata(metadata)\\n\\n if len(errors) == 0:\\n resp = make_response(metadata, 200)\\n resp.headers[\\\"Content-Type\\\"] = \\\"text/xml\\\"\\n else:\\n resp = make_response(\\\", \\\".join(errors), 500)\\n return resp\",\n \"def _WriteStorageMetadata(self):\\n stream_name = 'metadata.txt'\\n if self._HasStream(stream_name):\\n return\\n\\n stream_data = (\\n '[plaso_storage_file]\\\\n'\\n 'format_version: {0:d}\\\\n'\\n 'serialization_format: {1:s}\\\\n'\\n 'storage_type: {2:s}\\\\n'\\n '\\\\n').format(\\n self._FORMAT_VERSION, self.serialization_format, self.storage_type)\\n\\n stream_data = stream_data.encode('utf-8')\\n self._WriteStream(stream_name, stream_data)\",\n \"def get_metadata(self):\\n meta_data = {}\\n if self.beam_energy is not None:\\n meta_data['beam_energy'] = self.beam_energy\\n if self.collection_angle is not None:\\n meta_data['collection_angle'] = self.collection_angle\\n return meta_data\",\n \"def add_file_metadata(self):\\n metadata = self.__file.require_group(METADATA)\\n self.__write_value(metadata, DATE_CREATED, date.today().strftime(\\\"%Y-%m-%d\\\"))\\n self.__write_value(metadata, SDK_VERSION, __version__)\",\n \"def update_metadata(self):\\n parser = GenericParser(\\n fn_re='{}/(e\\\\d+s\\\\d+)_.*/Production.nc'.format(self.data_folder),\\n group_names=['sim'],\\n group_transforms=[lambda x: x],\\n top_fn='',\\n step_ps=self.timestep\\n )\\n meta = gather_metadata('{}/e*/*nc'.format(self.data_folder), parser)\\n meta['top_fn'] = sorted(glob('{}/e*/structure.prmtop'.format(self.input_folder)))\\n self.meta = meta\",\n \"def metadata(self):\\r\\n return resources.Metadata(self)\",\n \"def metadata_create():\\n binding = {}\\n url = 'https://upload.twitter.com/1.1/media/metadata/create.json'\\n return _TwitterRequest('POST',\\n url,\\n 'rest:media',\\n 'post-media-metadata-create',\\n binding)\",\n \"def GetMetadataSample():\\n client = CreateClient()\\n # Fetch the metadata entry and display bits of it\\n metadata = client.GetMetadata()\\n print 'Quota'\\n print ' Total:', metadata.quota_bytes_total.text\\n print ' Used:', metadata.quota_bytes_used.text\\n print ' Trashed:', metadata.quota_bytes_used_in_trash.text\\n print 'Import / Export'\\n for input_format in metadata.import_formats:\\n print ' Import:', input_format.source, 'to', input_format.target\\n for export_format in metadata.export_formats:\\n print ' Export:', export_format.source, 'to', export_format.target\\n print 'Features'\\n for feature in metadata.features:\\n print ' Feature:', feature.name.text\\n print 'Upload Sizes'\\n for upload_size in metadata.max_upload_sizes:\\n print ' Kind:', upload_size.kind, upload_size.text\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.671694","0.60573244","0.57544136","0.5661377","0.56448686","0.5619563","0.5588338","0.55070674","0.5504906","0.5472223","0.5432367","0.54051733","0.5370304","0.53210187","0.53012925","0.5292331","0.5278983","0.52679557","0.5261438","0.52601606","0.5242331","0.52194655","0.52119493","0.516849","0.51597166","0.5148105","0.51383686","0.5132087","0.5126436","0.51115227","0.51045954","0.5093269","0.50914496","0.5087948","0.50869405","0.50863206","0.5073958","0.50656587","0.50415456","0.5041026","0.50363326","0.5029766","0.50242245","0.5016077","0.5011257","0.5006757","0.50052434","0.5002387","0.49979365","0.49946752","0.49946752","0.4990498","0.4979929","0.49713597","0.49664435","0.49636236","0.4963113","0.49607965","0.4959372","0.4958203","0.49567053","0.49465436","0.49399972","0.4929312","0.49233967","0.4922452","0.49173218","0.49164727","0.49148953","0.49025765","0.48944423","0.48927954","0.48784813","0.48760825","0.4872665","0.48680475","0.48644748","0.48630184","0.48595956","0.4851594","0.48511007","0.48497015","0.48398453","0.4838764","0.48304728","0.4827163","0.48257187","0.48127985","0.48111787","0.48094985","0.48062447","0.4805144","0.48047718","0.48025468","0.47989404","0.47971398","0.47936493","0.47930896","0.47911724","0.47807643"],"string":"[\n \"0.671694\",\n \"0.60573244\",\n \"0.57544136\",\n \"0.5661377\",\n \"0.56448686\",\n \"0.5619563\",\n \"0.5588338\",\n \"0.55070674\",\n \"0.5504906\",\n \"0.5472223\",\n \"0.5432367\",\n \"0.54051733\",\n \"0.5370304\",\n \"0.53210187\",\n \"0.53012925\",\n \"0.5292331\",\n \"0.5278983\",\n \"0.52679557\",\n \"0.5261438\",\n \"0.52601606\",\n \"0.5242331\",\n \"0.52194655\",\n \"0.52119493\",\n \"0.516849\",\n \"0.51597166\",\n \"0.5148105\",\n \"0.51383686\",\n \"0.5132087\",\n \"0.5126436\",\n \"0.51115227\",\n \"0.51045954\",\n \"0.5093269\",\n \"0.50914496\",\n \"0.5087948\",\n \"0.50869405\",\n \"0.50863206\",\n \"0.5073958\",\n \"0.50656587\",\n \"0.50415456\",\n \"0.5041026\",\n \"0.50363326\",\n \"0.5029766\",\n \"0.50242245\",\n \"0.5016077\",\n \"0.5011257\",\n \"0.5006757\",\n \"0.50052434\",\n \"0.5002387\",\n \"0.49979365\",\n \"0.49946752\",\n \"0.49946752\",\n \"0.4990498\",\n \"0.4979929\",\n \"0.49713597\",\n \"0.49664435\",\n \"0.49636236\",\n \"0.4963113\",\n \"0.49607965\",\n \"0.4959372\",\n \"0.4958203\",\n \"0.49567053\",\n \"0.49465436\",\n \"0.49399972\",\n \"0.4929312\",\n \"0.49233967\",\n \"0.4922452\",\n \"0.49173218\",\n \"0.49164727\",\n \"0.49148953\",\n \"0.49025765\",\n \"0.48944423\",\n \"0.48927954\",\n \"0.48784813\",\n \"0.48760825\",\n \"0.4872665\",\n \"0.48680475\",\n \"0.48644748\",\n \"0.48630184\",\n \"0.48595956\",\n \"0.4851594\",\n \"0.48511007\",\n \"0.48497015\",\n \"0.48398453\",\n \"0.4838764\",\n \"0.48304728\",\n \"0.4827163\",\n \"0.48257187\",\n \"0.48127985\",\n \"0.48111787\",\n \"0.48094985\",\n \"0.48062447\",\n \"0.4805144\",\n \"0.48047718\",\n \"0.48025468\",\n \"0.47989404\",\n \"0.47971398\",\n \"0.47936493\",\n \"0.47930896\",\n \"0.47911724\",\n \"0.47807643\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.607395"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":83160,"cells":{"query":{"kind":"string","value":"updates metadata for a specific qa_group"},"document":{"kind":"string","value":"def metadata_update_qa_group(qa_group):\n\n # explicit\n if qa_group:\n filename = 'firmware-%s.xml.gz' % _qa_hash(qa_group)\n _generate_metadata_kind(filename, qa_group=qa_group)\n return [os.path.join(DOWNLOAD_DIR, filename)]\n\n # do for all\n db = LvfsDatabase(os.environ)\n db_firmware = LvfsDatabaseFirmware(db)\n qa_groups = db_firmware.get_qa_groups()\n filenames = []\n for qa_group in qa_groups:\n filename_qa = 'firmware-%s.xml.gz' % _qa_hash(qa_group)\n filename = _generate_metadata_kind(filename_qa, qa_group=qa_group)\n filenames.append(filename)\n\n # return all the files we have to sign\n return filenames"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _metadata_update_group(group_id):\n\n # get all firmwares in this group\n firmwares = db.firmware.get_all()\n firmwares_filtered = []\n for f in firmwares:\n if f.target == 'private':\n continue\n if f.group_id != group_id:\n continue\n firmwares_filtered.append(f)\n\n # create metadata file for the embargoed firmware\n affidavit = _create_affidavit()\n filename = 'firmware-%s.xml.gz' % _qa_hash(group_id)\n _generate_metadata_kind(filename,\n firmwares_filtered,\n affidavit=affidavit)","def update_group(groupname):\n name = request.get_json().get(\"name\", None)\n description = request.get_json().get(\"description\", None)\n response = jsonify(\n admin.update_group(current_app.scoped_session(), groupname, description, name)\n )\n return response","def group_update(*, login_manager: LoginManager, group_id: str, **kwargs: Any):\n groups_client = login_manager.get_groups_client()\n\n # get the current state of the group\n group = groups_client.get_group(group_id)\n\n # assemble put data using existing values for any field not given\n # note that the API does not accept the full group document, so we must\n # specify name and description instead of just iterating kwargs\n data = {}\n for field in [\"name\", \"description\"]:\n if kwargs.get(field) is not None:\n data[field] = kwargs[field]\n else:\n data[field] = group[field]\n\n response = groups_client.update_group(group_id, data)\n\n formatted_print(response, simple_text=\"Group updated successfully\")","def test_update_group(self):\n pass","def updateDataQuality(idMeta, Quality):\n # XXX add for diaries\n sqlq = \"UPDATE Meta \\\n SET `Quality`= %s \\\n WHERE `idMeta` = %s;\" % (Quality, idMeta)\n mdb.executeSQL(sqlq)\n mdb.commit()","def update_group():\n _id = request.form['_id']\n name = request.form['name']\n data, code, message = FIELD_SERVICE.update_group(_id, name)\n return __result(data, code, message)","def do_group_update():\n target_group = Group.query.filter_by(id=request.form['id']).first()\n if target_group is None:\n return group_list(\"Unknown group.\")\n\n target_group.name = request.form['name']\n target_group.group_meter_id = request.form['meter']\n target_group.group_production_meter_id_first = request.form['group_production_meter_id_first']\n target_group.group_production_meter_id_second = request.form[\n 'group_production_meter_id_second']\n\n db.session.commit()\n return group_list(\"Updated group \" + target_group.name)","def test_modify_group(self):\n response = self.client.modify_group(\"ABC123\")\n self.assertEqual(response[\"method\"], \"POST\")\n self.assertEqual(response[\"uri\"], \"/admin/v1/groups/ABC123\")\n self.assertEqual(util.params_to_dict(response[\"body\"]), {\"account_id\": [self.client.account_id]})","def update(self):\r\n return self.connection._update_group('UpdateAutoScalingGroup', self)","def update(self,\n provider_id,\n group_id,\n group,\n ):\n return self._invoke('update',\n {\n 'provider_id': provider_id,\n 'group_id': group_id,\n 'group': group,\n })","def update_group(self, group_id, **kwargs):\n post_body = json.dumps({'group': kwargs})\n resp, body = self.patch('groups/%s' % group_id, post_body)\n self.expected_success(200, resp.status)\n body = json.loads(body)\n return rest_client.ResponseBody(resp, body)","def update_group(self, group_id, new_description):\n url = self.groups_url + \"/\" + group_id\n new_data = json.dumps({\"description\": new_description})\n\n return requests.put(url, new_data, headers=self.headers)","def update_metadata(self, key, value):\n sp.verify(self.is_administrator(sp.sender), FA12_Error.NotAdmin)\n self.data.metadata[key] = value","def update(self, consistencygroup, **kwargs):\n if not kwargs:\n return\n\n body = {\"consistencygroup\": kwargs}\n\n return self._update(\"/consistencygroups/%s\" %\n base.getid(consistencygroup), body)","def customer_group_put(group_info):\n related_groups = customer_group_get_related(group_info[\"group_id\"])\n\n now = datetime.datetime.now()\n f = '%Y-%m-%d %H:%M:%S'\n insert_time = now.strftime(f)\n\n result = {\"success\" : 1, \"message\" : \"Customer Company can not be Updated\"}\n\n for groups in related_groups:\n c_group_info = list(groups)\n #check for the roles\n c_g_id = c_group_info[0]\n c_g_role = c_group_info[1].split(\"(\")[1][:-1]\n c_g_name = c_group_info[1].split(\"(\")[0]\n new_c_g_name = group_info[\"group_name\"] + \"(\"+ c_g_role +\")\"\n db_conn = DB_Conn()\n db = db_conn.db_connect()\n cursor = db.cursor()\n query = \"\"\"\n UPDATE `groups`\n SET\n `group_name` = \"%s\",\n `company_name` = \"%s\",\n `company_address` = \"%s\",\n `company_telephone` = \"%s\",\n `company_fax` = \"%s\",\n `company_website` = \"%s\",\n `company_sales_contact` = \"%s\",\n `company_purchase_contact` = \"%s\",\n `company_business` = \"%s\",\n `company_business_type` = \"%s\",\n `company_sales_email` = \"%s\",\n `company_purchase_email` = \"%s\",\n `company_reg_number` = \"%s\",\n `company_vat_number` = \"%s\",\n `description` = \"%s\"\n WHERE\n `group_id` = \"%s\"\n \"\"\" %(\n new_c_g_name, \n group_info[\"company_name\"],\n group_info[\"company_address\"],\n group_info[\"company_telephone\"],\n group_info[\"company_fax\"],\n group_info[\"company_website\"],\n group_info[\"company_sales_contact\"],\n group_info[\"company_purchase_contact\"],\n group_info[\"company_business\"],\n group_info[\"company_business_type\"],\n group_info[\"company_sales_email\"],\n group_info[\"company_purchase_email\"],\n group_info[\"company_reg_number\"],\n group_info[\"company_vat_number\"],\n group_info[\"description\"],\n c_g_id\n )\n try:\n if cursor.execute(query):\n db.commit()\n result = {\"success\" : 0, \"message\" : \"Customer Company Updated Successfully\"}\n except Exception as e:\n result = {\"success\" : 1, \"message\" : \"Customer Company can not be Updated. Error \\\"\\'%s\\'\\\" \\\n Query = %s\" % (e, query) }\n finally:\n cursor.close()\n db.close()\n return result","def update_targetgroup(self, group_id, **kwargs):\r\n result = False\r\n if self._db(self._db.targetgroup.id==group_id).select():\r\n result = True\r\n self._db(self._db.targetgroup.id==group_id).update(**kwargs)\r\n self._db.commit()\r\n return result","async def update_contact_group(dbcon: DBConnection, contact_group_id: int, data: Dict[str, str]) -> None:\n\n async def _run(cur: Cursor) -> None:\n for key, value in data.items():\n if key not in ['name', 'active']:\n raise errors.IrisettError('invalid contact key %s' % key)\n q = \"\"\"update contact_groups set %s=%%s where id=%%s\"\"\" % key\n q_args = (value, contact_group_id)\n await cur.execute(q, q_args)\n\n if not await contact_group_exists(dbcon, contact_group_id):\n raise errors.InvalidArguments('contact group does not exist')\n await dbcon.transact(_run)","def update_metadata(\n self, expectation_suite: es.ExpectationSuite\n ) -> es.ExpectationSuite:\n _client = client.get_instance()\n path_params = [\n \"project\",\n _client._project_id,\n \"featurestores\",\n self._feature_store_id,\n \"featuregroups\",\n self._feature_group_id,\n \"expectationsuite\",\n expectation_suite.id,\n \"metadata\",\n ]\n\n headers = {\"content-type\": \"application/json\"}\n payload = expectation_suite.json()\n\n major, minor = self._variable_api.parse_major_and_minor(\n self._variable_api.get_version(\"hopsworks\")\n )\n method = \"PUT\"\n if major == \"3\" and minor == \"0\":\n method = \"POST\"\n del path_params[-1]\n del path_params[-1]\n\n return es.ExpectationSuite.from_response_json(\n _client._send_request(method, path_params, headers=headers, data=payload)\n )","def test_update_resource_group(self):\n pass","def test_update_metadata_by_attribute(self):\n pass","def test_update_metadata_by_attribute1(self):\n pass","def _do_update(self, meta, k, v):\n self.runtime.logger.info('{}: [{}] -> {}'.format(meta.in_group_config_path, k, v))\n meta.config[k] = v\n meta.save()","def update_group(self, group_name, new_group_name=None, new_path=None):\r\n params = {'GroupName' : group_name}\r\n if new_group_name:\r\n params['NewGroupName'] = new_group_name\r\n if new_path:\r\n params['NewPath'] = new_path\r\n return self.get_response('UpdateGroup', params)","def update_meta(self, db_name, collection_name, is_finished):\n import time\n from ir_config import IRConfig\n meta_collection = self.__get_meta_collection(db_name)\n res = self.__find_collection_in_meta(db_name, collection_name)\n if res.count() > 0:\n meta_collection.update({self.__meta_key_name : collection_name},\n {'$set' : {self.__meta_lastmodified_name : int(time.time()),\n self.__meta_success_name : is_finished}}) \n else:\n meta_collection.insert({self.__meta_key_name : collection_name,\n self.__meta_lastmodified_name : int(time.time()),\n self.__meta_success_name : is_finished})","def set_group(self, data, group, intg, dq=None):\n # TODO: Include a 2-D DQ array to be combined with the GROUPDQ array\n #\n # Copy the input data to a 2-D plane for this group/intg combination.\n # NOTE: This only works if data array is broadcastable so the shape\n # of the data array is checked.\n #\n data = np.asarray(data, dtype=self.data.dtype)\n detector_shape = (self.rows, self.columns)\n if data.shape == detector_shape:\n self.data[intg, group, :, :] = data \n # Invalidate the averaged data\n self._data_averaged = None\n # Update the group data quality array if necessary.\n if dq is not None:\n if self.include_groupdq:\n dq = np.asarray(dq, dtype=self.groupdq.dtype) # Convert to same data type.\n self.groupdq[intg, group, :, :] |= dq\n else:\n strg = \"Incompatible arguments. A groupdq array is \"\n strg += \"provided when include_groupdq=False. \"\n strg += \"The array is ignored.\"\n LOGGER.error(strg)\n else:\n strg = \"Group data array has the wrong shape \"\n strg += \"(%s instead of %s).\" % (str(data.shape),\n str(detector_shape))\n raise TypeError(strg)","def update_research_group(self, employee_id, new_research_group):\n cursor = self.dbconnect.get_cursor()\n try:\n cursor.execute('UPDATE employee '\n 'SET research_group = %s '\n 'WHERE id=%s;',\n (new_research_group, employee_id))\n self.dbconnect.commit()\n except:\n self.dbconnect.rollback()\n raise","def update(ctx, name, description, tags):\n user, project_name, _group = get_project_group_or_local(ctx.obj.get('project'),\n ctx.obj.get('group'))\n update_dict = {}\n\n if name:\n update_dict['name'] = name\n\n if description:\n update_dict['description'] = description\n\n tags = validate_tags(tags)\n if tags:\n update_dict['tags'] = tags\n\n if not update_dict:\n Printer.print_warning('No argument was provided to update the experiment group.')\n sys.exit(0)\n\n try:\n response = PolyaxonClient().experiment_group.update_experiment_group(\n user, project_name, _group, update_dict)\n except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:\n Printer.print_error('Could not update experiment group `{}`.'.format(_group))\n Printer.print_error('Error message `{}`.'.format(e))\n sys.exit(1)\n\n Printer.print_success(\"Experiment group updated.\")\n get_group_details(response)","def put(self):\n status = ErrorCode.SUCCESS\n try:\n data = DotDict(json_decode(self.request.body))\n cid = self.current_user.cid\n tid = self.current_user.tid\n gid = data.gid\n name = data.name\n logging.info(\"[UWEB] Modify group request: %s, cid: %s\",\n data, self.current_user.cid)\n except Exception as e:\n status = ErrorCode.ILLEGAL_DATA_FORMAT\n logging.exception(\"[UWEB] Invalid data format. body:%s, Exception: %s\",\n self.request.body, e.args)\n self.write_ret(status)\n return\n\n try: \n group = self.get_group_by_cid(cid, name)\n if group:\n status = ErrorCode.GROUP_EXIST\n self.write_ret(status)\n return\n\n self.db.execute(\"UPDATE T_GROUP\"\n \" SET name = %s\"\n \" WHERE id = %s\",\n name, gid)\n\n # NOTE: wspush to client \n if status == ErrorCode.SUCCESS:\n WSPushHelper.pushS3(tid, self.db, self.redis)\n\n self.write_ret(status)\n except Exception as e:\n logging.exception(\"[UWEB] Modify group failed. cid: %s, Exception: %s\",\n self.current_user.cid, e.args)\n status = ErrorCode.SERVER_BUSY\n self.write_ret(status)","def test_update_metadata1(self):\n pass","def request_group_update():\n target_group = Group.query.filter_by(id=request.args['id']).first()\n if target_group is None:\n return group_list(\"Unknown group.\")\n\n return Response(\n render_template(\n 'admin/group/create-update.html',\n csrf_token=(\n get_raw_jwt() or {}).get(\"csrf\"),\n target=\"/admin/group/update\",\n id=target_group.id,\n name=target_group.name,\n meter=target_group.group_meter_id,\n group_production_meter_id_first=target_group.group_production_meter_id_first,\n group_production_meter_id_second=target_group.group_production_meter_id_second),\n mimetype='text/html')","def test_update_metadata(self):\n pass","def set(self, name_group, key, value):\n self.psettings.beginGroup(name_group)\n self.psettings.setValue(key, value)\n self.closeGroup()","def update_group_with_http_info(self, bucket_id, group_id, group, **kwargs):\n\n all_params = ['bucket_id', 'group_id', 'group', 'if_match', 'if_none_match', 'fields']\n all_params.append('callback')\n all_params.append('_return_http_data_only')\n all_params.append('_preload_content')\n all_params.append('_request_timeout')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method update_group\" % key\n )\n params[key] = val\n del params['kwargs']\n # verify the required parameter 'bucket_id' is set\n if ('bucket_id' not in params) or (params['bucket_id'] is None):\n raise ValueError(\"Missing the required parameter `bucket_id` when calling `update_group`\")\n # verify the required parameter 'group_id' is set\n if ('group_id' not in params) or (params['group_id'] is None):\n raise ValueError(\"Missing the required parameter `group_id` when calling `update_group`\")\n # verify the required parameter 'group' is set\n if ('group' not in params) or (params['group'] is None):\n raise ValueError(\"Missing the required parameter `group` when calling `update_group`\")\n\n if 'if_match' in params and not re.search('\\\\\\\"[0-9]+\\\\\\\"', params['if_match']):\n raise ValueError(\"Invalid value for parameter `if_match` when calling `update_group`, must conform to the pattern `/\\\\\\\"[0-9]+\\\\\\\"/`\")\n if 'if_none_match' in params and not re.search('\\\\\\\"[0-9]+\\\\\\\"', params['if_none_match']):\n raise ValueError(\"Invalid value for parameter `if_none_match` when calling `update_group`, must conform to the pattern `/\\\\\\\"[0-9]+\\\\\\\"/`\")\n\n collection_formats = {}\n\n resource_path = '/buckets/{bucket_id}/groups/{group_id}'.replace('{format}', 'json')\n path_params = {}\n if 'bucket_id' in params:\n path_params['bucket_id'] = params['bucket_id']\n if 'group_id' in params:\n path_params['group_id'] = params['group_id']\n\n query_params = {}\n if 'fields' in params:\n query_params['_fields'] = params['fields']\n collection_formats['_fields'] = 'csv'\n\n header_params = {}\n if 'if_match' in params:\n header_params['If-Match'] = params['if_match']\n if 'if_none_match' in params:\n header_params['If-None-Match'] = params['if_none_match']\n\n form_params = []\n local_var_files = {}\n\n body_params = None\n if 'group' in params:\n body_params = params['group']\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = ['basicAuth']\n\n return self.api_client.call_api(resource_path, 'PUT',\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=local_var_files,\n response_type='Group',\n auth_settings=auth_settings,\n callback=params.get('callback'),\n _return_http_data_only=params.get('_return_http_data_only'),\n _preload_content=params.get('_preload_content', True),\n _request_timeout=params.get('_request_timeout'),\n collection_formats=collection_formats)","def test_update_device_group_by_id(self):\n pass","def update_metadata(self):\n self.data[\"keywords\"] = self.repo.topics(self.data.get(\"keywords\", []))\n self.data[\"description\"] = self.data.get(\"description\") or self.repo.description\n self.data[\"codeRepository\"] = (\n self.data.get(\"codeRepository\") or self.repo.html_url\n )\n self.data[\"name\"] = self.data.get(\"name\") or self.repo.name\n self.data[\"issueTracker\"] = (\n self.data.get(\"issueTracker\") or self.repo.issues_url\n )\n self.data[\"license\"] = self.data.get(\"license\") or self.repo.license","def test_update_device_group_by_id1(self):\n pass","def update(self, group_snapshot, **kwargs):\n if not kwargs:\n return\n\n body = {\"group_snapshot\": kwargs}\n\n return self._update(\"/group_snapshots/%s\" % base.getid(group_snapshot),\n body)","def metadata(\n client: Client,\n modify: bool,\n library: str,\n editor: str,\n group: bool,\n update: bool,\n):\n if modify and not library:\n raise RuntimeError(\"--modify flag requires --library argument\")\n\n if update:\n print(\"Updating library... \")\n client.update()\n print(\"Library update complete.\")\n\n database = EditableDatabase(client.library.albums)\n if not modify:\n database.print_genres(group=True)\n if modify:\n modified = database.edit_genres(Path(library), editor, group)\n print(f\"\\nUpdated {modified} albums.\")","def tests_ti_document_update(self, request: FixtureRequest):\n super().group_update(request)","def test_update_entry_groups(self):\r\n # This method utilises the PUT request method and will make changes to the Canvas instance. This needs consideration.\r\n pass","def update_pkg_metadata(self, pkg, version=None, **kwargs):\n pass","def ModifyGroup(self, group, reason=None, **kwargs):\n query = []\n _AppendReason(query, reason)\n\n return self._SendRequest(HTTP_PUT,\n (\"/%s/groups/%s/modify\" %\n (GANETI_RAPI_VERSION, group)), query, kwargs)","def test_update_topic_groups(self):\r\n # This method utilises the PUT request method and will make changes to the Canvas instance. This needs consideration.\r\n pass","def test_partially_update_device_group_by_id(self):\n pass","def get_group_metadata(self):\n # Implemented from template for osid.resource.ResourceForm.get_group_metadata_template\n metadata = dict(self._group_metadata)\n metadata.update({'existing_group_values': self._my_map['group']})\n return Metadata(**metadata)","def persist_test_group(self, obj: object, group: str) -> str:","def update_adcampaign_group(self, campaign_group_id, name=None,\n campaign_group_status=None, objective=None,\n batch=False):\n path = '%s' % campaign_group_id\n args = {}\n if name is not None:\n args['name'] = name\n if campaign_group_status is not None:\n args['campaign_group_status'] = campaign_group_status\n if objective is not None:\n args['objective'] = objective\n return self.make_request(path, 'POST', args, batch=batch)","def update_metadata(self, item, feat_part, drop_feat):\n # In all cases, update the artist fields.\n self._log.info('artist: {0} -> {1}', item.artist, item.albumartist)\n item.artist = item.albumartist\n if item.artist_sort:\n # Just strip the featured artist from the sort name.\n item.artist_sort, _ = split_on_feat(item.artist_sort)\n\n # Only update the title if it does not already contain a featured\n # artist and if we do not drop featuring information.\n if not drop_feat and not contains_feat(item.title):\n feat_format = self.config['format'].as_str()\n new_format = feat_format.format(feat_part)\n new_title = f\"{item.title} {new_format}\"\n self._log.info('title: {0} -> {1}', item.title, new_title)\n item.title = new_title","def test_partially_update_device_group_by_id1(self):\n pass","def test_update_collection_metadata(self):\n c1 = self.hiarc_collections.create_collection(\n self.hiarc_util.create_collection(self.hiarc_util.get_test_metadata()))\n upmd = {\n \"department\": \"support\",\n \"quotaCarrying\": False,\n \"targetRate\": 7.271,\n \"level\": 2,\n \"startDate\": dateutil.parser.parse(\"2020-02-25T22:33:50.134Z\")\n }\n uc = hiarc.UpdateCollectionRequest(metadata=upmd)\n updated = self.hiarc_collections.update_collection(uc, c1.key)\n updated.metadata['startDate'] = dateutil.parser.parse(\n updated.metadata['startDate'])\n self.assertDictEqual(upmd, updated.metadata)","def group(self, group):\n self._group = group","def capacitygroup_update(cmd_ctx, cpc, capacitygroup, **options):\n cmd_ctx.execute_cmd(\n lambda: cmd_capacitygroup_update(cmd_ctx, cpc, capacitygroup, options))","def fusion_api_update_from_group(self, uri, api=None, headers=None):\n param = '/compliance'\n return self.li.update(body=None, uri=uri, api=api, headers=headers, param=param)","def set_group(self, address, group):\n self.groups[address] = group","def update_metadata(self):\n parser = GenericParser(\n fn_re='{}/(e\\d+s\\d+)_.*/Production.nc'.format(self.data_folder),\n group_names=['sim'],\n group_transforms=[lambda x: x],\n top_fn='',\n step_ps=self.timestep\n )\n meta = gather_metadata('{}/e*/*nc'.format(self.data_folder), parser)\n meta['top_fn'] = sorted(glob('{}/e*/structure.prmtop'.format(self.input_folder)))\n self.meta = meta","def update(self, *args, **kwargs): \n kwargs[\"sampleID\"] = self.__sampleID\n kwargs[\"sampleMetaID\"] = self.id()\n self._eLABJournalObject__api.update_sample_meta(*list(args), **dict(kwargs))\n rp = self._eLABJournalObject__api._request(\"/api/v1/samples/\"+urllib.parse.quote(str(kwargs[\"sampleID\"]))+\"/meta/\"+urllib.parse.quote(str(kwargs[\"sampleMetaID\"])), \"get\", {})\n #check and get\n if (rp is not None) & (type(rp) == dict):\n self.__init__(self._eLABJournalObject__api,kwargs[\"sampleID\"],rp) \n else:\n print(dict)\n raise Exception(\"couldn't perform selfupdate\")","def update(self, id, xmlData = NotImplemented, version = NotImplemented):\n\n kparams = KalturaParams()\n kparams.addIntIfDefined(\"id\", id);\n kparams.addStringIfDefined(\"xmlData\", xmlData)\n kparams.addIntIfDefined(\"version\", version);\n self.client.queueServiceActionCall(\"metadata_metadata\", \"update\", \"KalturaMetadata\", kparams)\n if self.client.isMultiRequest():\n return self.client.getMultiRequestResult()\n resultNode = self.client.doQueue()\n return KalturaObjectFactory.create(resultNode, 'KalturaMetadata')","def patch_group_with_http_info(self, bucket_id, group_id, group, **kwargs):\n\n all_params = ['bucket_id', 'group_id', 'group', 'if_match', 'if_none_match', 'fields']\n all_params.append('callback')\n all_params.append('_return_http_data_only')\n all_params.append('_preload_content')\n all_params.append('_request_timeout')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method patch_group\" % key\n )\n params[key] = val\n del params['kwargs']\n # verify the required parameter 'bucket_id' is set\n if ('bucket_id' not in params) or (params['bucket_id'] is None):\n raise ValueError(\"Missing the required parameter `bucket_id` when calling `patch_group`\")\n # verify the required parameter 'group_id' is set\n if ('group_id' not in params) or (params['group_id'] is None):\n raise ValueError(\"Missing the required parameter `group_id` when calling `patch_group`\")\n # verify the required parameter 'group' is set\n if ('group' not in params) or (params['group'] is None):\n raise ValueError(\"Missing the required parameter `group` when calling `patch_group`\")\n\n if 'if_match' in params and not re.search('\\\\\\\"[0-9]+\\\\\\\"', params['if_match']):\n raise ValueError(\"Invalid value for parameter `if_match` when calling `patch_group`, must conform to the pattern `/\\\\\\\"[0-9]+\\\\\\\"/`\")\n if 'if_none_match' in params and not re.search('\\\\\\\"[0-9]+\\\\\\\"', params['if_none_match']):\n raise ValueError(\"Invalid value for parameter `if_none_match` when calling `patch_group`, must conform to the pattern `/\\\\\\\"[0-9]+\\\\\\\"/`\")\n\n collection_formats = {}\n\n resource_path = '/buckets/{bucket_id}/groups/{group_id}'.replace('{format}', 'json')\n path_params = {}\n if 'bucket_id' in params:\n path_params['bucket_id'] = params['bucket_id']\n if 'group_id' in params:\n path_params['group_id'] = params['group_id']\n\n query_params = {}\n if 'fields' in params:\n query_params['_fields'] = params['fields']\n collection_formats['_fields'] = 'csv'\n\n header_params = {}\n if 'if_match' in params:\n header_params['If-Match'] = params['if_match']\n if 'if_none_match' in params:\n header_params['If-None-Match'] = params['if_none_match']\n\n form_params = []\n local_var_files = {}\n\n body_params = None\n if 'group' in params:\n body_params = params['group']\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json', 'application/merge-patch+json', 'application/json-patch+json'])\n\n # Authentication setting\n auth_settings = ['basicAuth']\n\n return self.api_client.call_api(resource_path, 'PATCH',\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=local_var_files,\n response_type='Group',\n auth_settings=auth_settings,\n callback=params.get('callback'),\n _return_http_data_only=params.get('_return_http_data_only'),\n _preload_content=params.get('_preload_content', True),\n _request_timeout=params.get('_request_timeout'),\n collection_formats=collection_formats)","def metadata_update(self, _):\n self.details.original_widget = YesNoWidget('Update metadata files?', self.__metadata_update)","def group(self, group):\n\n self._group = group","def group(self, group):\n\n self._group = group","def group(self, group):\n\n self._group = group","def _update_to_group(group, rrsets):\n #logging.debug('parsing DNS UPDATE:\\n\\n\\%s' % rrsets)\n for rrset in rrsets:\n for record in rrset:\n record.rdclass %= dns.rdataclass.UNIQUE #remove cache-flush bit\n\n if record.rdtype not in [dns.rdatatype.PTR, dns.rdatatype.A, dns.rdatatype.AAAA, dns.rdatatype.TXT, dns.rdatatype.SRV]:\n logging.warning('Invalid DNS RR type (%s), not adding mDNS record to Avahi' % record.rdtype)\n continue\n\n if record.rdclass != dns.rdataclass.IN:\n logging.warning('Invalid DNS RR class (%s), not adding mDNS record to Avahi' % record.rdclass)\n continue\n\n #if (record.rdtype == dns.rdatatype.PTR and ':' in record.to_digestable()) or record.rdtype == dns.rdatatype.AAAA:\n # continue #ignore IPV6 for now, can't sniff those connections\n\n try:\n group.AddRecord( #http://avahi.sourcearchive.com/documentation/0.6.30-5/avahi-client_2publish_8h_a849f3042580d6c8534cba820644517ac.html#a849f3042580d6c8534cba820644517ac\n IF_UNSPEC, # iface *\n PROTO_UNSPEC, # proto _INET & _INET6\n dbus.UInt32(256), # AvahiPublishFlags (use multicast)\n str(rrset.name).decode('utf-8'), #name\n dbus.UInt16(record.rdclass), #class\n dbus.UInt16(record.rdtype), #type\n dbus.UInt32(rrset.ttl), #ttl\n string_array_to_txt_array([record.to_digestable()])[0] #rdata\n )\n logging.info('added mDNS record to Avahi: %s' % rrset.to_text())\n except UnicodeDecodeError:\n logging.warn('malformed unicode in rdata, skipping: %s' % rrset.to_text())\n except dbus.exceptions.DBusException, e:\n if e.get_dbus_name() == 'org.freedesktop.Avahi.InvalidDomainNameError':\n logging.warning('not mirroring mDNS record with special chars: %s' % rrset.to_text())\n continue # skip this record since Avahi will reject it\n # mac probably sent a device_info PTR with spaces and parentheses in the friendly description\n # per https://tools.ietf.org/html/rfc6763#section-4.1.3\n # fanboy\\032\\(2\\)._eppc._tcp.local. 4500 CLASS32769 TXT \"\" # `fanboy (2)`\n # mDNS.c sends UTF8, dnspythom.from_wire() assumes ASCII, DBUS wants Unicode, Avahi only takes [a-zA-Z0-9.-]\n # http://dbus.freedesktop.org/doc/dbus-python/api/dbus.String-class.html\n # http://dbus.freedesktop.org/doc/dbus-python/api/dbus.UTF8String-class.html\n # http://www.avahi.org/ticket/21 http://avahi.org/ticket/63\n # http://git.0pointer.net/avahi.git/commit/?id=5c22acadcbe5b01d910d75b71e86e06a425172d3\n # http://git.0pointer.net/avahi.git/commit/?id=ee2820a23c6968bbeadbdf510389301dca6bc765\n # http://git.0pointer.net/avahi.git/tree/avahi-common/domain.c\n raise","def update_adgroup(self, adgroup_id, name=None, adgroup_status=None,\n bid_type=None, bid_info=None, creative_id=None,\n tracking_specs=None, view_tags=None, objective=None,\n targeting=None, conversion_specs=None,\n batch=False):\n path = \"%s\" % adgroup_id\n args = {}\n if name:\n args['name'] = name\n if bid_type:\n args['bid_type'] = bid_type\n if bid_info:\n args['bid_info'] = json.dumps(bid_info)\n\n if creative_id:\n args['creative'] = json.dumps({'creative_id': creative_id})\n if tracking_specs:\n args['tracking_specs'] = json.dumps(tracking_specs)\n if view_tags:\n args['view_tags'] = json.dumps(view_tags)\n if objective:\n args['objective'] = objective\n if adgroup_status:\n args['adgroup_status'] = adgroup_status\n if targeting:\n args['targeting'] = json.dumps(targeting)\n if conversion_specs:\n args['conversion_specs'] = json.dumps(conversion_specs)\n return self.make_request(path, 'POST', args, batch=batch)","def regroup(self, serial, group):\n api_page = \"/configuration/object/ap_regroup\"\n url = \"{}{}?{}&UIDARUBA={}\".format(\n self.base_url,\n api_page,\n self.config_path,\n self.uidaruba)\n\n obj_dict = {'serial-num': serial, 'new-group': group}\n obj_json = json.loads(json.dumps(obj_dict))\n\n resp = self.post(url, obj_json)\n\n print(resp.status_code)\n print(resp.text)","def qos_policy_group_rename(self, policy_group_name, new_name):\n return self.request( \"qos-policy-group-rename\", {\n 'policy_group_name': [ policy_group_name, 'policy-group-name', [ basestring, 'None' ], False ],\n 'new_name': [ new_name, 'new-name', [ basestring, 'None' ], False ],\n }, {\n } )","def slotGroupEdit(self):\n dialog = GroupDialog(self)\n if dialog.exec_loop() == QDialog.Accepted:\n if dialog.group_id != None:\n # set group\n self.sampleGroup.globalGroupId = dialog.group_id\n self.groupLabel.setText(dialog.group_id)\n else:\n # ungroup\n self.sampleGroup.globalGroupId = None\n self.groupLabel.setText('Not\\nGrouped')\n self.emit(PYSIGNAL('groupChanged'), (self,))","def cmd_album_update(client, args):\n fields = data_fields(args, client.allowed_album_fields)\n album = client.update_album(args.album_id, fields)\n generate_output({'album': album})","def test_user_group_controller_update(self):\n pass","def set_group(self, group: str) -> None:\n self.group = group","def test_products_ref_groups_put(self):\n pass","def append_group_info(record, groups):\n record.INFO['IN_GROUP'] = groups\n record.INFO['GROUP_ID'] = ''\n return record","def update(self, instance, validated_data):\n\n # Use an atomic transaction for managing dataset and authors\n with transaction.atomic():\n # pop off the authors data\n if \"authors\" in validated_data.keys():\n author_data = validated_data.pop('authors')\n\n instance._change_reason = 'Adding Authors to Dataset Metadata'\n # remove the existing authors\n Author.objects.filter(dataset_id=instance.id).delete() # delete first\n self.add_authors(author_data, instance)\n\n instance._change_reason = 'Update Dataset Metadata'\n\n # Update Dataset metadata\n super(self.__class__, self).update(instance=instance, validated_data=validated_data)\n\n return instance","def check_group_description(our_group):\n\tgroup_id = our_group[\"groupId\"]\n\turl = f'{BASE_URL}/groups/{group_id}'\n\tresponse = call_api(url)\n\ttheir_description = response[\"description\"]\n\tif not their_description.startswith(PERUN_MANAGED):\n\t\tnew_description = PERUN_MANAGED + their_description + \" | Manage in Perun: \" + our_group[\"perunResourceUrl\"]\n\telif their_description.startswith(PERUN_MANAGED) and not their_description.endswith(our_group[\"perunResourceUrl\"]):\n\t\t# Resource ID changed in Perun, update description\n\t\tnew_description = their_description.split(\" | Manage in Perun: \")\n\t\tnew_description = new_description[0] + \" | Manage in Perun: \" + our_group[\"perunResourceUrl\"]\n\telse:\n\t\treturn\n\tparams = {\"description\": new_description}\n\tcall_api(url, params, 'PATCH')\n\tprint_debug(f\"Description updated for group {group_id}\")","def _mod_group(self, command, group_id, group_type, buckets=None):\n self.datapath.send_msg(\n self.parser.OFPGroupMod(\n datapath=self.datapath,\n command=command,\n group_id=group_id,\n type_=group_type,\n buckets=buckets,\n )\n )","def updateImageGroups(self):\n self.img_grps = self.splitImages()\n grps = self.img_grps\n self.detail.clear()\n detail = \"Available Groups : \\n\"\n if len(grps) >= 1:\n for i in range(len(grps)):\n detail += \"Group \"+ str(i+1)+ \" : \" + str(grps[i][0]) + \" ... \" + str(grps[i][-1]) + '\\n'\n\n self.detail.insertPlainText(detail)\n self.detail.moveCursor(QTextCursor.End)","async def update_metadata(dbcon: DBConnection, object_type: str, object_id: int, metadict: Dict[str, str]):\n\n async def _run(cur: Cursor) -> None:\n for key, value in metadict.items():\n if value in [False, None]:\n q = \"\"\"delete from object_metadata where object_type=%s and object_id=%s and `key`=%s\"\"\"\n q_args = (object_type, object_id, str(key)) # type: Tuple\n else:\n q = \"\"\"replace into object_metadata (object_type, object_id, `key`, value) values (%s, %s, %s, %s)\"\"\"\n q_args = (object_type, object_id, str(key), str(value))\n await cur.execute(q, q_args)\n\n await dbcon.transact(_run)","def test_sg_update_name(self):\n\n # Add a faked storage_group\n faked_storage_group = self.add_storage_group1()\n storage_group_name = faked_storage_group.name\n\n storage_group_mgr = self.console.storage_groups\n storage_group = storage_group_mgr.find(name=storage_group_name)\n\n new_storage_group_name = \"new-\" + storage_group_name\n\n # Execute the code to be tested\n storage_group.update_properties(\n properties={'name': new_storage_group_name})\n\n # Verify that the resource is no longer found by its old name, using\n # list() (this does not use the name-to-URI cache).\n storage_groups_list = storage_group_mgr.list(\n filter_args=dict(name=storage_group_name))\n assert len(storage_groups_list) == 0\n\n # Verify that the resource is no longer found by its old name, using\n # find() (this uses the name-to-URI cache).\n with pytest.raises(NotFound):\n storage_group_mgr.find(name=storage_group_name)\n\n # Verify that the resource object already reflects the update, even\n # though it has not been refreshed yet.\n assert storage_group.properties['name'] == new_storage_group_name\n\n # Refresh the resource object and verify that it still reflects the\n # update.\n storage_group.pull_full_properties()\n assert storage_group.properties['name'] == new_storage_group_name\n\n # Verify that the resource can be found by its new name, using find()\n new_storage_group_find = storage_group_mgr.find(\n name=new_storage_group_name)\n assert new_storage_group_find.properties['name'] == \\\n new_storage_group_name\n\n # Verify that the resource can be found by its new name, using list()\n new_storage_groups_list = storage_group_mgr.list(\n filter_args=dict(name=new_storage_group_name))\n assert len(new_storage_groups_list) == 1\n new_storage_group_list = new_storage_groups_list[0]\n assert new_storage_group_list.properties['name'] == \\\n new_storage_group_name","def update(self, data):\n self.data = data\n # extract data\n subject = data.identifier\n self.id = _uri_to_oai(subject)\n self.modified = datetime.utcnow()\n self.deleted = False\n\n itemtype, subtype = _get_itemtype(data, subject)\n\n self.metadata = {}\n\n # fixed fields:\n self.metadata['rif_key'] = _uri_to_key(subject)\n self.metadata['rif_group'] = self.provider.groupDescription\n self.metadata['rif_originatingSource'] = self.provider.originatingSource\n self.metadata['rif_object'] = {'value': itemtype,\n 'type': subtype,\n #'dateModified': '',\n }\n\n if itemtype == 'collection':\n self.updateCollection(data, subject)\n elif itemtype == 'party':\n if subtype == 'person':\n self.updatePartyPerson(data, subject)\n else:\n self.updateParty(data, subject)\n elif itemtype == 'activity':\n self.updateActivity(data, subject)\n elif itemtype == 'service':\n self.updateService(data, subject)","def setGroup(self, group):\n\t\tself.config.GROUP = group","def update_metadata(self, file_id, metadata):\n pass","def update(context, namespace_name, id, values, session):\n namespace_api.get(context, namespace_name, session)\n\n metadata_tag = _get(context, id, session)\n metadef_utils.drop_protected_attrs(models.MetadefTag, values)\n # values['updated_at'] = timeutils.utcnow() - done by TS mixin\n try:\n metadata_tag.update(values.copy())\n metadata_tag.save(session=session)\n except db_exc.DBDuplicateEntry:\n LOG.debug(\"Invalid update. It would result in a duplicate\"\n \" metadata tag with same name=%(name)s\"\n \" in namespace=%(namespace_name)s.\",\n {'name': values['name'],\n 'namespace_name': namespace_name})\n raise exc.MetadefDuplicateTag(\n name=values['name'], namespace_name=namespace_name)\n\n return metadata_tag.to_dict()","def add_group_data(self, group_name):\n self.sorted = False\n self.grouped = False\n self.labels_to_add = []\n for path in self.all_groups.get(group_name):\n io = NWBHDF5IO(path, 'r')\n nwb_file = io.read()\n # self.labels.append(nwb_file.identifier)\n self.nwb_path_list.update({nwb_file.identifier: path})\n self.labels_to_add.append(nwb_file.identifier)\n self.musketeers_widget.session_widget.populate(self.labels_to_add, 'add')\n self.musketeers_widget.session_widget.update_text_filter()\n self.groupMenu.setEnabled(True)\n self.sortMenu.setEnabled(True)","def update_from_qai(self) -> dict:\n qaisession = self.qaisession\n if qaisession is None or not qaisession.is_logged_in():\n return dict(ok=False, msg=\"User not logged in\")\n # get the locally stored timestamp data from our database\n cur_tsdata = self.get_ts_data()\n try:\n newds = qai_helper.QAIDataset(None, cur_tsdata)\n except RuntimeError as err:\n return dict(ok=False, msg=\"QAI access error: {}\".format(str(err)))\n # load those parts from QAI that are out of date\n update_dct = qaisession.clever_update_qai_dump(newds)\n # if any value is True, then we did get something from QAI...\n num_updated = sum(update_dct.values())\n if num_updated > 0:\n try:\n self._db_has_changed = self.load_qai_data(newds, update_dct)\n except TypeError as err:\n return dict(ok=False, msg=\"database error: {}\".format(str(err)))\n return dict(ok=True, msg=\"Successfully updated {} tables for QAI\".format(num_updated))","def with_group(self, group):\n\t\tself.variables['group'] = group\n\t\treturn self","def add_to_group(self, org, contact, group):\n pass","def metadata_update(self, new_metadata=None):\n if new_metadata is None:\n self.metadata_set(self.t.metadata())","def update_groups(self, groups):\n self.fetch_group_messages() # preload messages before updating groups\n self.groups = groups\n self.put()","def update_atom_metadata(self, atom_name, update_with):\n self._update_atom_metadata(atom_name, update_with)","def test_ipam_aggregates_update(self):\n pass","def update_metadata(sess, asset_link):\n get_json = sess.get(asset_link).json()\n update_metadata = get_json['customFields']\n update_metadata['SANDAG Last Access Date'] = datetime.datetime.today().strftime('%D')\n\n sess.patch(asset_link, \n data=json.dumps(update_metadata)).json()","def _update_aggregate_dataset(self, formula, new_dframe, name, groups,\n agg_dataset):\n # parse aggregation and build column arguments\n aggregation, new_columns = self.make_columns(\n formula, name, new_dframe)\n\n agg = Aggregator(self.dataset, self.dframe,\n groups, aggregation, name)\n new_agg_dframe = agg.update(agg_dataset, self, formula, new_columns)\n\n # jsondict from new dframe\n new_data = new_agg_dframe.to_jsondict()\n\n for merged_dataset in agg_dataset.merged_datasets:\n # remove rows in child from this merged dataset\n merged_dataset.remove_parent_observations(\n agg_dataset.dataset_id)\n\n # calculate updates on the child\n merged_calculator = Calculator(merged_dataset)\n call_async(merged_calculator.calculate_updates, merged_calculator,\n new_data, parent_dataset_id=agg_dataset.dataset_id)","def test_update_groups_Passes_correct_data_to_modify_groups_file(\n self, mock_modify_groups_file , mock_read_groups_file\n ):\n mock_modify_groups_file.return_value = True\n mock_read_groups_file.return_value = self.groups_data\n\n crud = CRUD()\n crud.update_groups(\"1\", \"name\", \"new_data\")\n mock_modify_groups_file.assert_called_once_with(self.groups_data)","def test_update_metadata(self):\r\n locator = BlockUsageLocator(\r\n CourseLocator(org=\"testx\", offering=\"GreekHero\", branch='draft'),\r\n 'problem', block_id=\"problem3_2\"\r\n )\r\n problem = modulestore().get_item(locator)\r\n pre_def_id = problem.definition_locator.definition_id\r\n pre_version_guid = problem.location.version_guid\r\n self.assertIsNotNone(pre_def_id)\r\n self.assertIsNotNone(pre_version_guid)\r\n self.assertNotEqual(problem.max_attempts, 4, \"Invalidates rest of test\")\r\n\r\n problem.max_attempts = 4\r\n problem.save() # decache above setting into the kvs\r\n updated_problem = modulestore().update_item(problem, '**replace_user**')\r\n # check that course version changed and course's previous is the other one\r\n self.assertEqual(updated_problem.definition_locator.definition_id, pre_def_id)\r\n self.assertNotEqual(updated_problem.location.version_guid, pre_version_guid)\r\n self.assertEqual(updated_problem.max_attempts, 4)\r\n # refetch to ensure original didn't change\r\n original_location = problem.location.map_into_course(CourseLocator(version_guid=pre_version_guid))\r\n problem = modulestore().get_item(original_location)\r\n self.assertNotEqual(problem.max_attempts, 4, \"original changed\")\r\n\r\n current_course = modulestore().get_course(locator.course_key)\r\n self.assertEqual(updated_problem.location.version_guid, current_course.location.version_guid)\r\n\r\n history_info = modulestore().get_course_history_info(current_course.location)\r\n self.assertEqual(history_info['previous_version'], pre_version_guid)\r\n self.assertEqual(history_info['edited_by'], \"**replace_user**\")","def update_mp3_metadata(self, mp3_file):\n if isinstance(mp3_file, str):\n mp3_file = mp3_utility.Mp3File(file_path=mp3_file, load_tags_from_file=True)\n remote_name = self.get_remote_name(mp3_file.file_path)\n archive_item_file_details = self.item_files_dict.get(remote_name, None)\n mp3_metadata = mp3_file.metadata\n if archive_item_file_details is None:\n logging.warning(\"The file does not exist! Skipping.\")\n else:\n remote_tag_update_needed = (archive_item_file_details.get(\"artist\", \"\") != mp3_metadata.artist) or (\n archive_item_file_details.get(\"creator\", \"\") != mp3_metadata.artist) or (\n archive_item_file_details.get(\"title\", \"\") != mp3_metadata.title) or (\n archive_item_file_details.get(\"album\", \"\") != mp3_metadata.album) or (\n archive_item_file_details.get(\"album_artist\",\n \"\") != mp3_metadata.album_artist)\n if remote_tag_update_needed:\n logging.info(\"***Updating %s in archive item.\" % remote_name)\n logging.info(\n internetarchive.modify_metadata(\n self.archive_id,\n metadata=dict(title=mp3_metadata.title, album=mp3_metadata.album,\n album_artist=mp3_metadata.album_artist,\n artist=mp3_metadata.artist, creator=mp3_metadata.artist),\n target=os.path.join(\"files\", remote_name)))","def upsert_group(self,\n group, # type: Group\n *options, # type: UpsertGroupOptions\n **kwargs # type: Any\n ):\n # This endpoint accepts application/x-www-form-urlencoded and requires the data be sent as form data.\n # The name/id should not be included in the form data.\n # Roles should be a comma separated list of strings.\n # If, only if, the role contains a bucket name then the rolename should be suffixed\n # with[<bucket_name>] e.g. bucket_full_access[default],security_admin.\n\n final_args = forward_args(kwargs, *options)\n final_args.update({k: v for k, v in group.as_dict.items() if k in {\n 'roles', 'description', 'ldap_group_reference'}})\n self._admin_bucket.group_upsert(group.name, **final_args)","def update(person_group_id, name=None, user_data=None):\n url = 'persongroups/{}'.format(person_group_id)\n json = {\n 'name': name,\n 'userData': user_data,\n }\n\n return util.request('PATCH', url, json=json)","def append_group_attr(self, analyte: str, group_name: str, key: str, value: Any):\n group_path = \"/\".join([\"\", ASSAYS, analyte, group_name])\n if group_path not in self.__file:\n raise ValueError(\"{} missing\".format(group_path))\n group = self.__file[group_path]\n if key in group.keys():\n key_path = group_path + \"/\" + key\n data = self.__file[key_path]\n normalized = normalize_attr_values(value)\n data[...] = normalized\n else:\n self.__write_value(group, key, value)","def test_set_add_updates_new_record(self):\r\n partition = uuid4()\r\n cluster = 1\r\n TestQueryUpdateModel.objects(\r\n partition=partition, cluster=cluster).update(text_set__add={'bar'})\r\n obj = TestQueryUpdateModel.objects.get(partition=partition, cluster=cluster)\r\n self.assertEqual(obj.text_set, {\"bar\"})","def replaceMetadata(self, obj, dom):\n self.update_semantics = 'replace'\n # create a metadata dict that has all the defaults, overridden by the\n # current dom values. This way we will 'clear' the properties not in\n # the dom.\n metadata = copy(METADATA_DEFAULTS)\n metadata.update(self.getMetadata(dom, METADATA_MAPPING))\n if metadata:\n self.validate_metadata(metadata)\n metadata = self.fixEntities(metadata, ATTRIBUTES_TO_FIX)\n if ICollection.providedBy(obj):\n obj.collection_metadata(**metadata)\n elif IModule.providedBy(obj):\n obj.update_metadata(**metadata)\n # we set GoogleAnalyticsTrackingCode explicitly, since the script\n # 'update_metadata' ignores empty strings.\n obj.GoogleAnalyticsTrackingCode = metadata.get('GoogleAnalyticsTrackingCode')\n self.updateRoles(obj, dom)\n obj.reindexObject(idxs=metadata.keys())"],"string":"[\n \"def _metadata_update_group(group_id):\\n\\n # get all firmwares in this group\\n firmwares = db.firmware.get_all()\\n firmwares_filtered = []\\n for f in firmwares:\\n if f.target == 'private':\\n continue\\n if f.group_id != group_id:\\n continue\\n firmwares_filtered.append(f)\\n\\n # create metadata file for the embargoed firmware\\n affidavit = _create_affidavit()\\n filename = 'firmware-%s.xml.gz' % _qa_hash(group_id)\\n _generate_metadata_kind(filename,\\n firmwares_filtered,\\n affidavit=affidavit)\",\n \"def update_group(groupname):\\n name = request.get_json().get(\\\"name\\\", None)\\n description = request.get_json().get(\\\"description\\\", None)\\n response = jsonify(\\n admin.update_group(current_app.scoped_session(), groupname, description, name)\\n )\\n return response\",\n \"def group_update(*, login_manager: LoginManager, group_id: str, **kwargs: Any):\\n groups_client = login_manager.get_groups_client()\\n\\n # get the current state of the group\\n group = groups_client.get_group(group_id)\\n\\n # assemble put data using existing values for any field not given\\n # note that the API does not accept the full group document, so we must\\n # specify name and description instead of just iterating kwargs\\n data = {}\\n for field in [\\\"name\\\", \\\"description\\\"]:\\n if kwargs.get(field) is not None:\\n data[field] = kwargs[field]\\n else:\\n data[field] = group[field]\\n\\n response = groups_client.update_group(group_id, data)\\n\\n formatted_print(response, simple_text=\\\"Group updated successfully\\\")\",\n \"def test_update_group(self):\\n pass\",\n \"def updateDataQuality(idMeta, Quality):\\n # XXX add for diaries\\n sqlq = \\\"UPDATE Meta \\\\\\n SET `Quality`= %s \\\\\\n WHERE `idMeta` = %s;\\\" % (Quality, idMeta)\\n mdb.executeSQL(sqlq)\\n mdb.commit()\",\n \"def update_group():\\n _id = request.form['_id']\\n name = request.form['name']\\n data, code, message = FIELD_SERVICE.update_group(_id, name)\\n return __result(data, code, message)\",\n \"def do_group_update():\\n target_group = Group.query.filter_by(id=request.form['id']).first()\\n if target_group is None:\\n return group_list(\\\"Unknown group.\\\")\\n\\n target_group.name = request.form['name']\\n target_group.group_meter_id = request.form['meter']\\n target_group.group_production_meter_id_first = request.form['group_production_meter_id_first']\\n target_group.group_production_meter_id_second = request.form[\\n 'group_production_meter_id_second']\\n\\n db.session.commit()\\n return group_list(\\\"Updated group \\\" + target_group.name)\",\n \"def test_modify_group(self):\\n response = self.client.modify_group(\\\"ABC123\\\")\\n self.assertEqual(response[\\\"method\\\"], \\\"POST\\\")\\n self.assertEqual(response[\\\"uri\\\"], \\\"/admin/v1/groups/ABC123\\\")\\n self.assertEqual(util.params_to_dict(response[\\\"body\\\"]), {\\\"account_id\\\": [self.client.account_id]})\",\n \"def update(self):\\r\\n return self.connection._update_group('UpdateAutoScalingGroup', self)\",\n \"def update(self,\\n provider_id,\\n group_id,\\n group,\\n ):\\n return self._invoke('update',\\n {\\n 'provider_id': provider_id,\\n 'group_id': group_id,\\n 'group': group,\\n })\",\n \"def update_group(self, group_id, **kwargs):\\n post_body = json.dumps({'group': kwargs})\\n resp, body = self.patch('groups/%s' % group_id, post_body)\\n self.expected_success(200, resp.status)\\n body = json.loads(body)\\n return rest_client.ResponseBody(resp, body)\",\n \"def update_group(self, group_id, new_description):\\n url = self.groups_url + \\\"/\\\" + group_id\\n new_data = json.dumps({\\\"description\\\": new_description})\\n\\n return requests.put(url, new_data, headers=self.headers)\",\n \"def update_metadata(self, key, value):\\n sp.verify(self.is_administrator(sp.sender), FA12_Error.NotAdmin)\\n self.data.metadata[key] = value\",\n \"def update(self, consistencygroup, **kwargs):\\n if not kwargs:\\n return\\n\\n body = {\\\"consistencygroup\\\": kwargs}\\n\\n return self._update(\\\"/consistencygroups/%s\\\" %\\n base.getid(consistencygroup), body)\",\n \"def customer_group_put(group_info):\\n related_groups = customer_group_get_related(group_info[\\\"group_id\\\"])\\n\\n now = datetime.datetime.now()\\n f = '%Y-%m-%d %H:%M:%S'\\n insert_time = now.strftime(f)\\n\\n result = {\\\"success\\\" : 1, \\\"message\\\" : \\\"Customer Company can not be Updated\\\"}\\n\\n for groups in related_groups:\\n c_group_info = list(groups)\\n #check for the roles\\n c_g_id = c_group_info[0]\\n c_g_role = c_group_info[1].split(\\\"(\\\")[1][:-1]\\n c_g_name = c_group_info[1].split(\\\"(\\\")[0]\\n new_c_g_name = group_info[\\\"group_name\\\"] + \\\"(\\\"+ c_g_role +\\\")\\\"\\n db_conn = DB_Conn()\\n db = db_conn.db_connect()\\n cursor = db.cursor()\\n query = \\\"\\\"\\\"\\n UPDATE `groups`\\n SET\\n `group_name` = \\\"%s\\\",\\n `company_name` = \\\"%s\\\",\\n `company_address` = \\\"%s\\\",\\n `company_telephone` = \\\"%s\\\",\\n `company_fax` = \\\"%s\\\",\\n `company_website` = \\\"%s\\\",\\n `company_sales_contact` = \\\"%s\\\",\\n `company_purchase_contact` = \\\"%s\\\",\\n `company_business` = \\\"%s\\\",\\n `company_business_type` = \\\"%s\\\",\\n `company_sales_email` = \\\"%s\\\",\\n `company_purchase_email` = \\\"%s\\\",\\n `company_reg_number` = \\\"%s\\\",\\n `company_vat_number` = \\\"%s\\\",\\n `description` = \\\"%s\\\"\\n WHERE\\n `group_id` = \\\"%s\\\"\\n \\\"\\\"\\\" %(\\n new_c_g_name, \\n group_info[\\\"company_name\\\"],\\n group_info[\\\"company_address\\\"],\\n group_info[\\\"company_telephone\\\"],\\n group_info[\\\"company_fax\\\"],\\n group_info[\\\"company_website\\\"],\\n group_info[\\\"company_sales_contact\\\"],\\n group_info[\\\"company_purchase_contact\\\"],\\n group_info[\\\"company_business\\\"],\\n group_info[\\\"company_business_type\\\"],\\n group_info[\\\"company_sales_email\\\"],\\n group_info[\\\"company_purchase_email\\\"],\\n group_info[\\\"company_reg_number\\\"],\\n group_info[\\\"company_vat_number\\\"],\\n group_info[\\\"description\\\"],\\n c_g_id\\n )\\n try:\\n if cursor.execute(query):\\n db.commit()\\n result = {\\\"success\\\" : 0, \\\"message\\\" : \\\"Customer Company Updated Successfully\\\"}\\n except Exception as e:\\n result = {\\\"success\\\" : 1, \\\"message\\\" : \\\"Customer Company can not be Updated. Error \\\\\\\"\\\\'%s\\\\'\\\\\\\" \\\\\\n Query = %s\\\" % (e, query) }\\n finally:\\n cursor.close()\\n db.close()\\n return result\",\n \"def update_targetgroup(self, group_id, **kwargs):\\r\\n result = False\\r\\n if self._db(self._db.targetgroup.id==group_id).select():\\r\\n result = True\\r\\n self._db(self._db.targetgroup.id==group_id).update(**kwargs)\\r\\n self._db.commit()\\r\\n return result\",\n \"async def update_contact_group(dbcon: DBConnection, contact_group_id: int, data: Dict[str, str]) -> None:\\n\\n async def _run(cur: Cursor) -> None:\\n for key, value in data.items():\\n if key not in ['name', 'active']:\\n raise errors.IrisettError('invalid contact key %s' % key)\\n q = \\\"\\\"\\\"update contact_groups set %s=%%s where id=%%s\\\"\\\"\\\" % key\\n q_args = (value, contact_group_id)\\n await cur.execute(q, q_args)\\n\\n if not await contact_group_exists(dbcon, contact_group_id):\\n raise errors.InvalidArguments('contact group does not exist')\\n await dbcon.transact(_run)\",\n \"def update_metadata(\\n self, expectation_suite: es.ExpectationSuite\\n ) -> es.ExpectationSuite:\\n _client = client.get_instance()\\n path_params = [\\n \\\"project\\\",\\n _client._project_id,\\n \\\"featurestores\\\",\\n self._feature_store_id,\\n \\\"featuregroups\\\",\\n self._feature_group_id,\\n \\\"expectationsuite\\\",\\n expectation_suite.id,\\n \\\"metadata\\\",\\n ]\\n\\n headers = {\\\"content-type\\\": \\\"application/json\\\"}\\n payload = expectation_suite.json()\\n\\n major, minor = self._variable_api.parse_major_and_minor(\\n self._variable_api.get_version(\\\"hopsworks\\\")\\n )\\n method = \\\"PUT\\\"\\n if major == \\\"3\\\" and minor == \\\"0\\\":\\n method = \\\"POST\\\"\\n del path_params[-1]\\n del path_params[-1]\\n\\n return es.ExpectationSuite.from_response_json(\\n _client._send_request(method, path_params, headers=headers, data=payload)\\n )\",\n \"def test_update_resource_group(self):\\n pass\",\n \"def test_update_metadata_by_attribute(self):\\n pass\",\n \"def test_update_metadata_by_attribute1(self):\\n pass\",\n \"def _do_update(self, meta, k, v):\\n self.runtime.logger.info('{}: [{}] -> {}'.format(meta.in_group_config_path, k, v))\\n meta.config[k] = v\\n meta.save()\",\n \"def update_group(self, group_name, new_group_name=None, new_path=None):\\r\\n params = {'GroupName' : group_name}\\r\\n if new_group_name:\\r\\n params['NewGroupName'] = new_group_name\\r\\n if new_path:\\r\\n params['NewPath'] = new_path\\r\\n return self.get_response('UpdateGroup', params)\",\n \"def update_meta(self, db_name, collection_name, is_finished):\\n import time\\n from ir_config import IRConfig\\n meta_collection = self.__get_meta_collection(db_name)\\n res = self.__find_collection_in_meta(db_name, collection_name)\\n if res.count() > 0:\\n meta_collection.update({self.__meta_key_name : collection_name},\\n {'$set' : {self.__meta_lastmodified_name : int(time.time()),\\n self.__meta_success_name : is_finished}}) \\n else:\\n meta_collection.insert({self.__meta_key_name : collection_name,\\n self.__meta_lastmodified_name : int(time.time()),\\n self.__meta_success_name : is_finished})\",\n \"def set_group(self, data, group, intg, dq=None):\\n # TODO: Include a 2-D DQ array to be combined with the GROUPDQ array\\n #\\n # Copy the input data to a 2-D plane for this group/intg combination.\\n # NOTE: This only works if data array is broadcastable so the shape\\n # of the data array is checked.\\n #\\n data = np.asarray(data, dtype=self.data.dtype)\\n detector_shape = (self.rows, self.columns)\\n if data.shape == detector_shape:\\n self.data[intg, group, :, :] = data \\n # Invalidate the averaged data\\n self._data_averaged = None\\n # Update the group data quality array if necessary.\\n if dq is not None:\\n if self.include_groupdq:\\n dq = np.asarray(dq, dtype=self.groupdq.dtype) # Convert to same data type.\\n self.groupdq[intg, group, :, :] |= dq\\n else:\\n strg = \\\"Incompatible arguments. A groupdq array is \\\"\\n strg += \\\"provided when include_groupdq=False. \\\"\\n strg += \\\"The array is ignored.\\\"\\n LOGGER.error(strg)\\n else:\\n strg = \\\"Group data array has the wrong shape \\\"\\n strg += \\\"(%s instead of %s).\\\" % (str(data.shape),\\n str(detector_shape))\\n raise TypeError(strg)\",\n \"def update_research_group(self, employee_id, new_research_group):\\n cursor = self.dbconnect.get_cursor()\\n try:\\n cursor.execute('UPDATE employee '\\n 'SET research_group = %s '\\n 'WHERE id=%s;',\\n (new_research_group, employee_id))\\n self.dbconnect.commit()\\n except:\\n self.dbconnect.rollback()\\n raise\",\n \"def update(ctx, name, description, tags):\\n user, project_name, _group = get_project_group_or_local(ctx.obj.get('project'),\\n ctx.obj.get('group'))\\n update_dict = {}\\n\\n if name:\\n update_dict['name'] = name\\n\\n if description:\\n update_dict['description'] = description\\n\\n tags = validate_tags(tags)\\n if tags:\\n update_dict['tags'] = tags\\n\\n if not update_dict:\\n Printer.print_warning('No argument was provided to update the experiment group.')\\n sys.exit(0)\\n\\n try:\\n response = PolyaxonClient().experiment_group.update_experiment_group(\\n user, project_name, _group, update_dict)\\n except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:\\n Printer.print_error('Could not update experiment group `{}`.'.format(_group))\\n Printer.print_error('Error message `{}`.'.format(e))\\n sys.exit(1)\\n\\n Printer.print_success(\\\"Experiment group updated.\\\")\\n get_group_details(response)\",\n \"def put(self):\\n status = ErrorCode.SUCCESS\\n try:\\n data = DotDict(json_decode(self.request.body))\\n cid = self.current_user.cid\\n tid = self.current_user.tid\\n gid = data.gid\\n name = data.name\\n logging.info(\\\"[UWEB] Modify group request: %s, cid: %s\\\",\\n data, self.current_user.cid)\\n except Exception as e:\\n status = ErrorCode.ILLEGAL_DATA_FORMAT\\n logging.exception(\\\"[UWEB] Invalid data format. body:%s, Exception: %s\\\",\\n self.request.body, e.args)\\n self.write_ret(status)\\n return\\n\\n try: \\n group = self.get_group_by_cid(cid, name)\\n if group:\\n status = ErrorCode.GROUP_EXIST\\n self.write_ret(status)\\n return\\n\\n self.db.execute(\\\"UPDATE T_GROUP\\\"\\n \\\" SET name = %s\\\"\\n \\\" WHERE id = %s\\\",\\n name, gid)\\n\\n # NOTE: wspush to client \\n if status == ErrorCode.SUCCESS:\\n WSPushHelper.pushS3(tid, self.db, self.redis)\\n\\n self.write_ret(status)\\n except Exception as e:\\n logging.exception(\\\"[UWEB] Modify group failed. cid: %s, Exception: %s\\\",\\n self.current_user.cid, e.args)\\n status = ErrorCode.SERVER_BUSY\\n self.write_ret(status)\",\n \"def test_update_metadata1(self):\\n pass\",\n \"def request_group_update():\\n target_group = Group.query.filter_by(id=request.args['id']).first()\\n if target_group is None:\\n return group_list(\\\"Unknown group.\\\")\\n\\n return Response(\\n render_template(\\n 'admin/group/create-update.html',\\n csrf_token=(\\n get_raw_jwt() or {}).get(\\\"csrf\\\"),\\n target=\\\"/admin/group/update\\\",\\n id=target_group.id,\\n name=target_group.name,\\n meter=target_group.group_meter_id,\\n group_production_meter_id_first=target_group.group_production_meter_id_first,\\n group_production_meter_id_second=target_group.group_production_meter_id_second),\\n mimetype='text/html')\",\n \"def test_update_metadata(self):\\n pass\",\n \"def set(self, name_group, key, value):\\n self.psettings.beginGroup(name_group)\\n self.psettings.setValue(key, value)\\n self.closeGroup()\",\n \"def update_group_with_http_info(self, bucket_id, group_id, group, **kwargs):\\n\\n all_params = ['bucket_id', 'group_id', 'group', 'if_match', 'if_none_match', 'fields']\\n all_params.append('callback')\\n all_params.append('_return_http_data_only')\\n all_params.append('_preload_content')\\n all_params.append('_request_timeout')\\n\\n params = locals()\\n for key, val in iteritems(params['kwargs']):\\n if key not in all_params:\\n raise TypeError(\\n \\\"Got an unexpected keyword argument '%s'\\\"\\n \\\" to method update_group\\\" % key\\n )\\n params[key] = val\\n del params['kwargs']\\n # verify the required parameter 'bucket_id' is set\\n if ('bucket_id' not in params) or (params['bucket_id'] is None):\\n raise ValueError(\\\"Missing the required parameter `bucket_id` when calling `update_group`\\\")\\n # verify the required parameter 'group_id' is set\\n if ('group_id' not in params) or (params['group_id'] is None):\\n raise ValueError(\\\"Missing the required parameter `group_id` when calling `update_group`\\\")\\n # verify the required parameter 'group' is set\\n if ('group' not in params) or (params['group'] is None):\\n raise ValueError(\\\"Missing the required parameter `group` when calling `update_group`\\\")\\n\\n if 'if_match' in params and not re.search('\\\\\\\\\\\\\\\"[0-9]+\\\\\\\\\\\\\\\"', params['if_match']):\\n raise ValueError(\\\"Invalid value for parameter `if_match` when calling `update_group`, must conform to the pattern `/\\\\\\\\\\\\\\\"[0-9]+\\\\\\\\\\\\\\\"/`\\\")\\n if 'if_none_match' in params and not re.search('\\\\\\\\\\\\\\\"[0-9]+\\\\\\\\\\\\\\\"', params['if_none_match']):\\n raise ValueError(\\\"Invalid value for parameter `if_none_match` when calling `update_group`, must conform to the pattern `/\\\\\\\\\\\\\\\"[0-9]+\\\\\\\\\\\\\\\"/`\\\")\\n\\n collection_formats = {}\\n\\n resource_path = '/buckets/{bucket_id}/groups/{group_id}'.replace('{format}', 'json')\\n path_params = {}\\n if 'bucket_id' in params:\\n path_params['bucket_id'] = params['bucket_id']\\n if 'group_id' in params:\\n path_params['group_id'] = params['group_id']\\n\\n query_params = {}\\n if 'fields' in params:\\n query_params['_fields'] = params['fields']\\n collection_formats['_fields'] = 'csv'\\n\\n header_params = {}\\n if 'if_match' in params:\\n header_params['If-Match'] = params['if_match']\\n if 'if_none_match' in params:\\n header_params['If-None-Match'] = params['if_none_match']\\n\\n form_params = []\\n local_var_files = {}\\n\\n body_params = None\\n if 'group' in params:\\n body_params = params['group']\\n\\n # HTTP header `Accept`\\n header_params['Accept'] = self.api_client.\\\\\\n select_header_accept(['application/json'])\\n if not header_params['Accept']:\\n del header_params['Accept']\\n\\n # HTTP header `Content-Type`\\n header_params['Content-Type'] = self.api_client.\\\\\\n select_header_content_type(['application/json'])\\n\\n # Authentication setting\\n auth_settings = ['basicAuth']\\n\\n return self.api_client.call_api(resource_path, 'PUT',\\n path_params,\\n query_params,\\n header_params,\\n body=body_params,\\n post_params=form_params,\\n files=local_var_files,\\n response_type='Group',\\n auth_settings=auth_settings,\\n callback=params.get('callback'),\\n _return_http_data_only=params.get('_return_http_data_only'),\\n _preload_content=params.get('_preload_content', True),\\n _request_timeout=params.get('_request_timeout'),\\n collection_formats=collection_formats)\",\n \"def test_update_device_group_by_id(self):\\n pass\",\n \"def update_metadata(self):\\n self.data[\\\"keywords\\\"] = self.repo.topics(self.data.get(\\\"keywords\\\", []))\\n self.data[\\\"description\\\"] = self.data.get(\\\"description\\\") or self.repo.description\\n self.data[\\\"codeRepository\\\"] = (\\n self.data.get(\\\"codeRepository\\\") or self.repo.html_url\\n )\\n self.data[\\\"name\\\"] = self.data.get(\\\"name\\\") or self.repo.name\\n self.data[\\\"issueTracker\\\"] = (\\n self.data.get(\\\"issueTracker\\\") or self.repo.issues_url\\n )\\n self.data[\\\"license\\\"] = self.data.get(\\\"license\\\") or self.repo.license\",\n \"def test_update_device_group_by_id1(self):\\n pass\",\n \"def update(self, group_snapshot, **kwargs):\\n if not kwargs:\\n return\\n\\n body = {\\\"group_snapshot\\\": kwargs}\\n\\n return self._update(\\\"/group_snapshots/%s\\\" % base.getid(group_snapshot),\\n body)\",\n \"def metadata(\\n client: Client,\\n modify: bool,\\n library: str,\\n editor: str,\\n group: bool,\\n update: bool,\\n):\\n if modify and not library:\\n raise RuntimeError(\\\"--modify flag requires --library argument\\\")\\n\\n if update:\\n print(\\\"Updating library... \\\")\\n client.update()\\n print(\\\"Library update complete.\\\")\\n\\n database = EditableDatabase(client.library.albums)\\n if not modify:\\n database.print_genres(group=True)\\n if modify:\\n modified = database.edit_genres(Path(library), editor, group)\\n print(f\\\"\\\\nUpdated {modified} albums.\\\")\",\n \"def tests_ti_document_update(self, request: FixtureRequest):\\n super().group_update(request)\",\n \"def test_update_entry_groups(self):\\r\\n # This method utilises the PUT request method and will make changes to the Canvas instance. This needs consideration.\\r\\n pass\",\n \"def update_pkg_metadata(self, pkg, version=None, **kwargs):\\n pass\",\n \"def ModifyGroup(self, group, reason=None, **kwargs):\\n query = []\\n _AppendReason(query, reason)\\n\\n return self._SendRequest(HTTP_PUT,\\n (\\\"/%s/groups/%s/modify\\\" %\\n (GANETI_RAPI_VERSION, group)), query, kwargs)\",\n \"def test_update_topic_groups(self):\\r\\n # This method utilises the PUT request method and will make changes to the Canvas instance. This needs consideration.\\r\\n pass\",\n \"def test_partially_update_device_group_by_id(self):\\n pass\",\n \"def get_group_metadata(self):\\n # Implemented from template for osid.resource.ResourceForm.get_group_metadata_template\\n metadata = dict(self._group_metadata)\\n metadata.update({'existing_group_values': self._my_map['group']})\\n return Metadata(**metadata)\",\n \"def persist_test_group(self, obj: object, group: str) -> str:\",\n \"def update_adcampaign_group(self, campaign_group_id, name=None,\\n campaign_group_status=None, objective=None,\\n batch=False):\\n path = '%s' % campaign_group_id\\n args = {}\\n if name is not None:\\n args['name'] = name\\n if campaign_group_status is not None:\\n args['campaign_group_status'] = campaign_group_status\\n if objective is not None:\\n args['objective'] = objective\\n return self.make_request(path, 'POST', args, batch=batch)\",\n \"def update_metadata(self, item, feat_part, drop_feat):\\n # In all cases, update the artist fields.\\n self._log.info('artist: {0} -> {1}', item.artist, item.albumartist)\\n item.artist = item.albumartist\\n if item.artist_sort:\\n # Just strip the featured artist from the sort name.\\n item.artist_sort, _ = split_on_feat(item.artist_sort)\\n\\n # Only update the title if it does not already contain a featured\\n # artist and if we do not drop featuring information.\\n if not drop_feat and not contains_feat(item.title):\\n feat_format = self.config['format'].as_str()\\n new_format = feat_format.format(feat_part)\\n new_title = f\\\"{item.title} {new_format}\\\"\\n self._log.info('title: {0} -> {1}', item.title, new_title)\\n item.title = new_title\",\n \"def test_partially_update_device_group_by_id1(self):\\n pass\",\n \"def test_update_collection_metadata(self):\\n c1 = self.hiarc_collections.create_collection(\\n self.hiarc_util.create_collection(self.hiarc_util.get_test_metadata()))\\n upmd = {\\n \\\"department\\\": \\\"support\\\",\\n \\\"quotaCarrying\\\": False,\\n \\\"targetRate\\\": 7.271,\\n \\\"level\\\": 2,\\n \\\"startDate\\\": dateutil.parser.parse(\\\"2020-02-25T22:33:50.134Z\\\")\\n }\\n uc = hiarc.UpdateCollectionRequest(metadata=upmd)\\n updated = self.hiarc_collections.update_collection(uc, c1.key)\\n updated.metadata['startDate'] = dateutil.parser.parse(\\n updated.metadata['startDate'])\\n self.assertDictEqual(upmd, updated.metadata)\",\n \"def group(self, group):\\n self._group = group\",\n \"def capacitygroup_update(cmd_ctx, cpc, capacitygroup, **options):\\n cmd_ctx.execute_cmd(\\n lambda: cmd_capacitygroup_update(cmd_ctx, cpc, capacitygroup, options))\",\n \"def fusion_api_update_from_group(self, uri, api=None, headers=None):\\n param = '/compliance'\\n return self.li.update(body=None, uri=uri, api=api, headers=headers, param=param)\",\n \"def set_group(self, address, group):\\n self.groups[address] = group\",\n \"def update_metadata(self):\\n parser = GenericParser(\\n fn_re='{}/(e\\\\d+s\\\\d+)_.*/Production.nc'.format(self.data_folder),\\n group_names=['sim'],\\n group_transforms=[lambda x: x],\\n top_fn='',\\n step_ps=self.timestep\\n )\\n meta = gather_metadata('{}/e*/*nc'.format(self.data_folder), parser)\\n meta['top_fn'] = sorted(glob('{}/e*/structure.prmtop'.format(self.input_folder)))\\n self.meta = meta\",\n \"def update(self, *args, **kwargs): \\n kwargs[\\\"sampleID\\\"] = self.__sampleID\\n kwargs[\\\"sampleMetaID\\\"] = self.id()\\n self._eLABJournalObject__api.update_sample_meta(*list(args), **dict(kwargs))\\n rp = self._eLABJournalObject__api._request(\\\"/api/v1/samples/\\\"+urllib.parse.quote(str(kwargs[\\\"sampleID\\\"]))+\\\"/meta/\\\"+urllib.parse.quote(str(kwargs[\\\"sampleMetaID\\\"])), \\\"get\\\", {})\\n #check and get\\n if (rp is not None) & (type(rp) == dict):\\n self.__init__(self._eLABJournalObject__api,kwargs[\\\"sampleID\\\"],rp) \\n else:\\n print(dict)\\n raise Exception(\\\"couldn't perform selfupdate\\\")\",\n \"def update(self, id, xmlData = NotImplemented, version = NotImplemented):\\n\\n kparams = KalturaParams()\\n kparams.addIntIfDefined(\\\"id\\\", id);\\n kparams.addStringIfDefined(\\\"xmlData\\\", xmlData)\\n kparams.addIntIfDefined(\\\"version\\\", version);\\n self.client.queueServiceActionCall(\\\"metadata_metadata\\\", \\\"update\\\", \\\"KalturaMetadata\\\", kparams)\\n if self.client.isMultiRequest():\\n return self.client.getMultiRequestResult()\\n resultNode = self.client.doQueue()\\n return KalturaObjectFactory.create(resultNode, 'KalturaMetadata')\",\n \"def patch_group_with_http_info(self, bucket_id, group_id, group, **kwargs):\\n\\n all_params = ['bucket_id', 'group_id', 'group', 'if_match', 'if_none_match', 'fields']\\n all_params.append('callback')\\n all_params.append('_return_http_data_only')\\n all_params.append('_preload_content')\\n all_params.append('_request_timeout')\\n\\n params = locals()\\n for key, val in iteritems(params['kwargs']):\\n if key not in all_params:\\n raise TypeError(\\n \\\"Got an unexpected keyword argument '%s'\\\"\\n \\\" to method patch_group\\\" % key\\n )\\n params[key] = val\\n del params['kwargs']\\n # verify the required parameter 'bucket_id' is set\\n if ('bucket_id' not in params) or (params['bucket_id'] is None):\\n raise ValueError(\\\"Missing the required parameter `bucket_id` when calling `patch_group`\\\")\\n # verify the required parameter 'group_id' is set\\n if ('group_id' not in params) or (params['group_id'] is None):\\n raise ValueError(\\\"Missing the required parameter `group_id` when calling `patch_group`\\\")\\n # verify the required parameter 'group' is set\\n if ('group' not in params) or (params['group'] is None):\\n raise ValueError(\\\"Missing the required parameter `group` when calling `patch_group`\\\")\\n\\n if 'if_match' in params and not re.search('\\\\\\\\\\\\\\\"[0-9]+\\\\\\\\\\\\\\\"', params['if_match']):\\n raise ValueError(\\\"Invalid value for parameter `if_match` when calling `patch_group`, must conform to the pattern `/\\\\\\\\\\\\\\\"[0-9]+\\\\\\\\\\\\\\\"/`\\\")\\n if 'if_none_match' in params and not re.search('\\\\\\\\\\\\\\\"[0-9]+\\\\\\\\\\\\\\\"', params['if_none_match']):\\n raise ValueError(\\\"Invalid value for parameter `if_none_match` when calling `patch_group`, must conform to the pattern `/\\\\\\\\\\\\\\\"[0-9]+\\\\\\\\\\\\\\\"/`\\\")\\n\\n collection_formats = {}\\n\\n resource_path = '/buckets/{bucket_id}/groups/{group_id}'.replace('{format}', 'json')\\n path_params = {}\\n if 'bucket_id' in params:\\n path_params['bucket_id'] = params['bucket_id']\\n if 'group_id' in params:\\n path_params['group_id'] = params['group_id']\\n\\n query_params = {}\\n if 'fields' in params:\\n query_params['_fields'] = params['fields']\\n collection_formats['_fields'] = 'csv'\\n\\n header_params = {}\\n if 'if_match' in params:\\n header_params['If-Match'] = params['if_match']\\n if 'if_none_match' in params:\\n header_params['If-None-Match'] = params['if_none_match']\\n\\n form_params = []\\n local_var_files = {}\\n\\n body_params = None\\n if 'group' in params:\\n body_params = params['group']\\n\\n # HTTP header `Accept`\\n header_params['Accept'] = self.api_client.\\\\\\n select_header_accept(['application/json'])\\n if not header_params['Accept']:\\n del header_params['Accept']\\n\\n # HTTP header `Content-Type`\\n header_params['Content-Type'] = self.api_client.\\\\\\n select_header_content_type(['application/json', 'application/merge-patch+json', 'application/json-patch+json'])\\n\\n # Authentication setting\\n auth_settings = ['basicAuth']\\n\\n return self.api_client.call_api(resource_path, 'PATCH',\\n path_params,\\n query_params,\\n header_params,\\n body=body_params,\\n post_params=form_params,\\n files=local_var_files,\\n response_type='Group',\\n auth_settings=auth_settings,\\n callback=params.get('callback'),\\n _return_http_data_only=params.get('_return_http_data_only'),\\n _preload_content=params.get('_preload_content', True),\\n _request_timeout=params.get('_request_timeout'),\\n collection_formats=collection_formats)\",\n \"def metadata_update(self, _):\\n self.details.original_widget = YesNoWidget('Update metadata files?', self.__metadata_update)\",\n \"def group(self, group):\\n\\n self._group = group\",\n \"def group(self, group):\\n\\n self._group = group\",\n \"def group(self, group):\\n\\n self._group = group\",\n \"def _update_to_group(group, rrsets):\\n #logging.debug('parsing DNS UPDATE:\\\\n\\\\n\\\\%s' % rrsets)\\n for rrset in rrsets:\\n for record in rrset:\\n record.rdclass %= dns.rdataclass.UNIQUE #remove cache-flush bit\\n\\n if record.rdtype not in [dns.rdatatype.PTR, dns.rdatatype.A, dns.rdatatype.AAAA, dns.rdatatype.TXT, dns.rdatatype.SRV]:\\n logging.warning('Invalid DNS RR type (%s), not adding mDNS record to Avahi' % record.rdtype)\\n continue\\n\\n if record.rdclass != dns.rdataclass.IN:\\n logging.warning('Invalid DNS RR class (%s), not adding mDNS record to Avahi' % record.rdclass)\\n continue\\n\\n #if (record.rdtype == dns.rdatatype.PTR and ':' in record.to_digestable()) or record.rdtype == dns.rdatatype.AAAA:\\n # continue #ignore IPV6 for now, can't sniff those connections\\n\\n try:\\n group.AddRecord( #http://avahi.sourcearchive.com/documentation/0.6.30-5/avahi-client_2publish_8h_a849f3042580d6c8534cba820644517ac.html#a849f3042580d6c8534cba820644517ac\\n IF_UNSPEC, # iface *\\n PROTO_UNSPEC, # proto _INET & _INET6\\n dbus.UInt32(256), # AvahiPublishFlags (use multicast)\\n str(rrset.name).decode('utf-8'), #name\\n dbus.UInt16(record.rdclass), #class\\n dbus.UInt16(record.rdtype), #type\\n dbus.UInt32(rrset.ttl), #ttl\\n string_array_to_txt_array([record.to_digestable()])[0] #rdata\\n )\\n logging.info('added mDNS record to Avahi: %s' % rrset.to_text())\\n except UnicodeDecodeError:\\n logging.warn('malformed unicode in rdata, skipping: %s' % rrset.to_text())\\n except dbus.exceptions.DBusException, e:\\n if e.get_dbus_name() == 'org.freedesktop.Avahi.InvalidDomainNameError':\\n logging.warning('not mirroring mDNS record with special chars: %s' % rrset.to_text())\\n continue # skip this record since Avahi will reject it\\n # mac probably sent a device_info PTR with spaces and parentheses in the friendly description\\n # per https://tools.ietf.org/html/rfc6763#section-4.1.3\\n # fanboy\\\\032\\\\(2\\\\)._eppc._tcp.local. 4500 CLASS32769 TXT \\\"\\\" # `fanboy (2)`\\n # mDNS.c sends UTF8, dnspythom.from_wire() assumes ASCII, DBUS wants Unicode, Avahi only takes [a-zA-Z0-9.-]\\n # http://dbus.freedesktop.org/doc/dbus-python/api/dbus.String-class.html\\n # http://dbus.freedesktop.org/doc/dbus-python/api/dbus.UTF8String-class.html\\n # http://www.avahi.org/ticket/21 http://avahi.org/ticket/63\\n # http://git.0pointer.net/avahi.git/commit/?id=5c22acadcbe5b01d910d75b71e86e06a425172d3\\n # http://git.0pointer.net/avahi.git/commit/?id=ee2820a23c6968bbeadbdf510389301dca6bc765\\n # http://git.0pointer.net/avahi.git/tree/avahi-common/domain.c\\n raise\",\n \"def update_adgroup(self, adgroup_id, name=None, adgroup_status=None,\\n bid_type=None, bid_info=None, creative_id=None,\\n tracking_specs=None, view_tags=None, objective=None,\\n targeting=None, conversion_specs=None,\\n batch=False):\\n path = \\\"%s\\\" % adgroup_id\\n args = {}\\n if name:\\n args['name'] = name\\n if bid_type:\\n args['bid_type'] = bid_type\\n if bid_info:\\n args['bid_info'] = json.dumps(bid_info)\\n\\n if creative_id:\\n args['creative'] = json.dumps({'creative_id': creative_id})\\n if tracking_specs:\\n args['tracking_specs'] = json.dumps(tracking_specs)\\n if view_tags:\\n args['view_tags'] = json.dumps(view_tags)\\n if objective:\\n args['objective'] = objective\\n if adgroup_status:\\n args['adgroup_status'] = adgroup_status\\n if targeting:\\n args['targeting'] = json.dumps(targeting)\\n if conversion_specs:\\n args['conversion_specs'] = json.dumps(conversion_specs)\\n return self.make_request(path, 'POST', args, batch=batch)\",\n \"def regroup(self, serial, group):\\n api_page = \\\"/configuration/object/ap_regroup\\\"\\n url = \\\"{}{}?{}&UIDARUBA={}\\\".format(\\n self.base_url,\\n api_page,\\n self.config_path,\\n self.uidaruba)\\n\\n obj_dict = {'serial-num': serial, 'new-group': group}\\n obj_json = json.loads(json.dumps(obj_dict))\\n\\n resp = self.post(url, obj_json)\\n\\n print(resp.status_code)\\n print(resp.text)\",\n \"def qos_policy_group_rename(self, policy_group_name, new_name):\\n return self.request( \\\"qos-policy-group-rename\\\", {\\n 'policy_group_name': [ policy_group_name, 'policy-group-name', [ basestring, 'None' ], False ],\\n 'new_name': [ new_name, 'new-name', [ basestring, 'None' ], False ],\\n }, {\\n } )\",\n \"def slotGroupEdit(self):\\n dialog = GroupDialog(self)\\n if dialog.exec_loop() == QDialog.Accepted:\\n if dialog.group_id != None:\\n # set group\\n self.sampleGroup.globalGroupId = dialog.group_id\\n self.groupLabel.setText(dialog.group_id)\\n else:\\n # ungroup\\n self.sampleGroup.globalGroupId = None\\n self.groupLabel.setText('Not\\\\nGrouped')\\n self.emit(PYSIGNAL('groupChanged'), (self,))\",\n \"def cmd_album_update(client, args):\\n fields = data_fields(args, client.allowed_album_fields)\\n album = client.update_album(args.album_id, fields)\\n generate_output({'album': album})\",\n \"def test_user_group_controller_update(self):\\n pass\",\n \"def set_group(self, group: str) -> None:\\n self.group = group\",\n \"def test_products_ref_groups_put(self):\\n pass\",\n \"def append_group_info(record, groups):\\n record.INFO['IN_GROUP'] = groups\\n record.INFO['GROUP_ID'] = ''\\n return record\",\n \"def update(self, instance, validated_data):\\n\\n # Use an atomic transaction for managing dataset and authors\\n with transaction.atomic():\\n # pop off the authors data\\n if \\\"authors\\\" in validated_data.keys():\\n author_data = validated_data.pop('authors')\\n\\n instance._change_reason = 'Adding Authors to Dataset Metadata'\\n # remove the existing authors\\n Author.objects.filter(dataset_id=instance.id).delete() # delete first\\n self.add_authors(author_data, instance)\\n\\n instance._change_reason = 'Update Dataset Metadata'\\n\\n # Update Dataset metadata\\n super(self.__class__, self).update(instance=instance, validated_data=validated_data)\\n\\n return instance\",\n \"def check_group_description(our_group):\\n\\tgroup_id = our_group[\\\"groupId\\\"]\\n\\turl = f'{BASE_URL}/groups/{group_id}'\\n\\tresponse = call_api(url)\\n\\ttheir_description = response[\\\"description\\\"]\\n\\tif not their_description.startswith(PERUN_MANAGED):\\n\\t\\tnew_description = PERUN_MANAGED + their_description + \\\" | Manage in Perun: \\\" + our_group[\\\"perunResourceUrl\\\"]\\n\\telif their_description.startswith(PERUN_MANAGED) and not their_description.endswith(our_group[\\\"perunResourceUrl\\\"]):\\n\\t\\t# Resource ID changed in Perun, update description\\n\\t\\tnew_description = their_description.split(\\\" | Manage in Perun: \\\")\\n\\t\\tnew_description = new_description[0] + \\\" | Manage in Perun: \\\" + our_group[\\\"perunResourceUrl\\\"]\\n\\telse:\\n\\t\\treturn\\n\\tparams = {\\\"description\\\": new_description}\\n\\tcall_api(url, params, 'PATCH')\\n\\tprint_debug(f\\\"Description updated for group {group_id}\\\")\",\n \"def _mod_group(self, command, group_id, group_type, buckets=None):\\n self.datapath.send_msg(\\n self.parser.OFPGroupMod(\\n datapath=self.datapath,\\n command=command,\\n group_id=group_id,\\n type_=group_type,\\n buckets=buckets,\\n )\\n )\",\n \"def updateImageGroups(self):\\n self.img_grps = self.splitImages()\\n grps = self.img_grps\\n self.detail.clear()\\n detail = \\\"Available Groups : \\\\n\\\"\\n if len(grps) >= 1:\\n for i in range(len(grps)):\\n detail += \\\"Group \\\"+ str(i+1)+ \\\" : \\\" + str(grps[i][0]) + \\\" ... \\\" + str(grps[i][-1]) + '\\\\n'\\n\\n self.detail.insertPlainText(detail)\\n self.detail.moveCursor(QTextCursor.End)\",\n \"async def update_metadata(dbcon: DBConnection, object_type: str, object_id: int, metadict: Dict[str, str]):\\n\\n async def _run(cur: Cursor) -> None:\\n for key, value in metadict.items():\\n if value in [False, None]:\\n q = \\\"\\\"\\\"delete from object_metadata where object_type=%s and object_id=%s and `key`=%s\\\"\\\"\\\"\\n q_args = (object_type, object_id, str(key)) # type: Tuple\\n else:\\n q = \\\"\\\"\\\"replace into object_metadata (object_type, object_id, `key`, value) values (%s, %s, %s, %s)\\\"\\\"\\\"\\n q_args = (object_type, object_id, str(key), str(value))\\n await cur.execute(q, q_args)\\n\\n await dbcon.transact(_run)\",\n \"def test_sg_update_name(self):\\n\\n # Add a faked storage_group\\n faked_storage_group = self.add_storage_group1()\\n storage_group_name = faked_storage_group.name\\n\\n storage_group_mgr = self.console.storage_groups\\n storage_group = storage_group_mgr.find(name=storage_group_name)\\n\\n new_storage_group_name = \\\"new-\\\" + storage_group_name\\n\\n # Execute the code to be tested\\n storage_group.update_properties(\\n properties={'name': new_storage_group_name})\\n\\n # Verify that the resource is no longer found by its old name, using\\n # list() (this does not use the name-to-URI cache).\\n storage_groups_list = storage_group_mgr.list(\\n filter_args=dict(name=storage_group_name))\\n assert len(storage_groups_list) == 0\\n\\n # Verify that the resource is no longer found by its old name, using\\n # find() (this uses the name-to-URI cache).\\n with pytest.raises(NotFound):\\n storage_group_mgr.find(name=storage_group_name)\\n\\n # Verify that the resource object already reflects the update, even\\n # though it has not been refreshed yet.\\n assert storage_group.properties['name'] == new_storage_group_name\\n\\n # Refresh the resource object and verify that it still reflects the\\n # update.\\n storage_group.pull_full_properties()\\n assert storage_group.properties['name'] == new_storage_group_name\\n\\n # Verify that the resource can be found by its new name, using find()\\n new_storage_group_find = storage_group_mgr.find(\\n name=new_storage_group_name)\\n assert new_storage_group_find.properties['name'] == \\\\\\n new_storage_group_name\\n\\n # Verify that the resource can be found by its new name, using list()\\n new_storage_groups_list = storage_group_mgr.list(\\n filter_args=dict(name=new_storage_group_name))\\n assert len(new_storage_groups_list) == 1\\n new_storage_group_list = new_storage_groups_list[0]\\n assert new_storage_group_list.properties['name'] == \\\\\\n new_storage_group_name\",\n \"def update(self, data):\\n self.data = data\\n # extract data\\n subject = data.identifier\\n self.id = _uri_to_oai(subject)\\n self.modified = datetime.utcnow()\\n self.deleted = False\\n\\n itemtype, subtype = _get_itemtype(data, subject)\\n\\n self.metadata = {}\\n\\n # fixed fields:\\n self.metadata['rif_key'] = _uri_to_key(subject)\\n self.metadata['rif_group'] = self.provider.groupDescription\\n self.metadata['rif_originatingSource'] = self.provider.originatingSource\\n self.metadata['rif_object'] = {'value': itemtype,\\n 'type': subtype,\\n #'dateModified': '',\\n }\\n\\n if itemtype == 'collection':\\n self.updateCollection(data, subject)\\n elif itemtype == 'party':\\n if subtype == 'person':\\n self.updatePartyPerson(data, subject)\\n else:\\n self.updateParty(data, subject)\\n elif itemtype == 'activity':\\n self.updateActivity(data, subject)\\n elif itemtype == 'service':\\n self.updateService(data, subject)\",\n \"def setGroup(self, group):\\n\\t\\tself.config.GROUP = group\",\n \"def update_metadata(self, file_id, metadata):\\n pass\",\n \"def update(context, namespace_name, id, values, session):\\n namespace_api.get(context, namespace_name, session)\\n\\n metadata_tag = _get(context, id, session)\\n metadef_utils.drop_protected_attrs(models.MetadefTag, values)\\n # values['updated_at'] = timeutils.utcnow() - done by TS mixin\\n try:\\n metadata_tag.update(values.copy())\\n metadata_tag.save(session=session)\\n except db_exc.DBDuplicateEntry:\\n LOG.debug(\\\"Invalid update. It would result in a duplicate\\\"\\n \\\" metadata tag with same name=%(name)s\\\"\\n \\\" in namespace=%(namespace_name)s.\\\",\\n {'name': values['name'],\\n 'namespace_name': namespace_name})\\n raise exc.MetadefDuplicateTag(\\n name=values['name'], namespace_name=namespace_name)\\n\\n return metadata_tag.to_dict()\",\n \"def add_group_data(self, group_name):\\n self.sorted = False\\n self.grouped = False\\n self.labels_to_add = []\\n for path in self.all_groups.get(group_name):\\n io = NWBHDF5IO(path, 'r')\\n nwb_file = io.read()\\n # self.labels.append(nwb_file.identifier)\\n self.nwb_path_list.update({nwb_file.identifier: path})\\n self.labels_to_add.append(nwb_file.identifier)\\n self.musketeers_widget.session_widget.populate(self.labels_to_add, 'add')\\n self.musketeers_widget.session_widget.update_text_filter()\\n self.groupMenu.setEnabled(True)\\n self.sortMenu.setEnabled(True)\",\n \"def update_from_qai(self) -> dict:\\n qaisession = self.qaisession\\n if qaisession is None or not qaisession.is_logged_in():\\n return dict(ok=False, msg=\\\"User not logged in\\\")\\n # get the locally stored timestamp data from our database\\n cur_tsdata = self.get_ts_data()\\n try:\\n newds = qai_helper.QAIDataset(None, cur_tsdata)\\n except RuntimeError as err:\\n return dict(ok=False, msg=\\\"QAI access error: {}\\\".format(str(err)))\\n # load those parts from QAI that are out of date\\n update_dct = qaisession.clever_update_qai_dump(newds)\\n # if any value is True, then we did get something from QAI...\\n num_updated = sum(update_dct.values())\\n if num_updated > 0:\\n try:\\n self._db_has_changed = self.load_qai_data(newds, update_dct)\\n except TypeError as err:\\n return dict(ok=False, msg=\\\"database error: {}\\\".format(str(err)))\\n return dict(ok=True, msg=\\\"Successfully updated {} tables for QAI\\\".format(num_updated))\",\n \"def with_group(self, group):\\n\\t\\tself.variables['group'] = group\\n\\t\\treturn self\",\n \"def add_to_group(self, org, contact, group):\\n pass\",\n \"def metadata_update(self, new_metadata=None):\\n if new_metadata is None:\\n self.metadata_set(self.t.metadata())\",\n \"def update_groups(self, groups):\\n self.fetch_group_messages() # preload messages before updating groups\\n self.groups = groups\\n self.put()\",\n \"def update_atom_metadata(self, atom_name, update_with):\\n self._update_atom_metadata(atom_name, update_with)\",\n \"def test_ipam_aggregates_update(self):\\n pass\",\n \"def update_metadata(sess, asset_link):\\n get_json = sess.get(asset_link).json()\\n update_metadata = get_json['customFields']\\n update_metadata['SANDAG Last Access Date'] = datetime.datetime.today().strftime('%D')\\n\\n sess.patch(asset_link, \\n data=json.dumps(update_metadata)).json()\",\n \"def _update_aggregate_dataset(self, formula, new_dframe, name, groups,\\n agg_dataset):\\n # parse aggregation and build column arguments\\n aggregation, new_columns = self.make_columns(\\n formula, name, new_dframe)\\n\\n agg = Aggregator(self.dataset, self.dframe,\\n groups, aggregation, name)\\n new_agg_dframe = agg.update(agg_dataset, self, formula, new_columns)\\n\\n # jsondict from new dframe\\n new_data = new_agg_dframe.to_jsondict()\\n\\n for merged_dataset in agg_dataset.merged_datasets:\\n # remove rows in child from this merged dataset\\n merged_dataset.remove_parent_observations(\\n agg_dataset.dataset_id)\\n\\n # calculate updates on the child\\n merged_calculator = Calculator(merged_dataset)\\n call_async(merged_calculator.calculate_updates, merged_calculator,\\n new_data, parent_dataset_id=agg_dataset.dataset_id)\",\n \"def test_update_groups_Passes_correct_data_to_modify_groups_file(\\n self, mock_modify_groups_file , mock_read_groups_file\\n ):\\n mock_modify_groups_file.return_value = True\\n mock_read_groups_file.return_value = self.groups_data\\n\\n crud = CRUD()\\n crud.update_groups(\\\"1\\\", \\\"name\\\", \\\"new_data\\\")\\n mock_modify_groups_file.assert_called_once_with(self.groups_data)\",\n \"def test_update_metadata(self):\\r\\n locator = BlockUsageLocator(\\r\\n CourseLocator(org=\\\"testx\\\", offering=\\\"GreekHero\\\", branch='draft'),\\r\\n 'problem', block_id=\\\"problem3_2\\\"\\r\\n )\\r\\n problem = modulestore().get_item(locator)\\r\\n pre_def_id = problem.definition_locator.definition_id\\r\\n pre_version_guid = problem.location.version_guid\\r\\n self.assertIsNotNone(pre_def_id)\\r\\n self.assertIsNotNone(pre_version_guid)\\r\\n self.assertNotEqual(problem.max_attempts, 4, \\\"Invalidates rest of test\\\")\\r\\n\\r\\n problem.max_attempts = 4\\r\\n problem.save() # decache above setting into the kvs\\r\\n updated_problem = modulestore().update_item(problem, '**replace_user**')\\r\\n # check that course version changed and course's previous is the other one\\r\\n self.assertEqual(updated_problem.definition_locator.definition_id, pre_def_id)\\r\\n self.assertNotEqual(updated_problem.location.version_guid, pre_version_guid)\\r\\n self.assertEqual(updated_problem.max_attempts, 4)\\r\\n # refetch to ensure original didn't change\\r\\n original_location = problem.location.map_into_course(CourseLocator(version_guid=pre_version_guid))\\r\\n problem = modulestore().get_item(original_location)\\r\\n self.assertNotEqual(problem.max_attempts, 4, \\\"original changed\\\")\\r\\n\\r\\n current_course = modulestore().get_course(locator.course_key)\\r\\n self.assertEqual(updated_problem.location.version_guid, current_course.location.version_guid)\\r\\n\\r\\n history_info = modulestore().get_course_history_info(current_course.location)\\r\\n self.assertEqual(history_info['previous_version'], pre_version_guid)\\r\\n self.assertEqual(history_info['edited_by'], \\\"**replace_user**\\\")\",\n \"def update_mp3_metadata(self, mp3_file):\\n if isinstance(mp3_file, str):\\n mp3_file = mp3_utility.Mp3File(file_path=mp3_file, load_tags_from_file=True)\\n remote_name = self.get_remote_name(mp3_file.file_path)\\n archive_item_file_details = self.item_files_dict.get(remote_name, None)\\n mp3_metadata = mp3_file.metadata\\n if archive_item_file_details is None:\\n logging.warning(\\\"The file does not exist! Skipping.\\\")\\n else:\\n remote_tag_update_needed = (archive_item_file_details.get(\\\"artist\\\", \\\"\\\") != mp3_metadata.artist) or (\\n archive_item_file_details.get(\\\"creator\\\", \\\"\\\") != mp3_metadata.artist) or (\\n archive_item_file_details.get(\\\"title\\\", \\\"\\\") != mp3_metadata.title) or (\\n archive_item_file_details.get(\\\"album\\\", \\\"\\\") != mp3_metadata.album) or (\\n archive_item_file_details.get(\\\"album_artist\\\",\\n \\\"\\\") != mp3_metadata.album_artist)\\n if remote_tag_update_needed:\\n logging.info(\\\"***Updating %s in archive item.\\\" % remote_name)\\n logging.info(\\n internetarchive.modify_metadata(\\n self.archive_id,\\n metadata=dict(title=mp3_metadata.title, album=mp3_metadata.album,\\n album_artist=mp3_metadata.album_artist,\\n artist=mp3_metadata.artist, creator=mp3_metadata.artist),\\n target=os.path.join(\\\"files\\\", remote_name)))\",\n \"def upsert_group(self,\\n group, # type: Group\\n *options, # type: UpsertGroupOptions\\n **kwargs # type: Any\\n ):\\n # This endpoint accepts application/x-www-form-urlencoded and requires the data be sent as form data.\\n # The name/id should not be included in the form data.\\n # Roles should be a comma separated list of strings.\\n # If, only if, the role contains a bucket name then the rolename should be suffixed\\n # with[<bucket_name>] e.g. bucket_full_access[default],security_admin.\\n\\n final_args = forward_args(kwargs, *options)\\n final_args.update({k: v for k, v in group.as_dict.items() if k in {\\n 'roles', 'description', 'ldap_group_reference'}})\\n self._admin_bucket.group_upsert(group.name, **final_args)\",\n \"def update(person_group_id, name=None, user_data=None):\\n url = 'persongroups/{}'.format(person_group_id)\\n json = {\\n 'name': name,\\n 'userData': user_data,\\n }\\n\\n return util.request('PATCH', url, json=json)\",\n \"def append_group_attr(self, analyte: str, group_name: str, key: str, value: Any):\\n group_path = \\\"/\\\".join([\\\"\\\", ASSAYS, analyte, group_name])\\n if group_path not in self.__file:\\n raise ValueError(\\\"{} missing\\\".format(group_path))\\n group = self.__file[group_path]\\n if key in group.keys():\\n key_path = group_path + \\\"/\\\" + key\\n data = self.__file[key_path]\\n normalized = normalize_attr_values(value)\\n data[...] = normalized\\n else:\\n self.__write_value(group, key, value)\",\n \"def test_set_add_updates_new_record(self):\\r\\n partition = uuid4()\\r\\n cluster = 1\\r\\n TestQueryUpdateModel.objects(\\r\\n partition=partition, cluster=cluster).update(text_set__add={'bar'})\\r\\n obj = TestQueryUpdateModel.objects.get(partition=partition, cluster=cluster)\\r\\n self.assertEqual(obj.text_set, {\\\"bar\\\"})\",\n \"def replaceMetadata(self, obj, dom):\\n self.update_semantics = 'replace'\\n # create a metadata dict that has all the defaults, overridden by the\\n # current dom values. This way we will 'clear' the properties not in\\n # the dom.\\n metadata = copy(METADATA_DEFAULTS)\\n metadata.update(self.getMetadata(dom, METADATA_MAPPING))\\n if metadata:\\n self.validate_metadata(metadata)\\n metadata = self.fixEntities(metadata, ATTRIBUTES_TO_FIX)\\n if ICollection.providedBy(obj):\\n obj.collection_metadata(**metadata)\\n elif IModule.providedBy(obj):\\n obj.update_metadata(**metadata)\\n # we set GoogleAnalyticsTrackingCode explicitly, since the script\\n # 'update_metadata' ignores empty strings.\\n obj.GoogleAnalyticsTrackingCode = metadata.get('GoogleAnalyticsTrackingCode')\\n self.updateRoles(obj, dom)\\n obj.reindexObject(idxs=metadata.keys())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62396324","0.5877734","0.576575","0.57327974","0.57194453","0.56374407","0.56304944","0.54979336","0.5483407","0.5479937","0.54672974","0.5455434","0.54246724","0.54197586","0.54063433","0.5388485","0.5379117","0.5371604","0.5357497","0.5346416","0.53452957","0.53372353","0.53215736","0.53035235","0.52948254","0.52580935","0.5234045","0.52254593","0.51868767","0.51606685","0.5134078","0.5115346","0.5110202","0.50848323","0.50735044","0.5072201","0.5057947","0.5055361","0.50475544","0.5046963","0.501223","0.49742705","0.4968892","0.49423423","0.49351263","0.49266756","0.49040642","0.48952243","0.4881949","0.48699212","0.48662695","0.48624316","0.48514888","0.48505116","0.48502085","0.48489025","0.48350734","0.4834348","0.48334107","0.4829574","0.4829574","0.4829574","0.48006535","0.47767","0.47760844","0.4775953","0.47643992","0.47631004","0.47627214","0.4760684","0.47581863","0.47574696","0.4753418","0.47449547","0.47390085","0.4728673","0.4726573","0.47183266","0.47118467","0.47115391","0.4709075","0.4702393","0.47018242","0.4698677","0.46922493","0.46920416","0.46916533","0.46904752","0.4690141","0.46877775","0.468709","0.46750745","0.4673622","0.46700627","0.46619272","0.4656678","0.46559682","0.46510315","0.4648337","0.4644038"],"string":"[\n \"0.62396324\",\n \"0.5877734\",\n \"0.576575\",\n \"0.57327974\",\n \"0.57194453\",\n \"0.56374407\",\n \"0.56304944\",\n \"0.54979336\",\n \"0.5483407\",\n \"0.5479937\",\n \"0.54672974\",\n \"0.5455434\",\n \"0.54246724\",\n \"0.54197586\",\n \"0.54063433\",\n \"0.5388485\",\n \"0.5379117\",\n \"0.5371604\",\n \"0.5357497\",\n \"0.5346416\",\n \"0.53452957\",\n \"0.53372353\",\n \"0.53215736\",\n \"0.53035235\",\n \"0.52948254\",\n \"0.52580935\",\n \"0.5234045\",\n \"0.52254593\",\n \"0.51868767\",\n \"0.51606685\",\n \"0.5134078\",\n \"0.5115346\",\n \"0.5110202\",\n \"0.50848323\",\n \"0.50735044\",\n \"0.5072201\",\n \"0.5057947\",\n \"0.5055361\",\n \"0.50475544\",\n \"0.5046963\",\n \"0.501223\",\n \"0.49742705\",\n \"0.4968892\",\n \"0.49423423\",\n \"0.49351263\",\n \"0.49266756\",\n \"0.49040642\",\n \"0.48952243\",\n \"0.4881949\",\n \"0.48699212\",\n \"0.48662695\",\n \"0.48624316\",\n \"0.48514888\",\n \"0.48505116\",\n \"0.48502085\",\n \"0.48489025\",\n \"0.48350734\",\n \"0.4834348\",\n \"0.48334107\",\n \"0.4829574\",\n \"0.4829574\",\n \"0.4829574\",\n \"0.48006535\",\n \"0.47767\",\n \"0.47760844\",\n \"0.4775953\",\n \"0.47643992\",\n \"0.47631004\",\n \"0.47627214\",\n \"0.4760684\",\n \"0.47581863\",\n \"0.47574696\",\n \"0.4753418\",\n \"0.47449547\",\n \"0.47390085\",\n \"0.4728673\",\n \"0.4726573\",\n \"0.47183266\",\n \"0.47118467\",\n \"0.47115391\",\n \"0.4709075\",\n \"0.4702393\",\n \"0.47018242\",\n \"0.4698677\",\n \"0.46922493\",\n \"0.46920416\",\n \"0.46916533\",\n \"0.46904752\",\n \"0.4690141\",\n \"0.46877775\",\n \"0.468709\",\n \"0.46750745\",\n \"0.4673622\",\n \"0.46700627\",\n \"0.46619272\",\n \"0.4656678\",\n \"0.46559682\",\n \"0.46510315\",\n \"0.4648337\",\n \"0.4644038\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.647164"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83161,"cells":{"query":{"kind":"string","value":"updates metadata for a specific target"},"document":{"kind":"string","value":"def metadata_update_targets(targets):\n filenames = []\n for target in targets:\n if target == 'stable':\n filename = _generate_metadata_kind('firmware.xml.gz', targets=['stable'])\n filenames.append(filename)\n elif target == 'testing':\n filename = _generate_metadata_kind('firmware-testing.xml.gz', targets=['stable', 'testing'])\n filenames.append(filename)\n\n # return all the files we have to sign\n return filenames"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _metadata_update_targets(targets):\n affidavit = _create_affidavit()\n firmwares = db.firmware.get_all()\n for target in targets:\n firmwares_filtered = []\n for f in firmwares:\n if f.target == 'private':\n continue\n if f.target != target:\n continue\n firmwares_filtered.append(f)\n if target == 'stable':\n _generate_metadata_kind('firmware.xml.gz',\n firmwares_filtered,\n affidavit=affidavit)\n elif target == 'testing':\n _generate_metadata_kind('firmware-testing.xml.gz',\n firmwares_filtered,\n affidavit=affidavit)","def update_metadata(self, file_id, metadata):\n pass","def update_target(self):\n pass","def metadata_update(self, new_metadata=None):\n if new_metadata is None:\n self.metadata_set(self.t.metadata())","def update_metadata(self, metadata: t.Mapping[str, str]) -> None:\n self._metadata.update(metadata)","def test_update_metadata(self):\n pass","def update_metadata(self, metadata):\n return self.manager.update_metadata(self, metadata)","def test_update_metadata1(self):\n pass","def update_metadata(self, key, value):\n sp.verify(self.is_administrator(sp.sender), FA12_Error.NotAdmin)\n self.data.metadata[key] = value","def update_metadata(self, metadata):\n return self.parent.update_metadata_for_node(self, metadata)","def target_update(obj, target_uri, sli_name, target_from, target_to, target_file):\n client = get_client(obj)\n\n target = client.target_get(target_uri)\n if not target:\n fatal_error('Target {} does not exist'.format(target_uri))\n\n product = client.product_list(name=target['product_name'])[0]\n\n sli = client.sli_list(product=product, name=sli_name)\n if not sli:\n fatal_error('SLI {} does not exist'.format(sli_name))\n sli = sli[0]\n\n with Action('Updating Target {} for product {}'.format(target_uri, target['product_name']), nl=True) as act:\n if target_file:\n target = json.load(target_file)\n else:\n if sli_name:\n target['sli_uri'] = sli['uri']\n if target_from:\n target['from'] = target_from\n if target_to:\n target['to'] = target_to\n\n validate_target(target, act)\n\n if not act.errors:\n target = client.target_update(target)\n\n print(json.dumps(target, indent=4))","def test_update_metadata_by_attribute(self):\n pass","def update(self, target, query):\n node = self._data[target]\n name = \"%s node %.8s\" % (node['type'], target)\n\n query.update({\n 'type': node['type'],\n 'model': node['model']\n })\n\n logger.info(\"Validating query\")\n NodeValidator.validate(query)\n\n self._data[target] = dict_update(node, query, name)\n logger.info(\"Updated parameters above of %s\" % name)\n\n return {target: self._data[target]}","def _set_target_info_by_name(self, targets, port, target_name, iqn):\n host_iqn_registered_in_target = (\n self._get_host_iqn_registered_in_target_by_name(\n port, target_name, iqn))\n if host_iqn_registered_in_target:\n gid = host_iqn_registered_in_target['hostGroupNumber']\n storage_iqn = self.client.get_host_grp(port, gid)['iscsiName']\n targets['info'][port] = True\n targets['list'].append((port, gid))\n targets['iqns'][(port, gid)] = storage_iqn\n return True\n return False","def set_metadata(self, metadata):\n return self.client._perform_json(\n \"PUT\", \"/projects/%s/recipes/%s/metadata\" % (self.project_key, self.recipe_name),\n body=metadata)","def test_update_metadata_by_attribute1(self):\n pass","def update(self, target):\n self.target = target.detach()","def update_metadata(self, corpus_id, meta_data, save_to_cache=True):\n logger.info('Updating meta data for corpus \"%s\"' % corpus_id)\n corpus = self.get_corpus(corpus_id, check_s3=True, use_cache=True)\n\n # Loop and add/overwrite meta data key value pairs\n for k, v in meta_data.items():\n corpus.meta_data[k] = v\n\n if save_to_cache:\n meta_file_key = '%s/%s/%s.json' % (default_key_base,\n corpus_id,\n file_defaults['meta'])\n corpus._save_to_cache(meta=meta_file_key)","def target(self, target) :\n\t\ttry :\n\t\t\tself._target = target\n\t\texcept Exception as e:\n\t\t\traise e","def target(self, target) :\n\t\ttry :\n\t\t\tself._target = target\n\t\texcept Exception as e:\n\t\t\traise e","def metadata_update(self, _):\n self.details.original_widget = YesNoWidget('Update metadata files?', self.__metadata_update)","def target(self, target):\n\n self._target = target","async def _edittarget_heist(self, ctx, *, target: str):\r\n author = ctx.message.author\r\n guild = ctx.guild\r\n target = string.capwords(target)\r\n targets = await self.thief.get_guild_targets(guild)\r\n\r\n if target not in targets:\r\n return await ctx.send(\"That target does not exist.\")\r\n\r\n keys = [x for x in targets[target]]\r\n keys.append(\"Name\")\r\n check = lambda m: m.content.title() in keys and m.author == author\r\n\r\n await ctx.send(\"Which property of {} would you like to edit?\\n\"\r\n \"{}\".format(target, \", \".join(keys)))\r\n\r\n response = await self.bot.wait_for('MESSAGE', timeout=15, check=check)\r\n\r\n if response is None:\r\n return await ctx.send(\"Canceling removal. You took too long.\")\r\n\r\n if response.content.title() == \"Name\":\r\n await ctx.send(\"What would you like to rename the target to?\\n*Cannot be a name \"\r\n \"currently in use.*\")\r\n check2 = lambda m: string.capwords(m.content) not in targets and m.author == author\r\n\r\n elif response.content.title() in [\"Vault\", \"Vault Max\"]:\r\n await ctx.send(\"What would you like to set the {} \"\r\n \"to?\".format(response.content.title()))\r\n check2 = lambda m: m.content.isdigit() and int(m.content) > 0 and m.author == author\r\n\r\n elif response.content.title() == \"Success\":\r\n await ctx.send(\"What would you like to change the success rate to?\")\r\n check2 = lambda m: m.content.isdigit() and 0 < int(m.content) <= 100 and m.author == author\r\n\r\n elif response.content.title() == \"Crew\":\r\n await ctx.send(\"What would you like to change the max crew size to?\\n Cannot be \"\r\n \"the same as another target and will be the maximum number of \"\r\n \"players for that target.\")\r\n crew_sizes = [subdict[\"Crew\"] for subdict in targets.values()]\r\n check2 = lambda m: m.content.isdigit() and int(m.content) not in crew_sizes and m.author == author\r\n\r\n choice = await self.bot.wait_for('MESSAGE', timeout=15, check=check2)\r\n\r\n if choice is None:\r\n return await ctx.send(\"Canceling removal. You took too long.\")\r\n\r\n if response.content.title() == \"Name\":\r\n new_name = string.capwords(choice.content)\r\n targets[new_name] = targets.pop(target)\r\n await self.thief.save_targets(guild, targets)\r\n await ctx.send(\"Changed {}'s {} to {}.\".format(target, response.content,\r\n choice.content))\r\n else:\r\n targets[target][response.content.title()] = int(choice.content)\r\n await self.thief.save_targets(guild, targets)\r\n await ctx.send(\"Changed {}'s {} to {}.\".format(target, response.content,\r\n choice.content))","def update_metadata(state, name, wid, file_id, metadata_file):\n\n client = state.api_client\n\n # Get the workspace details\n w_details = helpers.workspace.details(client, wid, name)\n if w_details is None:\n # Can only happen when the name is used and there are no results. Not\n # with the wid option because it would raise a 404 QuetzalAPIException\n raise click.ClickException(f'Workspace named \"{name}\" does not exist.')\n\n metadata_contents = json.load(metadata_file)\n response = client.workspace_file_update_metadata(wid=w_details.id, uuid=file_id,\n body=metadata_contents)\n click.secho(f'Metadata for file {file_id} successfully changed.', fg='green')\n click.secho('Updated metadata:')\n click.secho(json.dumps(response, indent=2), fg='blue')","def update_flow_metadata(self, update_with):\n if update_with:\n source, clone = self._fetch_flowdetail(clone=True)\n clone.meta.update(update_with)\n self._with_connection(self._save_flow_detail, source, clone)","def _update_target(self):\n self.target_dqn.load_state_dict(self.dqn.state_dict())","def target_name(self, target_name):\n\n self._target_name = target_name","def target_name(self, target_name):\n\n self._target_name = target_name","def _update_metadata_if_changed(self, metadata_role, referenced_metadata='release'):\n \n uncompressed_metadata_filename = metadata_role + '.txt'\n\n # Ensure the referenced metadata has been loaded. The 'root' role may be\n # updated without having 'release' available. \n if referenced_metadata not in self.metadata['current']:\n message = 'Cannot update '+repr(metadata_role)+' because ' \\\n +referenced_metadata+' is missing.'\n raise tuf.RepositoryError(message)\n # The referenced metadata has been loaded. Extract the new\n # fileinfo for 'metadata_role' from it. \n else:\n message = repr(metadata_role)+' referenced in '+\\\n repr(referenced_metadata)+'. '+repr(metadata_role)+' may be updated.'\n logger.debug(message)\n \n # There might be a compressed version of 'release.txt' or Targets\n # metadata available for download. Check the 'meta' field of\n # 'referenced_metadata' to see if it is listed when 'metadata_role'\n # is 'release'. The full rolename for delegated Targets metadata\n # must begin with 'targets/'. The Release role lists all the Targets\n # metadata available on the repository, including any that may be in\n # compressed form.\n compression = None\n\n # Extract the fileinfo of the uncompressed version of 'metadata_role'.\n uncompressed_fileinfo = self.metadata['current'][referenced_metadata] \\\n ['meta'] \\\n [uncompressed_metadata_filename]\n\n # Check for availability of compressed versions of 'release.txt',\n # 'targets.txt', and delegated Targets, which also start with 'targets'.\n # For 'targets.txt' and delegated metadata, 'referenced_metata'\n # should always be 'release'. 'release.txt' specifies all roles\n # provided by a repository, including their file sizes and hashes.\n if metadata_role == 'release' or metadata_role.startswith('targets'):\n gzip_metadata_filename = uncompressed_metadata_filename + '.gz'\n if gzip_metadata_filename in self.metadata['current'] \\\n [referenced_metadata]['meta']:\n compression = 'gzip'\n compressed_fileinfo = self.metadata['current'][referenced_metadata] \\\n ['meta'][gzip_metadata_filename]\n # NOTE: When we download the compressed file, we care about its\n # compressed length. However, we check the hash of the uncompressed\n # file; therefore we use the hashes of the uncompressed file.\n fileinfo = {'length': compressed_fileinfo['length'],\n 'hashes': uncompressed_fileinfo['hashes']}\n logger.debug('Compressed version of '+\\\n repr(uncompressed_metadata_filename)+' is available at '+\\\n repr(gzip_metadata_filename)+'.')\n else:\n logger.debug('Compressed version of '+\\\n repr(uncompressed_metadata_filename)+' not available.')\n fileinfo = uncompressed_fileinfo\n else:\n fileinfo = uncompressed_fileinfo\n\n # Simply return if the file has not changed, according to the metadata\n # about the uncompressed file provided by the referenced metadata.\n if not self._fileinfo_has_changed(uncompressed_metadata_filename,\n uncompressed_fileinfo):\n return\n\n logger.debug('Metadata '+repr(uncompressed_metadata_filename)+\\\n ' has changed.')\n\n try:\n self._update_metadata(metadata_role, fileinfo=fileinfo,\n compression=compression)\n except:\n # The current metadata we have is not current but we couldn't\n # get new metadata. We shouldn't use the old metadata anymore.\n # This will get rid of in-memory knowledge of the role and\n # delegated roles, but will leave delegated metadata files as\n # current files on disk.\n # TODO: Should we get rid of the delegated metadata files?\n # We shouldn't need to, but we need to check the trust\n # implications of the current implementation.\n self._delete_metadata(metadata_role)\n logger.error('Metadata for '+str(metadata_role)+' could not be updated')\n raise\n else:\n # We need to remove delegated roles because the delegated roles\n # may not be trusted anymore.\n if metadata_role == 'targets' or metadata_role.startswith('targets/'):\n logger.debug('Removing delegated roles of '+repr(metadata_role)+'.')\n # TODO: Should we also remove the keys of the delegated roles?\n tuf.roledb.remove_delegated_roles(metadata_role)\n self._import_delegations(metadata_role)","def set_metadata(self, data):\r\n pass","def _update_metadata(self, metadata_role, fileinfo, compression=None):\n\n # Construct the metadata filename as expected by the download/mirror modules.\n metadata_filename = metadata_role + '.txt'\n uncompressed_metadata_filename = metadata_filename\n \n # The 'release' or Targets metadata may be compressed. Add the appropriate\n # extension to 'metadata_filename'. \n if compression == 'gzip':\n metadata_filename = metadata_filename + '.gz'\n\n # Extract file length and file hashes. They will be passed as arguments\n # to 'download_file' function.\n compressed_file_length = fileinfo['length']\n uncompressed_file_hashes = fileinfo['hashes']\n\n # Attempt a file download from each mirror until the file is downloaded and\n # verified. If the signature of the downloaded file is valid, proceed,\n # otherwise log a warning and try the next mirror. 'metadata_file_object'\n # is the file-like object returned by 'download.py'. 'metadata_signable'\n # is the object extracted from 'metadata_file_object'. Metadata saved to\n # files are regarded as 'signable' objects, conformant to\n # 'tuf.formats.SIGNABLE_SCHEMA'.\n #\n # Some metadata (presently timestamp) will be downloaded \"unsafely\", in the\n # sense that we can only estimate its true length and know nothing about\n # its hashes. This is because not all metadata will have other metadata\n # for it; otherwise we will have an infinite regress of metadata signing\n # for each other. In this case, we will download the metadata up to the\n # best length we can get for it, not check its hashes, but perform the rest\n # of the checks (e.g signature verification).\n #\n # Note also that we presently support decompression of only \"safe\"\n # metadata, but this is easily extend to \"unsafe\" metadata as well as\n # \"safe\" targets.\n\n if metadata_role == 'timestamp':\n metadata_file_object = \\\n self.unsafely_get_metadata_file(metadata_role, metadata_filename,\n compressed_file_length)\n else:\n metadata_file_object = \\\n self.safely_get_metadata_file(metadata_role, metadata_filename,\n compressed_file_length,\n uncompressed_file_hashes,\n compression=compression)\n\n # The metadata has been verified. Move the metadata file into place.\n # First, move the 'current' metadata file to the 'previous' directory\n # if it exists.\n current_filepath = os.path.join(self.metadata_directory['current'],\n metadata_filename)\n current_filepath = os.path.abspath(current_filepath)\n tuf.util.ensure_parent_dir(current_filepath)\n \n previous_filepath = os.path.join(self.metadata_directory['previous'],\n metadata_filename)\n previous_filepath = os.path.abspath(previous_filepath)\n if os.path.exists(current_filepath):\n # Previous metadata might not exist, say when delegations are added.\n tuf.util.ensure_parent_dir(previous_filepath)\n shutil.move(current_filepath, previous_filepath)\n\n # Next, move the verified updated metadata file to the 'current' directory.\n # Note that the 'move' method comes from tuf.util's TempFile class.\n # 'metadata_file_object' is an instance of tuf.util.TempFile.\n metadata_signable = tuf.util.load_json_string(metadata_file_object.read())\n if compression == 'gzip':\n current_uncompressed_filepath = \\\n os.path.join(self.metadata_directory['current'],\n uncompressed_metadata_filename)\n current_uncompressed_filepath = \\\n os.path.abspath(current_uncompressed_filepath)\n metadata_file_object.move(current_uncompressed_filepath)\n else:\n metadata_file_object.move(current_filepath)\n\n # Extract the metadata object so we can store it to the metadata store.\n # 'current_metadata_object' set to 'None' if there is not an object\n # stored for 'metadata_role'.\n updated_metadata_object = metadata_signable['signed']\n current_metadata_object = self.metadata['current'].get(metadata_role)\n\n # Finally, update the metadata and fileinfo stores.\n logger.debug('Updated '+repr(current_filepath)+'.')\n self.metadata['previous'][metadata_role] = current_metadata_object\n self.metadata['current'][metadata_role] = updated_metadata_object\n self._update_fileinfo(metadata_filename)","def target_id(self, target_id):\n\n self._target_id = target_id","def update_pkg_metadata(self, pkg, version=None, **kwargs):\n pass","def update_targets_with_http_info(self, target, **kwargs):\n\n all_params = ['target', 'ids', 'names']\n all_params.append('callback')\n all_params.append('_return_http_data_only')\n all_params.append('_preload_content')\n all_params.append('_request_timeout')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method update_targets\" % key\n )\n params[key] = val\n del params['kwargs']\n # verify the required parameter 'target' is set\n if ('target' not in params) or (params['target'] is None):\n raise ValueError(\"Missing the required parameter `target` when calling `update_targets`\")\n\n\n collection_formats = {}\n\n path_params = {}\n\n query_params = []\n if 'ids' in params:\n query_params.append(('ids', params['ids']))\n collection_formats['ids'] = 'csv'\n if 'names' in params:\n query_params.append(('names', params['names']))\n collection_formats['names'] = 'csv'\n\n header_params = {}\n\n form_params = []\n local_var_files = {}\n\n body_params = None\n if 'target' in params:\n body_params = params['target']\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = ['AuthTokenHeader']\n\n return self.api_client.call_api('/1.9/targets', 'PATCH',\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=local_var_files,\n response_type='TargetResponse',\n auth_settings=auth_settings,\n callback=params.get('callback'),\n _return_http_data_only=params.get('_return_http_data_only'),\n _preload_content=params.get('_preload_content', True),\n _request_timeout=params.get('_request_timeout'),\n collection_formats=collection_formats)","def update_metadata(self):\n self.data[\"keywords\"] = self.repo.topics(self.data.get(\"keywords\", []))\n self.data[\"description\"] = self.data.get(\"description\") or self.repo.description\n self.data[\"codeRepository\"] = (\n self.data.get(\"codeRepository\") or self.repo.html_url\n )\n self.data[\"name\"] = self.data.get(\"name\") or self.repo.name\n self.data[\"issueTracker\"] = (\n self.data.get(\"issueTracker\") or self.repo.issues_url\n )\n self.data[\"license\"] = self.data.get(\"license\") or self.repo.license","def update_versioned_target(self, vt):\n self._cache_manager.update(vt.cache_key)","def replaceMetadata(self, obj, dom):\n self.update_semantics = 'replace'\n # create a metadata dict that has all the defaults, overridden by the\n # current dom values. This way we will 'clear' the properties not in\n # the dom.\n metadata = copy(METADATA_DEFAULTS)\n metadata.update(self.getMetadata(dom, METADATA_MAPPING))\n if metadata:\n self.validate_metadata(metadata)\n metadata = self.fixEntities(metadata, ATTRIBUTES_TO_FIX)\n if ICollection.providedBy(obj):\n obj.collection_metadata(**metadata)\n elif IModule.providedBy(obj):\n obj.update_metadata(**metadata)\n # we set GoogleAnalyticsTrackingCode explicitly, since the script\n # 'update_metadata' ignores empty strings.\n obj.GoogleAnalyticsTrackingCode = metadata.get('GoogleAnalyticsTrackingCode')\n self.updateRoles(obj, dom)\n obj.reindexObject(idxs=metadata.keys())","def setTarget(self, target):\n\n self._target = target","def target_description(self, target_description):\n\n self._target_description = target_description","def update_metadata(self, loadbalancer, metadata):\n return loadbalancer.update_metadata(metadata)","def set_metadata(self, key, val):\n \n self.metadata[key] = val","def SetTarget(self, entity):\n\t\tself.target = entity","def change_metadata(self, **kwargs):\n metadata = self.state.get_player_state(PLAYER_IDENTIFIER)\n\n # Update saved metadata\n for key, value in kwargs.items():\n setattr(metadata, key, value)\n\n # Create a temporary metadata instance with requested parameters\n change = PlayingState(**kwargs)\n self.state.item_update(change, PLAYER_IDENTIFIER)","def metadata(self, metadata):\n\n self._metadata = metadata","def metadata(self, metadata):\n\n self._metadata = metadata","def metadata(self, metadata):\n\n self._metadata = metadata","def metadata(self, metadata):\n\n self._metadata = metadata","def metadata(self, metadata):\n\n self._metadata = metadata","def metadata(self, metadata):\n\n self._metadata = metadata","def metadata(self, metadata):\n\n self._metadata = metadata","def target_id(self, target_id: str):\n\n self._target_id = target_id","def metadata_set(self, endpoint_name=None, key=None, value=None):\n if key is None:\n raise Exception(\"Key required!\")\n if endpoint_name is None:\n self.request('/v1.1/endpoint/metadata/%s' % key, 'POST', body=value)\n else:\n self.request('/v1.1/endpoints/%s/metadata/%s' %\n (endpoint_name, key), 'POST', body=value)","def _load_meta(self, db, metadata, source_name) -> None:\n db.metadata.put_item(Item={\n 'src_name': source_name,\n 'data_license': metadata.data_license,\n 'data_license_url': metadata.data_license_url,\n 'version': metadata.version,\n 'data_url': metadata.data_url,\n 'rdp_url': metadata.rdp_url,\n 'data_license_attributes': metadata.data_license_attributes,\n 'genome_assemblies': metadata.genome_assemblies\n })","def update_all_metadata(self, metadata):\n return self.manager.update_all_metadata(self, metadata)","def add_metadata(self, metadata: dict) -> None:","def __metadata_update(self, value):\n if value:\n try:\n self.details.original_widget = TextWidget('Updating metadata files. Please, wait...')\n self.execution_manager.close()\n except QMapError as e:\n self.details.original_widget = TextWidget(e)\n self.__back_to_main()","def update_target(self, target, pred, update_rate):\n for target_param, pred_param in zip(target.parameters(), pred.parameters()):\n target_param.data.copy_((1.0 - update_rate)\n * target_param.data + update_rate * pred_param.data)","def _instance_metadata_update(self, context, instance_uuid, metadata):\n return db.instance_metadata_update(context, instance_uuid,\n metadata, False)","def add_target(self, target_obj):\n self.loaded_targets[target_obj.model_name] = target_obj","def test_partial_update_metadata(self):\n pass","def update_edge_by_source_target(self, _source, _target, source=None, target=None, name=None, data={}):\n return self.make_request(\"PUT\", \"edges?source=%s&target=%s\"%(_source,_target), { \"id\" : name, \"source\" : source, \"target\" : target, \"data\" : data })","def set_metadata(self, metadata):\n return self.manager.set_metadata(self, metadata)","def set_metadata(self, metadata):\n return self.manager.set_metadata(self, metadata)","def update_target_network(self):\n\n\t\tprint \"Updating Target DQN...\"\n\t\t\n\t\tself.update_operation.run()","def update(self, src, labels): # real signature unknown; restored from __doc__\n pass","def test_partial_update_metadata1(self):\n pass","def update_plasticc_metadata(metadata):\n # Rename columns in the metadata table to match the avocado conventions.\n metadata_name_map = {\n 'true_target': 'class',\n 'hostgal_photoz_err': 'host_photoz_error',\n 'hostgal_photoz': 'host_photoz',\n 'hostgal_specz': 'host_specz',\n 'ddf_bool': 'ddf',\n 'true_z': 'redshift',\n }\n metadata.rename(metadata_name_map, axis=1, inplace=True)\n\n # Convert the ddf flag to a boolean\n metadata['ddf'] = metadata['ddf'].astype(bool)\n\n # Explicitly set a galactic/extragalactic flag.\n metadata['galactic'] = metadata['host_photoz'] == 0.\n\n # Update the object_id\n new_object_id = ['plasticc_%09d' % i for i in metadata['object_id']]\n metadata['object_id'] = new_object_id\n\n # Drop useless columns that are just confusing and unnecessary.\n metadata.drop(['target', 'distmod'], axis=1, inplace=True)\n\n metadata.set_index('object_id', inplace=True)\n\n return metadata","def metadata(self, metadata: Mapping[str, str]):\r\n self._metadata = metadata","def metadata(self, metadata: Mapping[str, str]):\r\n self._metadata = metadata","def _update_fileinfo(self, metadata_filename):\n \n # In case we delayed loading the metadata and didn't do it in\n # __init__ (such as with delegated metadata), then get the file\n # info now.\n \n # Save the path to the current metadata file for 'metadata_filename'.\n current_filepath = os.path.join(self.metadata_directory['current'],\n metadata_filename)\n # If the path is invalid, simply return and leave fileinfo unset.\n if not os.path.exists(current_filepath):\n self.fileinfo[current_filepath] = None\n return\n \n # Extract the file information from the actual file and save it\n # to the fileinfo store.\n file_length, hashes = tuf.util.get_file_details(current_filepath)\n metadata_fileinfo = tuf.formats.make_fileinfo(file_length, hashes)\n self.fileinfo[metadata_filename] = metadata_fileinfo","def update_target(target_info, temp_dir, images_dir, inventory, args):\n target_name = target_info.get(\"target\")\n target_sha256 = target_info.get(\"sha256_hash\")\n filename = target_info.get(\"filename\")\n temp_path = os.path.join(temp_dir, filename)\n # Add a trailing slash to make sure that urljoin handles things properly\n full_url = urljoin(args.base_url+'/', target_info.get(\"url\"))\n _, downloaded_size, downloaded_sha256 = download(\n images_url=full_url,\n filename=temp_path,\n buffer_size=args.buffer_size,\n print_progress=(_LOG_LEVEL <= _LOG_LEVELS.get(\"INFO\", 3))\n )\n if downloaded_size == 0:\n log(\"INFO\", \"Skipping target: {}\".format(target_name))\n return\n log(\"TRACE\", \"{} successfully downloaded ({} Bytes)\"\n .format(temp_path, downloaded_size))\n # If the SHA256 in the manifest has the value '0', this is a special case\n # and we just skip the verification step\n if target_sha256 == '0':\n log(\"DEBUG\", \"Skipping SHA256 check for {}.\".format(full_url))\n # If the check fails, print an error and don't unzip the file\n elif downloaded_sha256 != target_sha256:\n log(\"ERROR\", \"Downloaded SHA256 does not match manifest for {}!\"\n .format(full_url))\n return\n # Note: this skips the --keep option, so we'll never keep image packages\n # that fail the SHA256 checksum\n ## Now copy the contents to the final destination (the images directory)\n delete_from_inv(target_info, inventory, images_dir)\n if os.path.splitext(temp_path)[1].lower() == '.zip':\n archive_namelist = extract(\n temp_path,\n images_dir,\n args.test)\n if args.keep:\n # If the user wants to keep the downloaded archive,\n # save it to the images directory and add it to the inventory\n shutil.copy(temp_path, images_dir)\n archive_namelist.append(filename)\n else:\n archive_namelist = []\n shutil.copy(temp_path, images_dir)\n ## Update inventory\n inventory[target_name] = {\"repo_hash\": target_info.get(\"repo_hash\"),\n \"contents\": archive_namelist,\n \"filename\": filename}","def update_metadata(metadata_src_lst, metadata_dest_lst):\n if metadata_src_lst and metadata_dest_lst:\n if not isinstance(metadata_dest_lst[0], list): # annotation from one rater only\n metadata_dest_lst[0]._update(metadata_src_lst[0], TRANSFORM_PARAMS)\n else: # annotations from several raters\n for idx, _ in enumerate(metadata_dest_lst[0]):\n metadata_dest_lst[0][idx]._update(metadata_src_lst[0], TRANSFORM_PARAMS)\n return metadata_dest_lst","def _set_target_info(self, targets, host_grps, iqn):\n for host_grp in host_grps:\n port = host_grp['portId']\n gid = host_grp['hostGroupNumber']\n storage_iqn = host_grp['iscsiName']\n if self._is_host_iqn_registered_in_target(port, gid, iqn):\n targets['info'][port] = True\n targets['list'].append((port, gid))\n targets['iqns'][(port, gid)] = storage_iqn\n return True\n return False","def set_target(self, newtarget):\n if newtarget is None:\n self._side_properties['target'] = None\n return\n \n # -- Input Test -- #\n if AstroTarget not in newtarget.__class__.__mro__:\n raise TypeError(\"'newtarget' should be (or inherite of) an AstroTarget\")\n \n # -- Seems Ok -- #\n self._side_properties[\"target\"] = newtarget.copy()","def associate_metadata_operation(key, checksum, url, ts):\n instance = key.get()\n if not instance:\n logging.warning('Instance does not exist: %s', key)\n return\n\n if not instance.active_metadata_update:\n logging.warning('Instance active metadata update unspecified: %s', key)\n return\n\n if instance.active_metadata_update.checksum != checksum:\n logging.warning('Instance has unexpected active metadata update: %s', key)\n return\n\n if instance.active_metadata_update.url:\n if instance.active_metadata_update.url == url:\n return\n logging.warning('Instance has associated metadata operation: %s', key)\n return\n\n instance.active_metadata_update.operation_ts = ts\n instance.active_metadata_update.url = url\n instance.put()","def _update_filesystem_metadata(self, metadata):\n directory, fname = os.path.split(self.fname)\n fbase = os.path.splitext(fname)[0]\n \n # Test for presence and size of zip file\n zip_file = fbase + '.zip'\n zip_path = os.path.join(directory, zip_file)\n \n if os.path.isfile(zip_path):\n location = 'on_disk'\n data_file_size = os.path.getsize(zip_path)\n else:\n location = 'on_tape'\n data_file_size = 0\n \n # Test for presence of quick look PNG file\n quicklook_file = fbase + '.png'\n quicklook_path = os.path.join(directory, quicklook_file)\n \n if not os.path.isfile(quicklook_path):\n quicklook_file = ''\n\n # Add to metadata dictionary\n item_map = {'directory': directory, 'metadata_file': fname,\n 'data_file': zip_file, 'location': location, \n 'data_file_size': data_file_size, 'quicklook_file': quicklook_file}\n \n for key, value in item_map.items():\n metadata[key] = value","def _update_metadata_imagedata(metadata, out_filebase, i):\n metadata['FITSImageFilename'] = [out_filebase + FITS_EXT]\n metadata['PNGImageFileName'] = [out_filebase + PNG_EXT]\n metadata['PNGThumbNailFileName'] = [out_filebase + '_tnail' + PNG_EXT]\n\n image_keys = [\"IntegrationTime\", \"RightAscension\", \"Declination\",\n \"DecRa\", \"Targets\", \"KatpointTargets\"]\n for key in image_keys:\n metadata[key] = [metadata[key][i]]","def add_for_target(self, target, products):\n self._products_by_target[target].update(products)","def set_metadata(self, attribute, value):\n self.metadata[attribute] = value","def target(self, target):\n self.__target = float(target)","def update_table_metadata(\n self,\n table_name: str,\n description: str = None,\n user_id: str = None,\n flat_segmentation_source: str = None,\n read_permission: str = None,\n write_permission: str = None,\n notice_text: str = None,\n ):\n metadata = (\n self.db.cached_session.query(AnnoMetadata)\n .filter(AnnoMetadata.table_name == table_name)\n .first()\n )\n if metadata is None:\n raise TableNameNotFound(\n f\"no table named {table_name} in database {self.sql_url} \"\n )\n\n update_dict = {\n \"description\": description,\n \"user_id\": user_id,\n \"flat_segmentation_source\": flat_segmentation_source,\n \"read_permission\": read_permission,\n \"write_permission\": write_permission,\n }\n update_dict = {k: v for k, v in update_dict.items() if v is not None}\n if notice_text is not None:\n if len(notice_text) == 0:\n update_dict[\"notice_text\"] = None\n else:\n update_dict[\"notice_text\"] = notice_text\n for column, value in update_dict.items():\n if hasattr(metadata, str(column)):\n setattr(metadata, column, value)\n self.db.commit_session()\n logging.info(f\"Table: {table_name} metadata updated \")\n return self.db.get_table_metadata(table_name)","def update_metadata_for_node(self, node, metadata):\n return self.manager.update_metadata(self, metadata, node=node)","def set_target(self, target):\n # parse target objects\n res = []\n targets = target.split(',')\n for item in targets:\n res.append(item)\n self.target = res\n \n # create conversion table for new index\n self.conversion = {}\n for i, cat in enumerate(self.target):\n self.conversion[cat] = f'{i}'","def _save_target_info(self):\n \n #make sure the file exists\n path = self.communicator.image_store.project_path + \\\n self.target_file_name\n fout = open(path, 'w')\n\n print str(1)\n print str(len(self.target_list)-1)\n for i in range(1, len(self.target_list)):\n fout.write(self.target_list[i].format_info())\n fout.write(\"\\n\\n\")\n fout.close()","def update_atom_metadata(self, atom_name, update_with):\n self._update_atom_metadata(atom_name, update_with)","def update_target(\n self,\n ) -> Callable[[cloud_deploy.UpdateTargetRequest], operations_pb2.Operation]:\n # Generate a \"stub function\" on-the-fly which will actually make\n # the request.\n # gRPC handles serialization and deserialization, so we just need\n # to pass in the functions for each.\n if \"update_target\" not in self._stubs:\n self._stubs[\"update_target\"] = self.grpc_channel.unary_unary(\n \"/google.cloud.deploy.v1.CloudDeploy/UpdateTarget\",\n request_serializer=cloud_deploy.UpdateTargetRequest.serialize,\n response_deserializer=operations_pb2.Operation.FromString,\n )\n return self._stubs[\"update_target\"]","def update_mp3_metadata(self, mp3_file):\n if isinstance(mp3_file, str):\n mp3_file = mp3_utility.Mp3File(file_path=mp3_file, load_tags_from_file=True)\n remote_name = self.get_remote_name(mp3_file.file_path)\n archive_item_file_details = self.item_files_dict.get(remote_name, None)\n mp3_metadata = mp3_file.metadata\n if archive_item_file_details is None:\n logging.warning(\"The file does not exist! Skipping.\")\n else:\n remote_tag_update_needed = (archive_item_file_details.get(\"artist\", \"\") != mp3_metadata.artist) or (\n archive_item_file_details.get(\"creator\", \"\") != mp3_metadata.artist) or (\n archive_item_file_details.get(\"title\", \"\") != mp3_metadata.title) or (\n archive_item_file_details.get(\"album\", \"\") != mp3_metadata.album) or (\n archive_item_file_details.get(\"album_artist\",\n \"\") != mp3_metadata.album_artist)\n if remote_tag_update_needed:\n logging.info(\"***Updating %s in archive item.\" % remote_name)\n logging.info(\n internetarchive.modify_metadata(\n self.archive_id,\n metadata=dict(title=mp3_metadata.title, album=mp3_metadata.album,\n album_artist=mp3_metadata.album_artist,\n artist=mp3_metadata.artist, creator=mp3_metadata.artist),\n target=os.path.join(\"files\", remote_name)))","def update_metadata(self):\n parser = GenericParser(\n fn_re='{}/(e\\d+s\\d+)_.*/Production.nc'.format(self.data_folder),\n group_names=['sim'],\n group_transforms=[lambda x: x],\n top_fn='',\n step_ps=self.timestep\n )\n meta = gather_metadata('{}/e*/*nc'.format(self.data_folder), parser)\n meta['top_fn'] = sorted(glob('{}/e*/structure.prmtop'.format(self.input_folder)))\n self.meta = meta","def update_target_net(self, sess):\n sess.run(self.update_target_net_op)","def set_metadata(self, val, entry=None):\n \n if entry is None:\n self.metadata = val\n else:\n self.metadata[entry] = val","def cp_metadata(src_client, src_index, target_client, target_index):\n print \"Copy settings, aliases & mappings from source index %s to target index %s...\" % (src_index, target_index)\n try:\n res = src_client.indices.get_settings(src_index)\n settings = res[src_index]['settings'] if res and 'settings' in res[src_index] else {}\n res = src_client.indices.get_mapping(src_index)\n mappings = res[src_index]['mappings'] if res and 'mappings' in res[src_index] else {}\n res = src_client.indices.get_aliases(src_index)\n aliases = res[src_index]['aliases'] if res and 'aliases' in res[src_index] else {}\n res = target_client.indices.create(index=target_index, body={\"settings\": settings, \"mappings\": mappings, \"aliases\": aliases})\n print 'Metadata copied'\n return res['acknowledged']\n except Exception, e:\n print e\n return False","def update_metadata(\n self, expectation_suite: es.ExpectationSuite\n ) -> es.ExpectationSuite:\n _client = client.get_instance()\n path_params = [\n \"project\",\n _client._project_id,\n \"featurestores\",\n self._feature_store_id,\n \"featuregroups\",\n self._feature_group_id,\n \"expectationsuite\",\n expectation_suite.id,\n \"metadata\",\n ]\n\n headers = {\"content-type\": \"application/json\"}\n payload = expectation_suite.json()\n\n major, minor = self._variable_api.parse_major_and_minor(\n self._variable_api.get_version(\"hopsworks\")\n )\n method = \"PUT\"\n if major == \"3\" and minor == \"0\":\n method = \"POST\"\n del path_params[-1]\n del path_params[-1]\n\n return es.ExpectationSuite.from_response_json(\n _client._send_request(method, path_params, headers=headers, data=payload)\n )","def _apply_harmonized_metadata_to_sample(sample: Sample, harmonized_metadata: dict):\n for key, value in harmonized_metadata.items():\n setattr(sample, key, value)","def update_target(wn, source, old_target, new_target, change_list=None):\n rel_type = find_type(source, old_target)\n delete_rel(source, old_target, change_list)\n insert_rel(source, rel_type, new_target, change_list)\n if rel_type in wordnet.inverse_synset_rels:\n inv_rel_type = wordnet.inverse_synset_rels[rel_type]\n delete_rel(old_target, source, change_list)\n insert_rel(new_target, inv_rel_type, source, change_list)","def PostData(self, postdata):\n if len(postdata) > 0:\n for key in postdata:\n if postdata[key] == \"%TARGET%\":\n postdata[key] = self._target\n self._postdata = postdata\n else:\n self._postdata = None","def add_metadata (self, name, value):\n self.metadata[name] = value\n return self","def update_target_status(self, target_id: str, status: str) -> dict:\n status_data = {\n \"data\": {\"status\": status},\n \"q\": {\n \"condition\": \"OR\",\n \"rules\": [\n {\n \"id\": \"table.id\",\n \"field\": \"table.id\",\n \"type\": \"object\",\n \"input\": \"text\",\n \"operator\": \"equal\",\n \"value\": target_id\n }\n ]\n }\n }\n status_string = json.dumps(status_data)\n\n response = self.rc.execute(\"PATCH\",\n self._get_uri(PATCH_TARGET_URI),\n data=status_string,\n headers=self.header,\n verify=self.verify)\n return response.json()","def update_target_info(self, pic_num, crop_num):\n crop = self.communicator.image_store.get_crop(pic_num, crop_num)\n \n # get the attributes from the picture\n if crop.target != None:\n self.target_viewport.set_sensitive(True)\n self.picture_shape.set_text(crop.target.shape)\n self.picture_color.set_text(crop.target.color)\n self.picture_alpha.set_text(crop.target.alpha)\n self.picture_alphacolor.set_text(crop.target.alphacolor)\n self.picture_orientation.set_text(str(crop.target.orientation))\n self.picture_longitude.set_text(str(crop.target.longitude))\n self.picture_latitude.set_text(str(crop.target.latitude))\n \n if crop.target.included == True:\n self.user_toggled = False\n self.include_target.set_active(True)\n self.user_toggled = True\n self.target_number.set_text(\"target 0\" + str(crop.target.number))\n self.cd_target_num = crop.target.number\n else:\n self.user_toggled = False\n self.include_target.set_active(False)\n self.user_toggled = True\n self.target_number.set_text(\"\")\n self.cd_target_num = -1\n else:\n self.target_viewport.set_sensitive(False)\n self.picture_shape.set_text(\"\")\n self.picture_color.set_text(\"\")\n self.picture_alpha.set_text(\"\")\n self.picture_alphacolor.set_text(\"\")\n self.picture_orientation.set_text(\"\")\n self.picture_longitude.set_text(\"\")\n self.picture_latitude.set_text(\"\")\n self.user_toggled = False\n self.include_target.set_active(False)\n self.user_toggled = True\n self.target_number.set_text(\"\")\n self.cd_target_num = -1","def updateFileInfo(self, data, pid):\n self.db.updateLinkInfo(data)\n self.evm.dispatchEvent(\"packageUpdated\", pid)","def target_configuration(self, target_configuration):\n\n self._target_configuration = target_configuration"],"string":"[\n \"def _metadata_update_targets(targets):\\n affidavit = _create_affidavit()\\n firmwares = db.firmware.get_all()\\n for target in targets:\\n firmwares_filtered = []\\n for f in firmwares:\\n if f.target == 'private':\\n continue\\n if f.target != target:\\n continue\\n firmwares_filtered.append(f)\\n if target == 'stable':\\n _generate_metadata_kind('firmware.xml.gz',\\n firmwares_filtered,\\n affidavit=affidavit)\\n elif target == 'testing':\\n _generate_metadata_kind('firmware-testing.xml.gz',\\n firmwares_filtered,\\n affidavit=affidavit)\",\n \"def update_metadata(self, file_id, metadata):\\n pass\",\n \"def update_target(self):\\n pass\",\n \"def metadata_update(self, new_metadata=None):\\n if new_metadata is None:\\n self.metadata_set(self.t.metadata())\",\n \"def update_metadata(self, metadata: t.Mapping[str, str]) -> None:\\n self._metadata.update(metadata)\",\n \"def test_update_metadata(self):\\n pass\",\n \"def update_metadata(self, metadata):\\n return self.manager.update_metadata(self, metadata)\",\n \"def test_update_metadata1(self):\\n pass\",\n \"def update_metadata(self, key, value):\\n sp.verify(self.is_administrator(sp.sender), FA12_Error.NotAdmin)\\n self.data.metadata[key] = value\",\n \"def update_metadata(self, metadata):\\n return self.parent.update_metadata_for_node(self, metadata)\",\n \"def target_update(obj, target_uri, sli_name, target_from, target_to, target_file):\\n client = get_client(obj)\\n\\n target = client.target_get(target_uri)\\n if not target:\\n fatal_error('Target {} does not exist'.format(target_uri))\\n\\n product = client.product_list(name=target['product_name'])[0]\\n\\n sli = client.sli_list(product=product, name=sli_name)\\n if not sli:\\n fatal_error('SLI {} does not exist'.format(sli_name))\\n sli = sli[0]\\n\\n with Action('Updating Target {} for product {}'.format(target_uri, target['product_name']), nl=True) as act:\\n if target_file:\\n target = json.load(target_file)\\n else:\\n if sli_name:\\n target['sli_uri'] = sli['uri']\\n if target_from:\\n target['from'] = target_from\\n if target_to:\\n target['to'] = target_to\\n\\n validate_target(target, act)\\n\\n if not act.errors:\\n target = client.target_update(target)\\n\\n print(json.dumps(target, indent=4))\",\n \"def test_update_metadata_by_attribute(self):\\n pass\",\n \"def update(self, target, query):\\n node = self._data[target]\\n name = \\\"%s node %.8s\\\" % (node['type'], target)\\n\\n query.update({\\n 'type': node['type'],\\n 'model': node['model']\\n })\\n\\n logger.info(\\\"Validating query\\\")\\n NodeValidator.validate(query)\\n\\n self._data[target] = dict_update(node, query, name)\\n logger.info(\\\"Updated parameters above of %s\\\" % name)\\n\\n return {target: self._data[target]}\",\n \"def _set_target_info_by_name(self, targets, port, target_name, iqn):\\n host_iqn_registered_in_target = (\\n self._get_host_iqn_registered_in_target_by_name(\\n port, target_name, iqn))\\n if host_iqn_registered_in_target:\\n gid = host_iqn_registered_in_target['hostGroupNumber']\\n storage_iqn = self.client.get_host_grp(port, gid)['iscsiName']\\n targets['info'][port] = True\\n targets['list'].append((port, gid))\\n targets['iqns'][(port, gid)] = storage_iqn\\n return True\\n return False\",\n \"def set_metadata(self, metadata):\\n return self.client._perform_json(\\n \\\"PUT\\\", \\\"/projects/%s/recipes/%s/metadata\\\" % (self.project_key, self.recipe_name),\\n body=metadata)\",\n \"def test_update_metadata_by_attribute1(self):\\n pass\",\n \"def update(self, target):\\n self.target = target.detach()\",\n \"def update_metadata(self, corpus_id, meta_data, save_to_cache=True):\\n logger.info('Updating meta data for corpus \\\"%s\\\"' % corpus_id)\\n corpus = self.get_corpus(corpus_id, check_s3=True, use_cache=True)\\n\\n # Loop and add/overwrite meta data key value pairs\\n for k, v in meta_data.items():\\n corpus.meta_data[k] = v\\n\\n if save_to_cache:\\n meta_file_key = '%s/%s/%s.json' % (default_key_base,\\n corpus_id,\\n file_defaults['meta'])\\n corpus._save_to_cache(meta=meta_file_key)\",\n \"def target(self, target) :\\n\\t\\ttry :\\n\\t\\t\\tself._target = target\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def target(self, target) :\\n\\t\\ttry :\\n\\t\\t\\tself._target = target\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def metadata_update(self, _):\\n self.details.original_widget = YesNoWidget('Update metadata files?', self.__metadata_update)\",\n \"def target(self, target):\\n\\n self._target = target\",\n \"async def _edittarget_heist(self, ctx, *, target: str):\\r\\n author = ctx.message.author\\r\\n guild = ctx.guild\\r\\n target = string.capwords(target)\\r\\n targets = await self.thief.get_guild_targets(guild)\\r\\n\\r\\n if target not in targets:\\r\\n return await ctx.send(\\\"That target does not exist.\\\")\\r\\n\\r\\n keys = [x for x in targets[target]]\\r\\n keys.append(\\\"Name\\\")\\r\\n check = lambda m: m.content.title() in keys and m.author == author\\r\\n\\r\\n await ctx.send(\\\"Which property of {} would you like to edit?\\\\n\\\"\\r\\n \\\"{}\\\".format(target, \\\", \\\".join(keys)))\\r\\n\\r\\n response = await self.bot.wait_for('MESSAGE', timeout=15, check=check)\\r\\n\\r\\n if response is None:\\r\\n return await ctx.send(\\\"Canceling removal. You took too long.\\\")\\r\\n\\r\\n if response.content.title() == \\\"Name\\\":\\r\\n await ctx.send(\\\"What would you like to rename the target to?\\\\n*Cannot be a name \\\"\\r\\n \\\"currently in use.*\\\")\\r\\n check2 = lambda m: string.capwords(m.content) not in targets and m.author == author\\r\\n\\r\\n elif response.content.title() in [\\\"Vault\\\", \\\"Vault Max\\\"]:\\r\\n await ctx.send(\\\"What would you like to set the {} \\\"\\r\\n \\\"to?\\\".format(response.content.title()))\\r\\n check2 = lambda m: m.content.isdigit() and int(m.content) > 0 and m.author == author\\r\\n\\r\\n elif response.content.title() == \\\"Success\\\":\\r\\n await ctx.send(\\\"What would you like to change the success rate to?\\\")\\r\\n check2 = lambda m: m.content.isdigit() and 0 < int(m.content) <= 100 and m.author == author\\r\\n\\r\\n elif response.content.title() == \\\"Crew\\\":\\r\\n await ctx.send(\\\"What would you like to change the max crew size to?\\\\n Cannot be \\\"\\r\\n \\\"the same as another target and will be the maximum number of \\\"\\r\\n \\\"players for that target.\\\")\\r\\n crew_sizes = [subdict[\\\"Crew\\\"] for subdict in targets.values()]\\r\\n check2 = lambda m: m.content.isdigit() and int(m.content) not in crew_sizes and m.author == author\\r\\n\\r\\n choice = await self.bot.wait_for('MESSAGE', timeout=15, check=check2)\\r\\n\\r\\n if choice is None:\\r\\n return await ctx.send(\\\"Canceling removal. You took too long.\\\")\\r\\n\\r\\n if response.content.title() == \\\"Name\\\":\\r\\n new_name = string.capwords(choice.content)\\r\\n targets[new_name] = targets.pop(target)\\r\\n await self.thief.save_targets(guild, targets)\\r\\n await ctx.send(\\\"Changed {}'s {} to {}.\\\".format(target, response.content,\\r\\n choice.content))\\r\\n else:\\r\\n targets[target][response.content.title()] = int(choice.content)\\r\\n await self.thief.save_targets(guild, targets)\\r\\n await ctx.send(\\\"Changed {}'s {} to {}.\\\".format(target, response.content,\\r\\n choice.content))\",\n \"def update_metadata(state, name, wid, file_id, metadata_file):\\n\\n client = state.api_client\\n\\n # Get the workspace details\\n w_details = helpers.workspace.details(client, wid, name)\\n if w_details is None:\\n # Can only happen when the name is used and there are no results. Not\\n # with the wid option because it would raise a 404 QuetzalAPIException\\n raise click.ClickException(f'Workspace named \\\"{name}\\\" does not exist.')\\n\\n metadata_contents = json.load(metadata_file)\\n response = client.workspace_file_update_metadata(wid=w_details.id, uuid=file_id,\\n body=metadata_contents)\\n click.secho(f'Metadata for file {file_id} successfully changed.', fg='green')\\n click.secho('Updated metadata:')\\n click.secho(json.dumps(response, indent=2), fg='blue')\",\n \"def update_flow_metadata(self, update_with):\\n if update_with:\\n source, clone = self._fetch_flowdetail(clone=True)\\n clone.meta.update(update_with)\\n self._with_connection(self._save_flow_detail, source, clone)\",\n \"def _update_target(self):\\n self.target_dqn.load_state_dict(self.dqn.state_dict())\",\n \"def target_name(self, target_name):\\n\\n self._target_name = target_name\",\n \"def target_name(self, target_name):\\n\\n self._target_name = target_name\",\n \"def _update_metadata_if_changed(self, metadata_role, referenced_metadata='release'):\\n \\n uncompressed_metadata_filename = metadata_role + '.txt'\\n\\n # Ensure the referenced metadata has been loaded. The 'root' role may be\\n # updated without having 'release' available. \\n if referenced_metadata not in self.metadata['current']:\\n message = 'Cannot update '+repr(metadata_role)+' because ' \\\\\\n +referenced_metadata+' is missing.'\\n raise tuf.RepositoryError(message)\\n # The referenced metadata has been loaded. Extract the new\\n # fileinfo for 'metadata_role' from it. \\n else:\\n message = repr(metadata_role)+' referenced in '+\\\\\\n repr(referenced_metadata)+'. '+repr(metadata_role)+' may be updated.'\\n logger.debug(message)\\n \\n # There might be a compressed version of 'release.txt' or Targets\\n # metadata available for download. Check the 'meta' field of\\n # 'referenced_metadata' to see if it is listed when 'metadata_role'\\n # is 'release'. The full rolename for delegated Targets metadata\\n # must begin with 'targets/'. The Release role lists all the Targets\\n # metadata available on the repository, including any that may be in\\n # compressed form.\\n compression = None\\n\\n # Extract the fileinfo of the uncompressed version of 'metadata_role'.\\n uncompressed_fileinfo = self.metadata['current'][referenced_metadata] \\\\\\n ['meta'] \\\\\\n [uncompressed_metadata_filename]\\n\\n # Check for availability of compressed versions of 'release.txt',\\n # 'targets.txt', and delegated Targets, which also start with 'targets'.\\n # For 'targets.txt' and delegated metadata, 'referenced_metata'\\n # should always be 'release'. 'release.txt' specifies all roles\\n # provided by a repository, including their file sizes and hashes.\\n if metadata_role == 'release' or metadata_role.startswith('targets'):\\n gzip_metadata_filename = uncompressed_metadata_filename + '.gz'\\n if gzip_metadata_filename in self.metadata['current'] \\\\\\n [referenced_metadata]['meta']:\\n compression = 'gzip'\\n compressed_fileinfo = self.metadata['current'][referenced_metadata] \\\\\\n ['meta'][gzip_metadata_filename]\\n # NOTE: When we download the compressed file, we care about its\\n # compressed length. However, we check the hash of the uncompressed\\n # file; therefore we use the hashes of the uncompressed file.\\n fileinfo = {'length': compressed_fileinfo['length'],\\n 'hashes': uncompressed_fileinfo['hashes']}\\n logger.debug('Compressed version of '+\\\\\\n repr(uncompressed_metadata_filename)+' is available at '+\\\\\\n repr(gzip_metadata_filename)+'.')\\n else:\\n logger.debug('Compressed version of '+\\\\\\n repr(uncompressed_metadata_filename)+' not available.')\\n fileinfo = uncompressed_fileinfo\\n else:\\n fileinfo = uncompressed_fileinfo\\n\\n # Simply return if the file has not changed, according to the metadata\\n # about the uncompressed file provided by the referenced metadata.\\n if not self._fileinfo_has_changed(uncompressed_metadata_filename,\\n uncompressed_fileinfo):\\n return\\n\\n logger.debug('Metadata '+repr(uncompressed_metadata_filename)+\\\\\\n ' has changed.')\\n\\n try:\\n self._update_metadata(metadata_role, fileinfo=fileinfo,\\n compression=compression)\\n except:\\n # The current metadata we have is not current but we couldn't\\n # get new metadata. We shouldn't use the old metadata anymore.\\n # This will get rid of in-memory knowledge of the role and\\n # delegated roles, but will leave delegated metadata files as\\n # current files on disk.\\n # TODO: Should we get rid of the delegated metadata files?\\n # We shouldn't need to, but we need to check the trust\\n # implications of the current implementation.\\n self._delete_metadata(metadata_role)\\n logger.error('Metadata for '+str(metadata_role)+' could not be updated')\\n raise\\n else:\\n # We need to remove delegated roles because the delegated roles\\n # may not be trusted anymore.\\n if metadata_role == 'targets' or metadata_role.startswith('targets/'):\\n logger.debug('Removing delegated roles of '+repr(metadata_role)+'.')\\n # TODO: Should we also remove the keys of the delegated roles?\\n tuf.roledb.remove_delegated_roles(metadata_role)\\n self._import_delegations(metadata_role)\",\n \"def set_metadata(self, data):\\r\\n pass\",\n \"def _update_metadata(self, metadata_role, fileinfo, compression=None):\\n\\n # Construct the metadata filename as expected by the download/mirror modules.\\n metadata_filename = metadata_role + '.txt'\\n uncompressed_metadata_filename = metadata_filename\\n \\n # The 'release' or Targets metadata may be compressed. Add the appropriate\\n # extension to 'metadata_filename'. \\n if compression == 'gzip':\\n metadata_filename = metadata_filename + '.gz'\\n\\n # Extract file length and file hashes. They will be passed as arguments\\n # to 'download_file' function.\\n compressed_file_length = fileinfo['length']\\n uncompressed_file_hashes = fileinfo['hashes']\\n\\n # Attempt a file download from each mirror until the file is downloaded and\\n # verified. If the signature of the downloaded file is valid, proceed,\\n # otherwise log a warning and try the next mirror. 'metadata_file_object'\\n # is the file-like object returned by 'download.py'. 'metadata_signable'\\n # is the object extracted from 'metadata_file_object'. Metadata saved to\\n # files are regarded as 'signable' objects, conformant to\\n # 'tuf.formats.SIGNABLE_SCHEMA'.\\n #\\n # Some metadata (presently timestamp) will be downloaded \\\"unsafely\\\", in the\\n # sense that we can only estimate its true length and know nothing about\\n # its hashes. This is because not all metadata will have other metadata\\n # for it; otherwise we will have an infinite regress of metadata signing\\n # for each other. In this case, we will download the metadata up to the\\n # best length we can get for it, not check its hashes, but perform the rest\\n # of the checks (e.g signature verification).\\n #\\n # Note also that we presently support decompression of only \\\"safe\\\"\\n # metadata, but this is easily extend to \\\"unsafe\\\" metadata as well as\\n # \\\"safe\\\" targets.\\n\\n if metadata_role == 'timestamp':\\n metadata_file_object = \\\\\\n self.unsafely_get_metadata_file(metadata_role, metadata_filename,\\n compressed_file_length)\\n else:\\n metadata_file_object = \\\\\\n self.safely_get_metadata_file(metadata_role, metadata_filename,\\n compressed_file_length,\\n uncompressed_file_hashes,\\n compression=compression)\\n\\n # The metadata has been verified. Move the metadata file into place.\\n # First, move the 'current' metadata file to the 'previous' directory\\n # if it exists.\\n current_filepath = os.path.join(self.metadata_directory['current'],\\n metadata_filename)\\n current_filepath = os.path.abspath(current_filepath)\\n tuf.util.ensure_parent_dir(current_filepath)\\n \\n previous_filepath = os.path.join(self.metadata_directory['previous'],\\n metadata_filename)\\n previous_filepath = os.path.abspath(previous_filepath)\\n if os.path.exists(current_filepath):\\n # Previous metadata might not exist, say when delegations are added.\\n tuf.util.ensure_parent_dir(previous_filepath)\\n shutil.move(current_filepath, previous_filepath)\\n\\n # Next, move the verified updated metadata file to the 'current' directory.\\n # Note that the 'move' method comes from tuf.util's TempFile class.\\n # 'metadata_file_object' is an instance of tuf.util.TempFile.\\n metadata_signable = tuf.util.load_json_string(metadata_file_object.read())\\n if compression == 'gzip':\\n current_uncompressed_filepath = \\\\\\n os.path.join(self.metadata_directory['current'],\\n uncompressed_metadata_filename)\\n current_uncompressed_filepath = \\\\\\n os.path.abspath(current_uncompressed_filepath)\\n metadata_file_object.move(current_uncompressed_filepath)\\n else:\\n metadata_file_object.move(current_filepath)\\n\\n # Extract the metadata object so we can store it to the metadata store.\\n # 'current_metadata_object' set to 'None' if there is not an object\\n # stored for 'metadata_role'.\\n updated_metadata_object = metadata_signable['signed']\\n current_metadata_object = self.metadata['current'].get(metadata_role)\\n\\n # Finally, update the metadata and fileinfo stores.\\n logger.debug('Updated '+repr(current_filepath)+'.')\\n self.metadata['previous'][metadata_role] = current_metadata_object\\n self.metadata['current'][metadata_role] = updated_metadata_object\\n self._update_fileinfo(metadata_filename)\",\n \"def target_id(self, target_id):\\n\\n self._target_id = target_id\",\n \"def update_pkg_metadata(self, pkg, version=None, **kwargs):\\n pass\",\n \"def update_targets_with_http_info(self, target, **kwargs):\\n\\n all_params = ['target', 'ids', 'names']\\n all_params.append('callback')\\n all_params.append('_return_http_data_only')\\n all_params.append('_preload_content')\\n all_params.append('_request_timeout')\\n\\n params = locals()\\n for key, val in iteritems(params['kwargs']):\\n if key not in all_params:\\n raise TypeError(\\n \\\"Got an unexpected keyword argument '%s'\\\"\\n \\\" to method update_targets\\\" % key\\n )\\n params[key] = val\\n del params['kwargs']\\n # verify the required parameter 'target' is set\\n if ('target' not in params) or (params['target'] is None):\\n raise ValueError(\\\"Missing the required parameter `target` when calling `update_targets`\\\")\\n\\n\\n collection_formats = {}\\n\\n path_params = {}\\n\\n query_params = []\\n if 'ids' in params:\\n query_params.append(('ids', params['ids']))\\n collection_formats['ids'] = 'csv'\\n if 'names' in params:\\n query_params.append(('names', params['names']))\\n collection_formats['names'] = 'csv'\\n\\n header_params = {}\\n\\n form_params = []\\n local_var_files = {}\\n\\n body_params = None\\n if 'target' in params:\\n body_params = params['target']\\n # HTTP header `Accept`\\n header_params['Accept'] = self.api_client.\\\\\\n select_header_accept(['application/json'])\\n\\n # HTTP header `Content-Type`\\n header_params['Content-Type'] = self.api_client.\\\\\\n select_header_content_type(['application/json'])\\n\\n # Authentication setting\\n auth_settings = ['AuthTokenHeader']\\n\\n return self.api_client.call_api('/1.9/targets', 'PATCH',\\n path_params,\\n query_params,\\n header_params,\\n body=body_params,\\n post_params=form_params,\\n files=local_var_files,\\n response_type='TargetResponse',\\n auth_settings=auth_settings,\\n callback=params.get('callback'),\\n _return_http_data_only=params.get('_return_http_data_only'),\\n _preload_content=params.get('_preload_content', True),\\n _request_timeout=params.get('_request_timeout'),\\n collection_formats=collection_formats)\",\n \"def update_metadata(self):\\n self.data[\\\"keywords\\\"] = self.repo.topics(self.data.get(\\\"keywords\\\", []))\\n self.data[\\\"description\\\"] = self.data.get(\\\"description\\\") or self.repo.description\\n self.data[\\\"codeRepository\\\"] = (\\n self.data.get(\\\"codeRepository\\\") or self.repo.html_url\\n )\\n self.data[\\\"name\\\"] = self.data.get(\\\"name\\\") or self.repo.name\\n self.data[\\\"issueTracker\\\"] = (\\n self.data.get(\\\"issueTracker\\\") or self.repo.issues_url\\n )\\n self.data[\\\"license\\\"] = self.data.get(\\\"license\\\") or self.repo.license\",\n \"def update_versioned_target(self, vt):\\n self._cache_manager.update(vt.cache_key)\",\n \"def replaceMetadata(self, obj, dom):\\n self.update_semantics = 'replace'\\n # create a metadata dict that has all the defaults, overridden by the\\n # current dom values. This way we will 'clear' the properties not in\\n # the dom.\\n metadata = copy(METADATA_DEFAULTS)\\n metadata.update(self.getMetadata(dom, METADATA_MAPPING))\\n if metadata:\\n self.validate_metadata(metadata)\\n metadata = self.fixEntities(metadata, ATTRIBUTES_TO_FIX)\\n if ICollection.providedBy(obj):\\n obj.collection_metadata(**metadata)\\n elif IModule.providedBy(obj):\\n obj.update_metadata(**metadata)\\n # we set GoogleAnalyticsTrackingCode explicitly, since the script\\n # 'update_metadata' ignores empty strings.\\n obj.GoogleAnalyticsTrackingCode = metadata.get('GoogleAnalyticsTrackingCode')\\n self.updateRoles(obj, dom)\\n obj.reindexObject(idxs=metadata.keys())\",\n \"def setTarget(self, target):\\n\\n self._target = target\",\n \"def target_description(self, target_description):\\n\\n self._target_description = target_description\",\n \"def update_metadata(self, loadbalancer, metadata):\\n return loadbalancer.update_metadata(metadata)\",\n \"def set_metadata(self, key, val):\\n \\n self.metadata[key] = val\",\n \"def SetTarget(self, entity):\\n\\t\\tself.target = entity\",\n \"def change_metadata(self, **kwargs):\\n metadata = self.state.get_player_state(PLAYER_IDENTIFIER)\\n\\n # Update saved metadata\\n for key, value in kwargs.items():\\n setattr(metadata, key, value)\\n\\n # Create a temporary metadata instance with requested parameters\\n change = PlayingState(**kwargs)\\n self.state.item_update(change, PLAYER_IDENTIFIER)\",\n \"def metadata(self, metadata):\\n\\n self._metadata = metadata\",\n \"def metadata(self, metadata):\\n\\n self._metadata = metadata\",\n \"def metadata(self, metadata):\\n\\n self._metadata = metadata\",\n \"def metadata(self, metadata):\\n\\n self._metadata = metadata\",\n \"def metadata(self, metadata):\\n\\n self._metadata = metadata\",\n \"def metadata(self, metadata):\\n\\n self._metadata = metadata\",\n \"def metadata(self, metadata):\\n\\n self._metadata = metadata\",\n \"def target_id(self, target_id: str):\\n\\n self._target_id = target_id\",\n \"def metadata_set(self, endpoint_name=None, key=None, value=None):\\n if key is None:\\n raise Exception(\\\"Key required!\\\")\\n if endpoint_name is None:\\n self.request('/v1.1/endpoint/metadata/%s' % key, 'POST', body=value)\\n else:\\n self.request('/v1.1/endpoints/%s/metadata/%s' %\\n (endpoint_name, key), 'POST', body=value)\",\n \"def _load_meta(self, db, metadata, source_name) -> None:\\n db.metadata.put_item(Item={\\n 'src_name': source_name,\\n 'data_license': metadata.data_license,\\n 'data_license_url': metadata.data_license_url,\\n 'version': metadata.version,\\n 'data_url': metadata.data_url,\\n 'rdp_url': metadata.rdp_url,\\n 'data_license_attributes': metadata.data_license_attributes,\\n 'genome_assemblies': metadata.genome_assemblies\\n })\",\n \"def update_all_metadata(self, metadata):\\n return self.manager.update_all_metadata(self, metadata)\",\n \"def add_metadata(self, metadata: dict) -> None:\",\n \"def __metadata_update(self, value):\\n if value:\\n try:\\n self.details.original_widget = TextWidget('Updating metadata files. Please, wait...')\\n self.execution_manager.close()\\n except QMapError as e:\\n self.details.original_widget = TextWidget(e)\\n self.__back_to_main()\",\n \"def update_target(self, target, pred, update_rate):\\n for target_param, pred_param in zip(target.parameters(), pred.parameters()):\\n target_param.data.copy_((1.0 - update_rate)\\n * target_param.data + update_rate * pred_param.data)\",\n \"def _instance_metadata_update(self, context, instance_uuid, metadata):\\n return db.instance_metadata_update(context, instance_uuid,\\n metadata, False)\",\n \"def add_target(self, target_obj):\\n self.loaded_targets[target_obj.model_name] = target_obj\",\n \"def test_partial_update_metadata(self):\\n pass\",\n \"def update_edge_by_source_target(self, _source, _target, source=None, target=None, name=None, data={}):\\n return self.make_request(\\\"PUT\\\", \\\"edges?source=%s&target=%s\\\"%(_source,_target), { \\\"id\\\" : name, \\\"source\\\" : source, \\\"target\\\" : target, \\\"data\\\" : data })\",\n \"def set_metadata(self, metadata):\\n return self.manager.set_metadata(self, metadata)\",\n \"def set_metadata(self, metadata):\\n return self.manager.set_metadata(self, metadata)\",\n \"def update_target_network(self):\\n\\n\\t\\tprint \\\"Updating Target DQN...\\\"\\n\\t\\t\\n\\t\\tself.update_operation.run()\",\n \"def update(self, src, labels): # real signature unknown; restored from __doc__\\n pass\",\n \"def test_partial_update_metadata1(self):\\n pass\",\n \"def update_plasticc_metadata(metadata):\\n # Rename columns in the metadata table to match the avocado conventions.\\n metadata_name_map = {\\n 'true_target': 'class',\\n 'hostgal_photoz_err': 'host_photoz_error',\\n 'hostgal_photoz': 'host_photoz',\\n 'hostgal_specz': 'host_specz',\\n 'ddf_bool': 'ddf',\\n 'true_z': 'redshift',\\n }\\n metadata.rename(metadata_name_map, axis=1, inplace=True)\\n\\n # Convert the ddf flag to a boolean\\n metadata['ddf'] = metadata['ddf'].astype(bool)\\n\\n # Explicitly set a galactic/extragalactic flag.\\n metadata['galactic'] = metadata['host_photoz'] == 0.\\n\\n # Update the object_id\\n new_object_id = ['plasticc_%09d' % i for i in metadata['object_id']]\\n metadata['object_id'] = new_object_id\\n\\n # Drop useless columns that are just confusing and unnecessary.\\n metadata.drop(['target', 'distmod'], axis=1, inplace=True)\\n\\n metadata.set_index('object_id', inplace=True)\\n\\n return metadata\",\n \"def metadata(self, metadata: Mapping[str, str]):\\r\\n self._metadata = metadata\",\n \"def metadata(self, metadata: Mapping[str, str]):\\r\\n self._metadata = metadata\",\n \"def _update_fileinfo(self, metadata_filename):\\n \\n # In case we delayed loading the metadata and didn't do it in\\n # __init__ (such as with delegated metadata), then get the file\\n # info now.\\n \\n # Save the path to the current metadata file for 'metadata_filename'.\\n current_filepath = os.path.join(self.metadata_directory['current'],\\n metadata_filename)\\n # If the path is invalid, simply return and leave fileinfo unset.\\n if not os.path.exists(current_filepath):\\n self.fileinfo[current_filepath] = None\\n return\\n \\n # Extract the file information from the actual file and save it\\n # to the fileinfo store.\\n file_length, hashes = tuf.util.get_file_details(current_filepath)\\n metadata_fileinfo = tuf.formats.make_fileinfo(file_length, hashes)\\n self.fileinfo[metadata_filename] = metadata_fileinfo\",\n \"def update_target(target_info, temp_dir, images_dir, inventory, args):\\n target_name = target_info.get(\\\"target\\\")\\n target_sha256 = target_info.get(\\\"sha256_hash\\\")\\n filename = target_info.get(\\\"filename\\\")\\n temp_path = os.path.join(temp_dir, filename)\\n # Add a trailing slash to make sure that urljoin handles things properly\\n full_url = urljoin(args.base_url+'/', target_info.get(\\\"url\\\"))\\n _, downloaded_size, downloaded_sha256 = download(\\n images_url=full_url,\\n filename=temp_path,\\n buffer_size=args.buffer_size,\\n print_progress=(_LOG_LEVEL <= _LOG_LEVELS.get(\\\"INFO\\\", 3))\\n )\\n if downloaded_size == 0:\\n log(\\\"INFO\\\", \\\"Skipping target: {}\\\".format(target_name))\\n return\\n log(\\\"TRACE\\\", \\\"{} successfully downloaded ({} Bytes)\\\"\\n .format(temp_path, downloaded_size))\\n # If the SHA256 in the manifest has the value '0', this is a special case\\n # and we just skip the verification step\\n if target_sha256 == '0':\\n log(\\\"DEBUG\\\", \\\"Skipping SHA256 check for {}.\\\".format(full_url))\\n # If the check fails, print an error and don't unzip the file\\n elif downloaded_sha256 != target_sha256:\\n log(\\\"ERROR\\\", \\\"Downloaded SHA256 does not match manifest for {}!\\\"\\n .format(full_url))\\n return\\n # Note: this skips the --keep option, so we'll never keep image packages\\n # that fail the SHA256 checksum\\n ## Now copy the contents to the final destination (the images directory)\\n delete_from_inv(target_info, inventory, images_dir)\\n if os.path.splitext(temp_path)[1].lower() == '.zip':\\n archive_namelist = extract(\\n temp_path,\\n images_dir,\\n args.test)\\n if args.keep:\\n # If the user wants to keep the downloaded archive,\\n # save it to the images directory and add it to the inventory\\n shutil.copy(temp_path, images_dir)\\n archive_namelist.append(filename)\\n else:\\n archive_namelist = []\\n shutil.copy(temp_path, images_dir)\\n ## Update inventory\\n inventory[target_name] = {\\\"repo_hash\\\": target_info.get(\\\"repo_hash\\\"),\\n \\\"contents\\\": archive_namelist,\\n \\\"filename\\\": filename}\",\n \"def update_metadata(metadata_src_lst, metadata_dest_lst):\\n if metadata_src_lst and metadata_dest_lst:\\n if not isinstance(metadata_dest_lst[0], list): # annotation from one rater only\\n metadata_dest_lst[0]._update(metadata_src_lst[0], TRANSFORM_PARAMS)\\n else: # annotations from several raters\\n for idx, _ in enumerate(metadata_dest_lst[0]):\\n metadata_dest_lst[0][idx]._update(metadata_src_lst[0], TRANSFORM_PARAMS)\\n return metadata_dest_lst\",\n \"def _set_target_info(self, targets, host_grps, iqn):\\n for host_grp in host_grps:\\n port = host_grp['portId']\\n gid = host_grp['hostGroupNumber']\\n storage_iqn = host_grp['iscsiName']\\n if self._is_host_iqn_registered_in_target(port, gid, iqn):\\n targets['info'][port] = True\\n targets['list'].append((port, gid))\\n targets['iqns'][(port, gid)] = storage_iqn\\n return True\\n return False\",\n \"def set_target(self, newtarget):\\n if newtarget is None:\\n self._side_properties['target'] = None\\n return\\n \\n # -- Input Test -- #\\n if AstroTarget not in newtarget.__class__.__mro__:\\n raise TypeError(\\\"'newtarget' should be (or inherite of) an AstroTarget\\\")\\n \\n # -- Seems Ok -- #\\n self._side_properties[\\\"target\\\"] = newtarget.copy()\",\n \"def associate_metadata_operation(key, checksum, url, ts):\\n instance = key.get()\\n if not instance:\\n logging.warning('Instance does not exist: %s', key)\\n return\\n\\n if not instance.active_metadata_update:\\n logging.warning('Instance active metadata update unspecified: %s', key)\\n return\\n\\n if instance.active_metadata_update.checksum != checksum:\\n logging.warning('Instance has unexpected active metadata update: %s', key)\\n return\\n\\n if instance.active_metadata_update.url:\\n if instance.active_metadata_update.url == url:\\n return\\n logging.warning('Instance has associated metadata operation: %s', key)\\n return\\n\\n instance.active_metadata_update.operation_ts = ts\\n instance.active_metadata_update.url = url\\n instance.put()\",\n \"def _update_filesystem_metadata(self, metadata):\\n directory, fname = os.path.split(self.fname)\\n fbase = os.path.splitext(fname)[0]\\n \\n # Test for presence and size of zip file\\n zip_file = fbase + '.zip'\\n zip_path = os.path.join(directory, zip_file)\\n \\n if os.path.isfile(zip_path):\\n location = 'on_disk'\\n data_file_size = os.path.getsize(zip_path)\\n else:\\n location = 'on_tape'\\n data_file_size = 0\\n \\n # Test for presence of quick look PNG file\\n quicklook_file = fbase + '.png'\\n quicklook_path = os.path.join(directory, quicklook_file)\\n \\n if not os.path.isfile(quicklook_path):\\n quicklook_file = ''\\n\\n # Add to metadata dictionary\\n item_map = {'directory': directory, 'metadata_file': fname,\\n 'data_file': zip_file, 'location': location, \\n 'data_file_size': data_file_size, 'quicklook_file': quicklook_file}\\n \\n for key, value in item_map.items():\\n metadata[key] = value\",\n \"def _update_metadata_imagedata(metadata, out_filebase, i):\\n metadata['FITSImageFilename'] = [out_filebase + FITS_EXT]\\n metadata['PNGImageFileName'] = [out_filebase + PNG_EXT]\\n metadata['PNGThumbNailFileName'] = [out_filebase + '_tnail' + PNG_EXT]\\n\\n image_keys = [\\\"IntegrationTime\\\", \\\"RightAscension\\\", \\\"Declination\\\",\\n \\\"DecRa\\\", \\\"Targets\\\", \\\"KatpointTargets\\\"]\\n for key in image_keys:\\n metadata[key] = [metadata[key][i]]\",\n \"def add_for_target(self, target, products):\\n self._products_by_target[target].update(products)\",\n \"def set_metadata(self, attribute, value):\\n self.metadata[attribute] = value\",\n \"def target(self, target):\\n self.__target = float(target)\",\n \"def update_table_metadata(\\n self,\\n table_name: str,\\n description: str = None,\\n user_id: str = None,\\n flat_segmentation_source: str = None,\\n read_permission: str = None,\\n write_permission: str = None,\\n notice_text: str = None,\\n ):\\n metadata = (\\n self.db.cached_session.query(AnnoMetadata)\\n .filter(AnnoMetadata.table_name == table_name)\\n .first()\\n )\\n if metadata is None:\\n raise TableNameNotFound(\\n f\\\"no table named {table_name} in database {self.sql_url} \\\"\\n )\\n\\n update_dict = {\\n \\\"description\\\": description,\\n \\\"user_id\\\": user_id,\\n \\\"flat_segmentation_source\\\": flat_segmentation_source,\\n \\\"read_permission\\\": read_permission,\\n \\\"write_permission\\\": write_permission,\\n }\\n update_dict = {k: v for k, v in update_dict.items() if v is not None}\\n if notice_text is not None:\\n if len(notice_text) == 0:\\n update_dict[\\\"notice_text\\\"] = None\\n else:\\n update_dict[\\\"notice_text\\\"] = notice_text\\n for column, value in update_dict.items():\\n if hasattr(metadata, str(column)):\\n setattr(metadata, column, value)\\n self.db.commit_session()\\n logging.info(f\\\"Table: {table_name} metadata updated \\\")\\n return self.db.get_table_metadata(table_name)\",\n \"def update_metadata_for_node(self, node, metadata):\\n return self.manager.update_metadata(self, metadata, node=node)\",\n \"def set_target(self, target):\\n # parse target objects\\n res = []\\n targets = target.split(',')\\n for item in targets:\\n res.append(item)\\n self.target = res\\n \\n # create conversion table for new index\\n self.conversion = {}\\n for i, cat in enumerate(self.target):\\n self.conversion[cat] = f'{i}'\",\n \"def _save_target_info(self):\\n \\n #make sure the file exists\\n path = self.communicator.image_store.project_path + \\\\\\n self.target_file_name\\n fout = open(path, 'w')\\n\\n print str(1)\\n print str(len(self.target_list)-1)\\n for i in range(1, len(self.target_list)):\\n fout.write(self.target_list[i].format_info())\\n fout.write(\\\"\\\\n\\\\n\\\")\\n fout.close()\",\n \"def update_atom_metadata(self, atom_name, update_with):\\n self._update_atom_metadata(atom_name, update_with)\",\n \"def update_target(\\n self,\\n ) -> Callable[[cloud_deploy.UpdateTargetRequest], operations_pb2.Operation]:\\n # Generate a \\\"stub function\\\" on-the-fly which will actually make\\n # the request.\\n # gRPC handles serialization and deserialization, so we just need\\n # to pass in the functions for each.\\n if \\\"update_target\\\" not in self._stubs:\\n self._stubs[\\\"update_target\\\"] = self.grpc_channel.unary_unary(\\n \\\"/google.cloud.deploy.v1.CloudDeploy/UpdateTarget\\\",\\n request_serializer=cloud_deploy.UpdateTargetRequest.serialize,\\n response_deserializer=operations_pb2.Operation.FromString,\\n )\\n return self._stubs[\\\"update_target\\\"]\",\n \"def update_mp3_metadata(self, mp3_file):\\n if isinstance(mp3_file, str):\\n mp3_file = mp3_utility.Mp3File(file_path=mp3_file, load_tags_from_file=True)\\n remote_name = self.get_remote_name(mp3_file.file_path)\\n archive_item_file_details = self.item_files_dict.get(remote_name, None)\\n mp3_metadata = mp3_file.metadata\\n if archive_item_file_details is None:\\n logging.warning(\\\"The file does not exist! Skipping.\\\")\\n else:\\n remote_tag_update_needed = (archive_item_file_details.get(\\\"artist\\\", \\\"\\\") != mp3_metadata.artist) or (\\n archive_item_file_details.get(\\\"creator\\\", \\\"\\\") != mp3_metadata.artist) or (\\n archive_item_file_details.get(\\\"title\\\", \\\"\\\") != mp3_metadata.title) or (\\n archive_item_file_details.get(\\\"album\\\", \\\"\\\") != mp3_metadata.album) or (\\n archive_item_file_details.get(\\\"album_artist\\\",\\n \\\"\\\") != mp3_metadata.album_artist)\\n if remote_tag_update_needed:\\n logging.info(\\\"***Updating %s in archive item.\\\" % remote_name)\\n logging.info(\\n internetarchive.modify_metadata(\\n self.archive_id,\\n metadata=dict(title=mp3_metadata.title, album=mp3_metadata.album,\\n album_artist=mp3_metadata.album_artist,\\n artist=mp3_metadata.artist, creator=mp3_metadata.artist),\\n target=os.path.join(\\\"files\\\", remote_name)))\",\n \"def update_metadata(self):\\n parser = GenericParser(\\n fn_re='{}/(e\\\\d+s\\\\d+)_.*/Production.nc'.format(self.data_folder),\\n group_names=['sim'],\\n group_transforms=[lambda x: x],\\n top_fn='',\\n step_ps=self.timestep\\n )\\n meta = gather_metadata('{}/e*/*nc'.format(self.data_folder), parser)\\n meta['top_fn'] = sorted(glob('{}/e*/structure.prmtop'.format(self.input_folder)))\\n self.meta = meta\",\n \"def update_target_net(self, sess):\\n sess.run(self.update_target_net_op)\",\n \"def set_metadata(self, val, entry=None):\\n \\n if entry is None:\\n self.metadata = val\\n else:\\n self.metadata[entry] = val\",\n \"def cp_metadata(src_client, src_index, target_client, target_index):\\n print \\\"Copy settings, aliases & mappings from source index %s to target index %s...\\\" % (src_index, target_index)\\n try:\\n res = src_client.indices.get_settings(src_index)\\n settings = res[src_index]['settings'] if res and 'settings' in res[src_index] else {}\\n res = src_client.indices.get_mapping(src_index)\\n mappings = res[src_index]['mappings'] if res and 'mappings' in res[src_index] else {}\\n res = src_client.indices.get_aliases(src_index)\\n aliases = res[src_index]['aliases'] if res and 'aliases' in res[src_index] else {}\\n res = target_client.indices.create(index=target_index, body={\\\"settings\\\": settings, \\\"mappings\\\": mappings, \\\"aliases\\\": aliases})\\n print 'Metadata copied'\\n return res['acknowledged']\\n except Exception, e:\\n print e\\n return False\",\n \"def update_metadata(\\n self, expectation_suite: es.ExpectationSuite\\n ) -> es.ExpectationSuite:\\n _client = client.get_instance()\\n path_params = [\\n \\\"project\\\",\\n _client._project_id,\\n \\\"featurestores\\\",\\n self._feature_store_id,\\n \\\"featuregroups\\\",\\n self._feature_group_id,\\n \\\"expectationsuite\\\",\\n expectation_suite.id,\\n \\\"metadata\\\",\\n ]\\n\\n headers = {\\\"content-type\\\": \\\"application/json\\\"}\\n payload = expectation_suite.json()\\n\\n major, minor = self._variable_api.parse_major_and_minor(\\n self._variable_api.get_version(\\\"hopsworks\\\")\\n )\\n method = \\\"PUT\\\"\\n if major == \\\"3\\\" and minor == \\\"0\\\":\\n method = \\\"POST\\\"\\n del path_params[-1]\\n del path_params[-1]\\n\\n return es.ExpectationSuite.from_response_json(\\n _client._send_request(method, path_params, headers=headers, data=payload)\\n )\",\n \"def _apply_harmonized_metadata_to_sample(sample: Sample, harmonized_metadata: dict):\\n for key, value in harmonized_metadata.items():\\n setattr(sample, key, value)\",\n \"def update_target(wn, source, old_target, new_target, change_list=None):\\n rel_type = find_type(source, old_target)\\n delete_rel(source, old_target, change_list)\\n insert_rel(source, rel_type, new_target, change_list)\\n if rel_type in wordnet.inverse_synset_rels:\\n inv_rel_type = wordnet.inverse_synset_rels[rel_type]\\n delete_rel(old_target, source, change_list)\\n insert_rel(new_target, inv_rel_type, source, change_list)\",\n \"def PostData(self, postdata):\\n if len(postdata) > 0:\\n for key in postdata:\\n if postdata[key] == \\\"%TARGET%\\\":\\n postdata[key] = self._target\\n self._postdata = postdata\\n else:\\n self._postdata = None\",\n \"def add_metadata (self, name, value):\\n self.metadata[name] = value\\n return self\",\n \"def update_target_status(self, target_id: str, status: str) -> dict:\\n status_data = {\\n \\\"data\\\": {\\\"status\\\": status},\\n \\\"q\\\": {\\n \\\"condition\\\": \\\"OR\\\",\\n \\\"rules\\\": [\\n {\\n \\\"id\\\": \\\"table.id\\\",\\n \\\"field\\\": \\\"table.id\\\",\\n \\\"type\\\": \\\"object\\\",\\n \\\"input\\\": \\\"text\\\",\\n \\\"operator\\\": \\\"equal\\\",\\n \\\"value\\\": target_id\\n }\\n ]\\n }\\n }\\n status_string = json.dumps(status_data)\\n\\n response = self.rc.execute(\\\"PATCH\\\",\\n self._get_uri(PATCH_TARGET_URI),\\n data=status_string,\\n headers=self.header,\\n verify=self.verify)\\n return response.json()\",\n \"def update_target_info(self, pic_num, crop_num):\\n crop = self.communicator.image_store.get_crop(pic_num, crop_num)\\n \\n # get the attributes from the picture\\n if crop.target != None:\\n self.target_viewport.set_sensitive(True)\\n self.picture_shape.set_text(crop.target.shape)\\n self.picture_color.set_text(crop.target.color)\\n self.picture_alpha.set_text(crop.target.alpha)\\n self.picture_alphacolor.set_text(crop.target.alphacolor)\\n self.picture_orientation.set_text(str(crop.target.orientation))\\n self.picture_longitude.set_text(str(crop.target.longitude))\\n self.picture_latitude.set_text(str(crop.target.latitude))\\n \\n if crop.target.included == True:\\n self.user_toggled = False\\n self.include_target.set_active(True)\\n self.user_toggled = True\\n self.target_number.set_text(\\\"target 0\\\" + str(crop.target.number))\\n self.cd_target_num = crop.target.number\\n else:\\n self.user_toggled = False\\n self.include_target.set_active(False)\\n self.user_toggled = True\\n self.target_number.set_text(\\\"\\\")\\n self.cd_target_num = -1\\n else:\\n self.target_viewport.set_sensitive(False)\\n self.picture_shape.set_text(\\\"\\\")\\n self.picture_color.set_text(\\\"\\\")\\n self.picture_alpha.set_text(\\\"\\\")\\n self.picture_alphacolor.set_text(\\\"\\\")\\n self.picture_orientation.set_text(\\\"\\\")\\n self.picture_longitude.set_text(\\\"\\\")\\n self.picture_latitude.set_text(\\\"\\\")\\n self.user_toggled = False\\n self.include_target.set_active(False)\\n self.user_toggled = True\\n self.target_number.set_text(\\\"\\\")\\n self.cd_target_num = -1\",\n \"def updateFileInfo(self, data, pid):\\n self.db.updateLinkInfo(data)\\n self.evm.dispatchEvent(\\\"packageUpdated\\\", pid)\",\n \"def target_configuration(self, target_configuration):\\n\\n self._target_configuration = target_configuration\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.704391","0.6856124","0.680079","0.6698067","0.6497665","0.643017","0.6337812","0.6309755","0.61284596","0.61040866","0.6089916","0.60253173","0.5976579","0.5934039","0.59204215","0.59136456","0.5907409","0.58857447","0.5860491","0.5860491","0.58534926","0.58295894","0.5816415","0.5813671","0.578546","0.5778","0.57762754","0.57762754","0.5753484","0.5748734","0.5723793","0.5722842","0.570968","0.569247","0.56770253","0.56742245","0.5668789","0.56685215","0.566823","0.56428623","0.56258863","0.56044686","0.5603538","0.55884254","0.55884254","0.55884254","0.55884254","0.55884254","0.55884254","0.55884254","0.558708","0.55771446","0.5559307","0.55340075","0.5531086","0.55139554","0.5511209","0.5508893","0.55039084","0.5503239","0.5491177","0.549043","0.549043","0.54756796","0.5473461","0.54573816","0.54566437","0.54528326","0.54528326","0.5445595","0.5434125","0.5433248","0.5431166","0.5424065","0.5406791","0.5402546","0.538195","0.53818214","0.53811646","0.53804564","0.5371686","0.5370554","0.5369541","0.5364979","0.535661","0.5338831","0.5325416","0.53104246","0.5304933","0.5302776","0.5301101","0.52962524","0.52827466","0.5281407","0.52807134","0.52782637","0.5272964","0.5261429","0.52542895","0.52442634"],"string":"[\n \"0.704391\",\n \"0.6856124\",\n \"0.680079\",\n \"0.6698067\",\n \"0.6497665\",\n \"0.643017\",\n \"0.6337812\",\n \"0.6309755\",\n \"0.61284596\",\n \"0.61040866\",\n \"0.6089916\",\n \"0.60253173\",\n \"0.5976579\",\n \"0.5934039\",\n \"0.59204215\",\n \"0.59136456\",\n \"0.5907409\",\n \"0.58857447\",\n \"0.5860491\",\n \"0.5860491\",\n \"0.58534926\",\n \"0.58295894\",\n \"0.5816415\",\n \"0.5813671\",\n \"0.578546\",\n \"0.5778\",\n \"0.57762754\",\n \"0.57762754\",\n \"0.5753484\",\n \"0.5748734\",\n \"0.5723793\",\n \"0.5722842\",\n \"0.570968\",\n \"0.569247\",\n \"0.56770253\",\n \"0.56742245\",\n \"0.5668789\",\n \"0.56685215\",\n \"0.566823\",\n \"0.56428623\",\n \"0.56258863\",\n \"0.56044686\",\n \"0.5603538\",\n \"0.55884254\",\n \"0.55884254\",\n \"0.55884254\",\n \"0.55884254\",\n \"0.55884254\",\n \"0.55884254\",\n \"0.55884254\",\n \"0.558708\",\n \"0.55771446\",\n \"0.5559307\",\n \"0.55340075\",\n \"0.5531086\",\n \"0.55139554\",\n \"0.5511209\",\n \"0.5508893\",\n \"0.55039084\",\n \"0.5503239\",\n \"0.5491177\",\n \"0.549043\",\n \"0.549043\",\n \"0.54756796\",\n \"0.5473461\",\n \"0.54573816\",\n \"0.54566437\",\n \"0.54528326\",\n \"0.54528326\",\n \"0.5445595\",\n \"0.5434125\",\n \"0.5433248\",\n \"0.5431166\",\n \"0.5424065\",\n \"0.5406791\",\n \"0.5402546\",\n \"0.538195\",\n \"0.53818214\",\n \"0.53811646\",\n \"0.53804564\",\n \"0.5371686\",\n \"0.5370554\",\n \"0.5369541\",\n \"0.5364979\",\n \"0.535661\",\n \"0.5338831\",\n \"0.5325416\",\n \"0.53104246\",\n \"0.5304933\",\n \"0.5302776\",\n \"0.5301101\",\n \"0.52962524\",\n \"0.52827466\",\n \"0.5281407\",\n \"0.52807134\",\n \"0.52782637\",\n \"0.5272964\",\n \"0.5261429\",\n \"0.52542895\",\n \"0.52442634\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56407994"},"document_rank":{"kind":"string","value":"40"}}},{"rowIdx":83162,"cells":{"query":{"kind":"string","value":"Writes the input out to a local file"},"document":{"kind":"string","value":"def process(self, tup):\n\n input = tup.values[0]\n\n url = input['url']\n\n now = datetime.datetime.now()\n if url in self.seen:\n lastSeen = self.seen[url]\n delta = now - lastSeen\n if delta.total_seconds() < 3600:\n # seen less than an hour ago, don't fetch again\n return\n self.seen[url] = now\n\n delta = now - self.lastfetch\n if delta.total_seconds < 0.25:\n # self.log(\"CrawlerBolt sleeping\")\n time.sleep(.25)\n\n cj = cookielib.CookieJar()\n opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))\n headers = [(\"User-Agent\", \"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:12.0) Gecko/20100101 Firefox/12.0\")]\n opener.addheaders = headers\n output = None\n try:\n response = opener.open(url, timeout=10)\n content_type = response.info().getheader('Content-Type')\n decode_type = \"ISO-8859-1\"\n if content_type is not None and \"charset\" in content_type and \"pdf\" not in content_type:\n decode_type = content_type.split(\"charset=\")[-1]\n html = response.read().decode(decode_type)\n links = []\n if input['depth'] is not 0:\n links = self.linkExtractor.extract(url, response.getcode(), '', '', html, response.info()['date'], 'datawake-local-crawler')\n links = map(lambda x: x.value, links)\n links = filter(lambda x: x is not None and len(x) > 0, links)\n # self.log(\"CrawlerBolt extracted links: \"+str(links))\n\n output = dict(\n crawlid=input['crawlid'],\n appid=input['appid'],\n url=url,\n status_code=response.getcode(),\n status_msg='Success',\n timestamp=response.info()['date'],\n links_found=links,\n body=html,\n attrs=input['attrs']\n )\n\n\n # self.emit([json.dumps(output)])\n self.producer.send_messages(self.topic, json.dumps(output))\n\n self.lastfetch = datetime.datetime.now()\n except:\n self.log(\"CrawlerBolt \" + traceback.format_exc())\n self.log(\"CrawlerBolt: URL: \" + url)\n # self.fail(tup)\n\n if len(self.seen) > self.MAX_LRU_SIZE:\n self.log(\"CrawlerBolt truncating LRU cache\", level='trace')\n sorted_x = sorted(self.seen.items(), key=operator.itemgetter(1))[0:self.TRUNCATE]\n self.seen = dict(sorted_x)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _write_output_file(output: str, file_name: str):\n\tfile1 = open(file_name, 'w')\n\tfile1.write(output)\n\tfile1.close()","def __export_file(self, filename, output):\n outfile = open(filename, \"w\")\n outfile.write(output)\n outfile.close\n print(\"Output written to file: \" + filename + \"\\n\")","def write_to_file(self, filename: str) -> None:","def write_to_file(output, test_case_name, path):\n path_to_store = OutputWrite.make_test_dir(path, test_case_name)\n time_stamp = OutputWrite.get_time_stamp()\n try:\n LOG.debug('Changing the dir to {0}'.format(path_to_store))\n os.chdir(path_to_store)\n except Exception as _ex_:\n LOG.exception('Error :{0}'.format(_ex_))\n else:\n file_name = os.path.join(path_to_store, test_case_name +\n time_stamp)\n LOG.debug('The file name after joining = {0}'.format(file_name))\n try:\n LOG.debug('Writing Test case output to the file')\n with open(file_name, 'w') as file_obj:\n file_obj.write(output)\n except FileNotFoundError as _ex_:\n LOG.exception('Error : {0}'.format(_ex_))","def write(self, fname):\n pass","def _write_file(template, localcontext, output_path, name):\n output = template.render(localcontext)\n filename = os.sep.join((output_path, name))\n try:\n os.makedirs(os.path.dirname(filename))\n except Exception:\n pass\n with open(filename, 'w', encoding='utf-8') as f:\n f.write(output)\n print u' [ok] writing %s' % filename","def output(self, _in, out, **kwds):\n out.write(_in.read())","def fileWrite(content):\n file = open('./result.txt', 'w')\n file.write(content)\n file.close()","def write_file(self, fname, name, inputd):\r\n self.filename = name\r\n if fname != \".\":\r\n self.fname = f\"{fname}\\\\\"\r\n self.pathwrite = os.path.join(self.p, self.fname)\r\n else:\r\n self.pathwrite = self.p\r\n self.input = inputd\r\n try:\r\n self.path = os.path.join(self.pathwrite, self.filename)\r\n with open(self.path, 'w') as file:\r\n file.write(self.input)\r\n self.confirms = True\r\n except Exception as error:\r\n print(error)\r\n finally:\r\n return self.confirms","def write(self, filename):\n pass","def write(self, filename):\n pass","def file_write(stuff, file_path):\n with open(file_path, \"wt\") as fo:\n fo.write(stuff)","def _write_file(output_path: str, file_content: Iterable[str]) -> None:\n with open(output_path, \"w+\", encoding=\"utf-8\") as f:\n f.writelines(file_content)\n\n logging.info(f\"wrote to '{output_path}'\")","def writeto(self, fileout):\n \n dump_pkl(self.data, fileout)","def _toFile(self):\n pass","def out(filename, s):\n\tf = open(filename, 'w')\n\tf.write(s)\n\tf.close()","def _write_file(template, localcontext, output_path, name, override):\n # set localsiteurl for context so that Contents can adjust links\n if localcontext[\"localsiteurl\"]:\n context[\"localsiteurl\"] = localcontext[\"localsiteurl\"]\n output = template.render(localcontext)\n path = sanitised_join(output_path, name)\n\n try:\n os.makedirs(os.path.dirname(path))\n except Exception:\n pass\n\n with self._open_w(path, \"utf-8\", override=override) as f:\n f.write(output)\n logger.info(\"Writing %s\", path)\n\n # Send a signal to say we're writing a file with some specific\n # local context.\n signals.content_written.send(path, context=localcontext)","def write_file(self):\n if self._write_file == None:\n return\n\n try:\n out = file(self._write_file, \"w\")\n except IOError, e:\n print e\n sys.exit(1)\n out.writelines(\"A cases\") \n out.close()","def write(self, out):","def write_the_contents_to_the_same_file(self):\n if not len(self.student_list):\n print('There is no contents to write')\n return\n\n if self._filename is None:\n self._filename = self.input_filename()\n\n with open(self._filename, 'w') as OUT:\n OUT.write(self.student_list.to_csv(date_format='%Y-%m-%d',\n sep='\\t', header=False, columns=self.columns_to_save))\n print(f'Data are saved into {self._filename!r}')","def _amber_write_input_file(self):\n logger.debug(\"Writing {}\".format(self.input))\n with open(os.path.join(self.path, self.input), \"w\") as f:\n f.write(\"{}\\n\".format(self.title))\n f.write(\" &cntrl\\n\")\n self._write_dict_to_mdin(f, self.cntrl)\n\n if self.ewald is not None:\n f.write(\" &ewald\\n\")\n self._write_dict_to_mdin(f, self.ewald)\n\n if self.cntrl[\"nmropt\"] == 1:\n if self.wt is not None:\n for line in self.wt:\n f.write(\" \"+line+\"\\n\")\n f.write(\" &wt type = 'END', /\\n\")\n if self.restraint_file is not None:\n f.write(\"DISANG = {}\\n\".format(self.restraint_file))\n f.write(\"LISTOUT = POUT\\n\\n\")\n if self.group is not None:\n f.write(\"{:s}\".format(self.group))","def _write_file(template, localcontext, output_path, name, override):\r\n old_locale = locale.setlocale(locale.LC_ALL)\r\n locale.setlocale(locale.LC_ALL, str('C'))\r\n try:\r\n output = template.render(localcontext)\r\n finally:\r\n locale.setlocale(locale.LC_ALL, old_locale)\r\n path = os.path.join(output_path, name)\r\n try:\r\n os.makedirs(os.path.dirname(path))\r\n except Exception:\r\n pass\r\n\r\n with self._open_w(path, 'utf-8', override=override) as f:\r\n f.write(output)\r\n logger.info('writing {}'.format(path))\r\n\r\n # Send a signal to say we're writing a file with some specific\r\n # local context.\r\n signals.content_written.send(path, context=localcontext)","def make_file(self):\n\n f = open(get_output_path(), \"w\")\n \n f.write(self.export())\n \n f.close()\n\n return self","def save_input(self):\n if not os.path.exists(self.wdir):\n os.makedirs(self.wdir)\n\n with open(self.filepath, \"w\") as f:\n f.write(self.input_string)\n print(f\"-- Input file [{self.filename}] written successfully.\")","def outputtofile(filename, output):\n\n # Open outputfile in write mode, create if it doesn't exist. The with\n # statement of 'open' will take care of closing the file afterwards.\n with open(filename, 'w') as f:\n # Decode output string to UTF-8\n output = output.decode('utf-8')\n # Write all output to the file\n f.write(output)\n return","def file_write(self, name: str, output: str) -> None:\n\n self._event_loop.call_soon_threadsafe(\n tpartial(self._file_write_in_thread, name, output)\n )","def to_file(self, file_path, smirnoff_data):\n pass","def writefile(filename, content):\n with open(Path(os.path.expanduser(filename)), 'w') as outfile:\n outfile.write(content)","def write_file(path, data):\n with open_local_or_gcs(path, 'w') as h_dest:\n h_dest.write(data) # pylint: disable=no-member","def write_input(eval_points, filename='input.txt'):\n util.save(eval_points, filename)","def export(fileName, result):\n with open(fileName, 'a') as output:\n output.write(result)","def writetif(self,outputname,):\n pass","def write_filepath(self, filename, file_format='FASTA', zipout=False):\n \n file_obj = open_with_intermediates(filename,'w')\n if zipout:\n file_obj.close()\n file_obj = StringIO()\n self.write(file_obj, file_format=file_format)\n if zipout:\n import gzip\n file_obj_gz = gzip.open(filename, \"wb\", 6)\n file_obj_gz.write(str.encode(file_obj.getvalue()))\n file_obj_gz.close()\n file_obj.close()","def write_filepath(self, filename, file_format='FASTA', zipout=False):\n \n file_obj = open_with_intermediates(filename,'w')\n if zipout:\n file_obj.close()\n file_obj = StringIO()\n self.write(file_obj, file_format=file_format)\n if zipout:\n import gzip\n file_obj_gz = gzip.open(filename, \"wb\", 6)\n file_obj_gz.write(str.encode(file_obj.getvalue()))\n file_obj_gz.close()\n file_obj.close()","def write_input_file(self, folder=None):\n\n # Check data integrity before anything is written on disk or run\n self.check_input_file()\n\n if folder is None:\n #sys.exit('Batch_emto.write_input_file: \\'folder\\' has to be given!')\n folder = \"./\"\n else:\n common.check_folders(folder)\n\n fl = open(folder + '/{0}.'.format(self.jobname) + self.queue_type, \"w\")\n fl.write(self.output())\n fl.close()\n return","def write_actual_output(self, output):\n actual_output_file = path.splitext(self.source_name)[0] + \".actual\"\n with open(actual_output_file, \"w\") as f:\n f.write(output)","def write_lammps_files(self): \n lammps_file = self.file_name\n with open( lammps_file, 'w' ) as f:\n f.write(self.input_string())","def write(filename):\n print(uc.write(filename))","def write_file(self, i, path, fout):\n\n test_file = path + '/' + self.output[i]\n # Write file name\n print(test_file, file=fout, end='\\n\\n')\n\n extension = os.path.splitext(test_file)[1]\n if extension == '.fits' or extension == 'FITS':\n import subprocess\n prog = self.bindir + '/fits2ascii.py -i ' + test_file\n output = subprocess.check_output(prog.split(), shell=False)\n data = output.decode()\n else:\n fin = open(test_file, 'r')\n data = fin.read()\n fin.close()\n #fout.write(data)\n print(data, file=fout)\n print(file=fout, end='\\n')","def write_input(self):\n # load template, substitute parameters and write input file\n self.homog_core()\n self.write_mat_string()\n input_tmpl = open('base_input.txt')\n templ = Template(input_tmpl.read())\n file_string = templ.substitute(cool_frac = self.vfrac_cermet,\n r_core = self.r,\n core_z = self.z,\n r_refl = self.r + self.refl_t,\n refl_min = -self.refl_t,\n refl_max = self.z + self.refl_t,\n fuel_string = self.fuel_string,\n fuel_rho = self.rho,\n fuel_vol = self.core_vol,\n refl_vol = self.core_vol,\n thermal_power = self.Q_therm)\n # write the file\n filename = 'r_{0}_{1}.i'.format(round(self.vfrac_cermet, 3), \n round(self.r, 3))\n ifile = open(filename, 'w')\n ifile.write(file_string)\n ifile.close()\n\n return filename","def write_to_file(info: List[str]) -> None:\n return","def store (input, filename) :\n cout = open (filename, 'w')\n pickle.dump (input, cout)\n cout.close ()","def write_inpfile(self, filename, units=None, version=2.2, force_coordinates=False):\n wntr.network.io.write_inpfile(self, filename, units=units, version=version, force_coordinates=force_coordinates)","def test_custom_local_output_file() -> None:\n with tempfile.TemporaryDirectory() as tmpdirname:\n file_location = os.path.join(tmpdirname, \"foo.txt\")\n\n # Instantiate the output file\n absolute_file_location = os.path.abspath(file_location)\n output_file = PyArrowFileIO().new_output(location=f\"{absolute_file_location}\")\n\n # Create the output file and write to it\n f = output_file.create()\n f.write(b\"foo\")\n\n # Confirm that bytes were written\n with open(file_location, \"rb\") as f:\n assert f.read() == b\"foo\"\n\n assert len(output_file) == 3","def writeOutput(self, output):","def write(self, filename): # real signature unknown; restored from __doc__\n pass","def save_inp_file(name: str = f'/tmp/{datetime.datetime.now()}'):\n epamodule.ENsaveinpfile(name) # THIS IS OPTIONAL\n logger.debug(name)","def write(self, content, mode='wb'):\r\n self.localpath.write(content, mode)","def save_elem_file(self, output):\n with open(output, 'wb') as fid:\n self._write_elem_header(fid)\n self._write_nodes(fid)\n self._write_elements(fid)\n self._write_neighbors(fid)","def write_to_file(inventory):\n env = Environment(loader=FileSystemLoader('templates'), trim_blocks=True)\n output_template = env.get_template('output.j2')\n # create and clean an 'outputs' folder\n path = \"./outputs\"\n try:\n shutil.rmtree(path, ignore_errors = True, onerror = None)\n except:\n print('Error while deleting directory')\n os.mkdir(path)\n os.chdir(path)\n for node, node_data in inventory.items():\n if 'outputs' in node_data:\n os.mkdir(node)\n for command, output in node_data['outputs'].items():\n # when creating filenames based on command, swap 'spaces' with 'underscores':\n command = re.sub(r\"\\s\", r\"_\", command)\n open(f\"{node}/{command}.txt\", 'a').write(\n output_template.render(node=node, data=output))\n print(\"\\n\" + f\"Job complete. If data gathering was successful, see 'outputs' directory.\")\n return inventory","def write_txt(data, out_path, type=\"w\"):\n with open(out_path, type) as f:\n f.write(data.encode(\"utf-8\"))","def write_file(filename):\r\n if Py3:\r\n return open(filename, \"w\", newline='')\r\n return open(filename, \"wb\")","def whriteInOuput(finalOutput):\n\n os.chdir(\"D:/IIHT/Python/Project/NRPT all companies scrapper/caches\")\n #open text file, return an object of type io.TextIOWrapper\n with open(\"Companies Website.txt\", \"w\") as writ:\n #write each line in the object op, return an object of type int\n writ.write('\\n'.join(finalOutput) + \"\\n\")","def write(self, output: Any) -> None:\n self._original.write(output)\n self._handler.file_write(self._name, output)","def writeToFile(rdd, parallelized, output, user, format, features):\n fileEnd = \".\" + format\n output_path = output + \"/ig/\" + user + \"/\" + user + fileEnd\n if parallelized:\n rdd.saveAsTextFile(output_path)\n else:\n arr = np.array(rdd.collect())\n if not os.path.exists(os.path.dirname(output_path)):\n os.makedirs(os.path.dirname(output_path))\n with open(output_path, 'w+') as tsvfile:\n for row in arr:\n if format == \"json\":\n tsvfile.write(row.encode(\"utf-8\", errors='ignore') + \"\\n\")\n else:\n tsvfile.write(row + \"\\n\")\n if not format == \"json\":\n output_path = output + \"/ig/\" + user + \"/\" + user + \".txt\"\n saveCorpusFile(output_path, arr, format, features)","def to_file(self, outfile):\n\n with open(outfile, \"w\") as outf:\n outf.write(self.to_string())","def write_output(content, dir_to_file):\n\n if not dir_to_file:\n dir_to_file = '{0}output-{1}'.format(dir_to_file, uuid.uuid4())\n\n f = open(dir_to_file, 'a')\n f.write(content)\n f.close()\n\n log.info('function: {} dir_to_file: {}'.format('write_output', dir_to_file))\n\n return dir_to_file","def write_to_file(file_name, content):\n with open(file_name, \"w\") as text_file:\n text_file.write(str(content))","def spew(path, data):\n with open(path, 'w+') as f:\n f.write(data)","def write_file(country, season, final, var):\n if var=='label':\n path='../results/kmeans/'\n elif var=='cluster':\n path='../results/sequence_analysis/'\n country_ = country.lower()\n season_ = season.replace('-','_')\n file_name=country_+\"_\"+season_\n newpath=path+file_name+'/'\n if not os.path.exists(newpath):\n os.makedirs(newpath)\n f = open(newpath+file_name+\".txt\",\"w\") \n f.write(final)\n f.close()","def write_data_to_file(data, filename):\n with open(filename, 'wb') as outfile:\n outfile.write(data)","def write_file(l_dta, outputfile):\n l_dta2 = []\n for row in l_dta:\n s = '\\t'.join(row)\n l_dta2.append(s)\n s_dta = \"\\r\\n\".join(l_dta2)\n try:\n with open(outputfile, 'w') as fd:\n fd.write(s_dta)\n except (IOError,) as e:\n tracker()\n return None","def filewrite(self, filename):\n io.write(self, filename)","def create_input_file(self, polymer_identifier, format, outpath):\n\n\t\tsmiles = self.get_smiles_from_identifier(polymer_identifier)\n\t\t\n\t\tresult = generate_input_files(smiles, format)\n\t\twith open(outpath, 'w+') as f:\n\t\t\tf.write(result)","def Dump_File(output):\n now = datetime.now()\n log_date = now.strftime(\"%Y-%m-%d\")\n log_file = str(log_date + \"-cisco_output.txt\")\n try:\n os.mknod(log_file)\n with open(log_file, 'wa') as f:\n f.write(output)\n f.write(\"\\n\")\n f.close()\n except OSError as err:\n with open(log_file, 'wa') as f:\n f.write(output)\n f.write(\"\\n\")\n f.close()","def _write_to_file(self, string):\n with open(self.p.base_dir + '/' + self.p.filename, 'w') as f:\n f.write(string)","def savefile(self, x, o):\n self.sep('save')\n with open(o, 'w') as f:\n f.write(x)\n sys.exit('all done (%s bytes).. saved as %s' % (len(x), o))","def beginFileOutput(self):\n self._outputFilepath = self.dataSet[self._outputFileLabel]\n self._outputFile = open(self._outputFilepath, 'w')","def writeToFile(self, basedir, write_code=0):","def _write_output_file(\n result_ds: xr.Dataset,\n input_time_encoding: dict | None,\n netcdf_version: NetcdfVersion,\n file_path: str,\n) -> None:\n if input_time_encoding:\n time_encoding = {\n \"calendar\": input_time_encoding.get(\"calendar\"),\n UNITS_KEY: input_time_encoding.get(UNITS_KEY),\n \"dtype\": input_time_encoding.get(\"dtype\"),\n }\n else:\n time_encoding = {UNITS_KEY: \"days since 1850-1-1\"}\n result_ds.to_netcdf(\n file_path,\n format=netcdf_version.name,\n encoding={\"time\": time_encoding},\n )","def write_file(self):\n\n running_time = str(self.running_time_end - self.running_time_start)\n rounded_running_time = '{:.10}'.format(running_time)\n output = 'path_to_goal: ' + str(self.path_to_goal) + '\\n'\n output += 'cost_of_path: ' + str(self.cost_of_path) + '\\n'\n output += 'nodes_expanded: ' + str(self.nodes_expanded) + '\\n'\n output += 'fringe_size: ' + str(self.fringe_size) + '\\n'\n output += 'max_fringe_size: ' + str(self.max_fringe_size) + '\\n'\n output += 'search_depth: ' + str(self.search_depth) + '\\n'\n output += 'max_search_depth: ' + str(self.max_search_depth) + '\\n'\n output += 'running_time: ' + rounded_running_time + '\\n'\n\n system_name = system()\n if system_name == 'Windows':\n output += 'max_ram_usage: (Not available on Windows OS)'\n elif system_name == 'Linux':\n output += 'max_ram_usage: ' + \\\n str(getrusage(RUSAGE_SELF).ru_maxrss / 1024) + '\\n'\n\n file = open('output.txt', 'w+')\n file.write(output)\n print(output)","def write_to_file(filename, content):\n with open(filename, 'w') as f:\n f.write(content)","def test1_write():\n with open(FILE_DIR + FILE_NAME, mode='w', encoding='utf-8') as f:\n f.write(DATA)","def write_output_shifts_to_file(self, shift_output):\n pass","def write_file(output_data, output_file):\n output_file = utils._get_absolute_path(output_file)\n with open(output_file, 'w') as json_file:\n json.dump(output_data, json_file)\n\n return output_file","def data_to_file(data, ta_file):\n file_handle = file(ta_file, \"w\")\n file_handle.write(data_to_string(data))\n file_handle.close()","def string_to_file(path_to_file, string_to_write):\n\t\twith open(path_to_file, 'w+') as f:\n\t\t\tf.write(string_to_write)","def write(self, output):\n logging.info('write %s' % output)\n make_folder(output)\n f = open(output, 'w')\n code = self.get_code()\n if code:\n f.write(code)\n f.close()","def writeOut(self):\n # import time\n self.outHeader = self.srcHeader\n for line in self.outHeader:\n self.outFile.write(line + '\\n')\n # now = time.asctime(time.localtime(time.time()))\n # self.outFile.write('%% -- %s -- Written to new alog' % now)\n for time_s in sorted(self.outData):\n for sens in self.outData[time_s]:\n for meas in self.outData[time_s][sens]:\n valu = self.outData[time_s][sens][meas]\n msg_list = [str(time_s), meas, sens, str(valu)]\n line_string = reconstructLine(msg_list)\n self.outFile.write(line_string + '\\n')","def writeText(outputText, fileName):\n with open(fileName,\"w\") as fileObject:\n fileObject.write(outputText)","def write_to_file(filename, data):\n with open(filename, \"a\") as file:\n file.writelines(data)","def write_to_file(filename, data):\n with open(filename, \"a\") as file:\n file.writelines(data)","def write(self, outfile, rebasings=None):\r\n raise NotImplementedError()","def write_puzzle(to_file: str, solution: str):\n with open(to_file, \"w\") as file:\n file.write(solution)","def writeOutput(result, fname, output_dir):\n\n s = str(len(result)) + \"\\n\" + str(result).replace(\",\", \"\")[1:-1]\n fname = fname[:fname.rfind(\".\")] + \".txt\"\n os.makedirs(output_dir, exist_ok=True)\n with open(output_dir + fname, \"w\") as f:\n f.write(s)\n\n print(\"output written to: \" + output_dir + fname)","def write_to_file(filepath, data):\n\n with open(filepath, 'w') as f:\n f.write(str(data))","def writefile(name, instream, start=None, end=None, append=False):","def save_to_file(self, string):\n with open(self.output_path, \"w\") as text_file:\n text_file.write(string)\n print \"Saved to file \" + self.output_path","def write_to_output(output):\n try:\n # changing current directory to script directory\n OutputWrite.change_to_script_directory(__file__)\n # writing the output a file\n timestamp_in_secs = time.time()\n time_stamp_readable = datetime.datetime.fromtimestamp(\n timestamp_in_secs).strftime(\"%Y_%m_%d-%Ih_%Mm_%Ss_%p\")\n try:\n if not os.path.isdir('../results'):\n os.chdir('..')\n print('Current directory {0}'.format(os.getcwd()))\n os.mkdir('./results')\n OutputWrite.change_to_script_directory(__file__)\n except OSError as _ex_:\n print(\"Unable to create results directory {0}\".format(_ex_))\n abspath = os.path.abspath('..')\n print('abspath of ..', abspath)\n path = OutputWrite.create_dir_structure()\n file_name = os.path.join(path, 'output_' +\n time_stamp_readable)\n print('The file name after joining', file_name)\n with open(file_name, 'w') as file_obj:\n file_obj.write(output)\n\n except FileNotFoundError as err:\n print('Unable write the test results into the file {0}'.\n format(err))","def write_output_file(self, index):\n ctx = self.block_store.make_local_output(self.expected_outputs[index])\n self.open_output_contexts[index] = ctx\n return ctx.get_filename()","def saveIntoFile(self, fname, data, mode='a'):\n\t\tg = open(fname, mode)\n\t\tg.write(data)\n\t\tg.close()","def export_file(self):\n if self.args.keyfilter:\n self.filter_keys()\n if self.args.datafilter:\n self.filter_values()\n json.dump(self.outputdata, self.outfile, indent=self.args.indent)\n self.outfile.write('\\n')","def make_outputfile(self, solved_status, filename):\n filename = filename.split(\".\")\n filename[0] = filename[0].replace(\"Input\",\"Output\")\n str_filename = \".\"\n str_filename = str_filename.join(filename)\n # print(str_filename)\n\n f = open(str_filename,\"w+\")\n\n if(solved_status):\n string_rep = self.values_to_grid()\n ptr = 0\n for row in range(0,9):\n for col in range(0,9):\n f.write(string_rep[ptr]+ \" \")\n ptr += 1\n f.write(\"\\r\\n\") #windows compatiable formatting...\n else:\n f.write(\"Unable to solve this puzzle.\")\n\n f.close()","def file_writer(path, data):\n with open(path, \"a\") as file:\n file.write(data + \"\\n\")","def __write_file(path, link_name, context):\n file_name = ''\n for strng in ['/', 'http:']:\n if not file_name:\n file_name = link_name.replace(strng, '')\n else:\n file_name = file_name.replace(strng, '')\n\n full_path = os.path.join(path)\n if not os.path.exists(full_path):\n os.makedirs(full_path)\n open(full_path + '/' + file_name, 'w').write(context.encode('utf-8'))\n logging.info('File: %s Created', full_path + '/' + file_name)","def write_result(self, file_name):\n f = file(file_name, \"w\")\n f.write(self.m_result)\n f.close()","def to_file(self, filename=None):\n name = None\n if filename is not None:\n name = filename\n elif self.name:\n name = self.name\n\n if name:\n #f = open(self.name, 'w')\n f = codecs.open(name, 'w', encoding='utf-8')\n self.seek(0)\n f.write(self.read())\n f.close()\n else:\n print \"No log_name for this log\"","def tofile(self, f):\n raise NotImplementedError(\"RedisLocalBloomFilter not support tofile\")","def write_text_tofile(text):\n try:\n with open(os.path.join(script_dir, 'output_file.txt'), 'a') as output:\n output.write(text + '\\n')\n except:\n pass","def process_output_file_write(output_file, response):\n\n with open(output_file, \"w\") as output_file:\n output_file.write(response)","def write(self):\n # # Sometimes file is not written properly. So delete and rewrite it\n # os.system('rm {}'.format(snip_dir + '/' + self.name))\n # if 'NUM_TIME_STEPS' not in self.define.keys():\n # warnings.warn('NUM_TIME_STEPS missing in header. Execution may hang!')\n with open(snip_dir + '/' + self.name, 'w') as f:\n f.write('/* Temporary generated file for snip process definitions before compilation */\\n')\n f.write(self.__str__())\n\n # os.system('ls {}'.format(snip_dir + '/' + self.name))"],"string":"[\n \"def _write_output_file(output: str, file_name: str):\\n\\tfile1 = open(file_name, 'w')\\n\\tfile1.write(output)\\n\\tfile1.close()\",\n \"def __export_file(self, filename, output):\\n outfile = open(filename, \\\"w\\\")\\n outfile.write(output)\\n outfile.close\\n print(\\\"Output written to file: \\\" + filename + \\\"\\\\n\\\")\",\n \"def write_to_file(self, filename: str) -> None:\",\n \"def write_to_file(output, test_case_name, path):\\n path_to_store = OutputWrite.make_test_dir(path, test_case_name)\\n time_stamp = OutputWrite.get_time_stamp()\\n try:\\n LOG.debug('Changing the dir to {0}'.format(path_to_store))\\n os.chdir(path_to_store)\\n except Exception as _ex_:\\n LOG.exception('Error :{0}'.format(_ex_))\\n else:\\n file_name = os.path.join(path_to_store, test_case_name +\\n time_stamp)\\n LOG.debug('The file name after joining = {0}'.format(file_name))\\n try:\\n LOG.debug('Writing Test case output to the file')\\n with open(file_name, 'w') as file_obj:\\n file_obj.write(output)\\n except FileNotFoundError as _ex_:\\n LOG.exception('Error : {0}'.format(_ex_))\",\n \"def write(self, fname):\\n pass\",\n \"def _write_file(template, localcontext, output_path, name):\\n output = template.render(localcontext)\\n filename = os.sep.join((output_path, name))\\n try:\\n os.makedirs(os.path.dirname(filename))\\n except Exception:\\n pass\\n with open(filename, 'w', encoding='utf-8') as f:\\n f.write(output)\\n print u' [ok] writing %s' % filename\",\n \"def output(self, _in, out, **kwds):\\n out.write(_in.read())\",\n \"def fileWrite(content):\\n file = open('./result.txt', 'w')\\n file.write(content)\\n file.close()\",\n \"def write_file(self, fname, name, inputd):\\r\\n self.filename = name\\r\\n if fname != \\\".\\\":\\r\\n self.fname = f\\\"{fname}\\\\\\\\\\\"\\r\\n self.pathwrite = os.path.join(self.p, self.fname)\\r\\n else:\\r\\n self.pathwrite = self.p\\r\\n self.input = inputd\\r\\n try:\\r\\n self.path = os.path.join(self.pathwrite, self.filename)\\r\\n with open(self.path, 'w') as file:\\r\\n file.write(self.input)\\r\\n self.confirms = True\\r\\n except Exception as error:\\r\\n print(error)\\r\\n finally:\\r\\n return self.confirms\",\n \"def write(self, filename):\\n pass\",\n \"def write(self, filename):\\n pass\",\n \"def file_write(stuff, file_path):\\n with open(file_path, \\\"wt\\\") as fo:\\n fo.write(stuff)\",\n \"def _write_file(output_path: str, file_content: Iterable[str]) -> None:\\n with open(output_path, \\\"w+\\\", encoding=\\\"utf-8\\\") as f:\\n f.writelines(file_content)\\n\\n logging.info(f\\\"wrote to '{output_path}'\\\")\",\n \"def writeto(self, fileout):\\n \\n dump_pkl(self.data, fileout)\",\n \"def _toFile(self):\\n pass\",\n \"def out(filename, s):\\n\\tf = open(filename, 'w')\\n\\tf.write(s)\\n\\tf.close()\",\n \"def _write_file(template, localcontext, output_path, name, override):\\n # set localsiteurl for context so that Contents can adjust links\\n if localcontext[\\\"localsiteurl\\\"]:\\n context[\\\"localsiteurl\\\"] = localcontext[\\\"localsiteurl\\\"]\\n output = template.render(localcontext)\\n path = sanitised_join(output_path, name)\\n\\n try:\\n os.makedirs(os.path.dirname(path))\\n except Exception:\\n pass\\n\\n with self._open_w(path, \\\"utf-8\\\", override=override) as f:\\n f.write(output)\\n logger.info(\\\"Writing %s\\\", path)\\n\\n # Send a signal to say we're writing a file with some specific\\n # local context.\\n signals.content_written.send(path, context=localcontext)\",\n \"def write_file(self):\\n if self._write_file == None:\\n return\\n\\n try:\\n out = file(self._write_file, \\\"w\\\")\\n except IOError, e:\\n print e\\n sys.exit(1)\\n out.writelines(\\\"A cases\\\") \\n out.close()\",\n \"def write(self, out):\",\n \"def write_the_contents_to_the_same_file(self):\\n if not len(self.student_list):\\n print('There is no contents to write')\\n return\\n\\n if self._filename is None:\\n self._filename = self.input_filename()\\n\\n with open(self._filename, 'w') as OUT:\\n OUT.write(self.student_list.to_csv(date_format='%Y-%m-%d',\\n sep='\\\\t', header=False, columns=self.columns_to_save))\\n print(f'Data are saved into {self._filename!r}')\",\n \"def _amber_write_input_file(self):\\n logger.debug(\\\"Writing {}\\\".format(self.input))\\n with open(os.path.join(self.path, self.input), \\\"w\\\") as f:\\n f.write(\\\"{}\\\\n\\\".format(self.title))\\n f.write(\\\" &cntrl\\\\n\\\")\\n self._write_dict_to_mdin(f, self.cntrl)\\n\\n if self.ewald is not None:\\n f.write(\\\" &ewald\\\\n\\\")\\n self._write_dict_to_mdin(f, self.ewald)\\n\\n if self.cntrl[\\\"nmropt\\\"] == 1:\\n if self.wt is not None:\\n for line in self.wt:\\n f.write(\\\" \\\"+line+\\\"\\\\n\\\")\\n f.write(\\\" &wt type = 'END', /\\\\n\\\")\\n if self.restraint_file is not None:\\n f.write(\\\"DISANG = {}\\\\n\\\".format(self.restraint_file))\\n f.write(\\\"LISTOUT = POUT\\\\n\\\\n\\\")\\n if self.group is not None:\\n f.write(\\\"{:s}\\\".format(self.group))\",\n \"def _write_file(template, localcontext, output_path, name, override):\\r\\n old_locale = locale.setlocale(locale.LC_ALL)\\r\\n locale.setlocale(locale.LC_ALL, str('C'))\\r\\n try:\\r\\n output = template.render(localcontext)\\r\\n finally:\\r\\n locale.setlocale(locale.LC_ALL, old_locale)\\r\\n path = os.path.join(output_path, name)\\r\\n try:\\r\\n os.makedirs(os.path.dirname(path))\\r\\n except Exception:\\r\\n pass\\r\\n\\r\\n with self._open_w(path, 'utf-8', override=override) as f:\\r\\n f.write(output)\\r\\n logger.info('writing {}'.format(path))\\r\\n\\r\\n # Send a signal to say we're writing a file with some specific\\r\\n # local context.\\r\\n signals.content_written.send(path, context=localcontext)\",\n \"def make_file(self):\\n\\n f = open(get_output_path(), \\\"w\\\")\\n \\n f.write(self.export())\\n \\n f.close()\\n\\n return self\",\n \"def save_input(self):\\n if not os.path.exists(self.wdir):\\n os.makedirs(self.wdir)\\n\\n with open(self.filepath, \\\"w\\\") as f:\\n f.write(self.input_string)\\n print(f\\\"-- Input file [{self.filename}] written successfully.\\\")\",\n \"def outputtofile(filename, output):\\n\\n # Open outputfile in write mode, create if it doesn't exist. The with\\n # statement of 'open' will take care of closing the file afterwards.\\n with open(filename, 'w') as f:\\n # Decode output string to UTF-8\\n output = output.decode('utf-8')\\n # Write all output to the file\\n f.write(output)\\n return\",\n \"def file_write(self, name: str, output: str) -> None:\\n\\n self._event_loop.call_soon_threadsafe(\\n tpartial(self._file_write_in_thread, name, output)\\n )\",\n \"def to_file(self, file_path, smirnoff_data):\\n pass\",\n \"def writefile(filename, content):\\n with open(Path(os.path.expanduser(filename)), 'w') as outfile:\\n outfile.write(content)\",\n \"def write_file(path, data):\\n with open_local_or_gcs(path, 'w') as h_dest:\\n h_dest.write(data) # pylint: disable=no-member\",\n \"def write_input(eval_points, filename='input.txt'):\\n util.save(eval_points, filename)\",\n \"def export(fileName, result):\\n with open(fileName, 'a') as output:\\n output.write(result)\",\n \"def writetif(self,outputname,):\\n pass\",\n \"def write_filepath(self, filename, file_format='FASTA', zipout=False):\\n \\n file_obj = open_with_intermediates(filename,'w')\\n if zipout:\\n file_obj.close()\\n file_obj = StringIO()\\n self.write(file_obj, file_format=file_format)\\n if zipout:\\n import gzip\\n file_obj_gz = gzip.open(filename, \\\"wb\\\", 6)\\n file_obj_gz.write(str.encode(file_obj.getvalue()))\\n file_obj_gz.close()\\n file_obj.close()\",\n \"def write_filepath(self, filename, file_format='FASTA', zipout=False):\\n \\n file_obj = open_with_intermediates(filename,'w')\\n if zipout:\\n file_obj.close()\\n file_obj = StringIO()\\n self.write(file_obj, file_format=file_format)\\n if zipout:\\n import gzip\\n file_obj_gz = gzip.open(filename, \\\"wb\\\", 6)\\n file_obj_gz.write(str.encode(file_obj.getvalue()))\\n file_obj_gz.close()\\n file_obj.close()\",\n \"def write_input_file(self, folder=None):\\n\\n # Check data integrity before anything is written on disk or run\\n self.check_input_file()\\n\\n if folder is None:\\n #sys.exit('Batch_emto.write_input_file: \\\\'folder\\\\' has to be given!')\\n folder = \\\"./\\\"\\n else:\\n common.check_folders(folder)\\n\\n fl = open(folder + '/{0}.'.format(self.jobname) + self.queue_type, \\\"w\\\")\\n fl.write(self.output())\\n fl.close()\\n return\",\n \"def write_actual_output(self, output):\\n actual_output_file = path.splitext(self.source_name)[0] + \\\".actual\\\"\\n with open(actual_output_file, \\\"w\\\") as f:\\n f.write(output)\",\n \"def write_lammps_files(self): \\n lammps_file = self.file_name\\n with open( lammps_file, 'w' ) as f:\\n f.write(self.input_string())\",\n \"def write(filename):\\n print(uc.write(filename))\",\n \"def write_file(self, i, path, fout):\\n\\n test_file = path + '/' + self.output[i]\\n # Write file name\\n print(test_file, file=fout, end='\\\\n\\\\n')\\n\\n extension = os.path.splitext(test_file)[1]\\n if extension == '.fits' or extension == 'FITS':\\n import subprocess\\n prog = self.bindir + '/fits2ascii.py -i ' + test_file\\n output = subprocess.check_output(prog.split(), shell=False)\\n data = output.decode()\\n else:\\n fin = open(test_file, 'r')\\n data = fin.read()\\n fin.close()\\n #fout.write(data)\\n print(data, file=fout)\\n print(file=fout, end='\\\\n')\",\n \"def write_input(self):\\n # load template, substitute parameters and write input file\\n self.homog_core()\\n self.write_mat_string()\\n input_tmpl = open('base_input.txt')\\n templ = Template(input_tmpl.read())\\n file_string = templ.substitute(cool_frac = self.vfrac_cermet,\\n r_core = self.r,\\n core_z = self.z,\\n r_refl = self.r + self.refl_t,\\n refl_min = -self.refl_t,\\n refl_max = self.z + self.refl_t,\\n fuel_string = self.fuel_string,\\n fuel_rho = self.rho,\\n fuel_vol = self.core_vol,\\n refl_vol = self.core_vol,\\n thermal_power = self.Q_therm)\\n # write the file\\n filename = 'r_{0}_{1}.i'.format(round(self.vfrac_cermet, 3), \\n round(self.r, 3))\\n ifile = open(filename, 'w')\\n ifile.write(file_string)\\n ifile.close()\\n\\n return filename\",\n \"def write_to_file(info: List[str]) -> None:\\n return\",\n \"def store (input, filename) :\\n cout = open (filename, 'w')\\n pickle.dump (input, cout)\\n cout.close ()\",\n \"def write_inpfile(self, filename, units=None, version=2.2, force_coordinates=False):\\n wntr.network.io.write_inpfile(self, filename, units=units, version=version, force_coordinates=force_coordinates)\",\n \"def test_custom_local_output_file() -> None:\\n with tempfile.TemporaryDirectory() as tmpdirname:\\n file_location = os.path.join(tmpdirname, \\\"foo.txt\\\")\\n\\n # Instantiate the output file\\n absolute_file_location = os.path.abspath(file_location)\\n output_file = PyArrowFileIO().new_output(location=f\\\"{absolute_file_location}\\\")\\n\\n # Create the output file and write to it\\n f = output_file.create()\\n f.write(b\\\"foo\\\")\\n\\n # Confirm that bytes were written\\n with open(file_location, \\\"rb\\\") as f:\\n assert f.read() == b\\\"foo\\\"\\n\\n assert len(output_file) == 3\",\n \"def writeOutput(self, output):\",\n \"def write(self, filename): # real signature unknown; restored from __doc__\\n pass\",\n \"def save_inp_file(name: str = f'/tmp/{datetime.datetime.now()}'):\\n epamodule.ENsaveinpfile(name) # THIS IS OPTIONAL\\n logger.debug(name)\",\n \"def write(self, content, mode='wb'):\\r\\n self.localpath.write(content, mode)\",\n \"def save_elem_file(self, output):\\n with open(output, 'wb') as fid:\\n self._write_elem_header(fid)\\n self._write_nodes(fid)\\n self._write_elements(fid)\\n self._write_neighbors(fid)\",\n \"def write_to_file(inventory):\\n env = Environment(loader=FileSystemLoader('templates'), trim_blocks=True)\\n output_template = env.get_template('output.j2')\\n # create and clean an 'outputs' folder\\n path = \\\"./outputs\\\"\\n try:\\n shutil.rmtree(path, ignore_errors = True, onerror = None)\\n except:\\n print('Error while deleting directory')\\n os.mkdir(path)\\n os.chdir(path)\\n for node, node_data in inventory.items():\\n if 'outputs' in node_data:\\n os.mkdir(node)\\n for command, output in node_data['outputs'].items():\\n # when creating filenames based on command, swap 'spaces' with 'underscores':\\n command = re.sub(r\\\"\\\\s\\\", r\\\"_\\\", command)\\n open(f\\\"{node}/{command}.txt\\\", 'a').write(\\n output_template.render(node=node, data=output))\\n print(\\\"\\\\n\\\" + f\\\"Job complete. If data gathering was successful, see 'outputs' directory.\\\")\\n return inventory\",\n \"def write_txt(data, out_path, type=\\\"w\\\"):\\n with open(out_path, type) as f:\\n f.write(data.encode(\\\"utf-8\\\"))\",\n \"def write_file(filename):\\r\\n if Py3:\\r\\n return open(filename, \\\"w\\\", newline='')\\r\\n return open(filename, \\\"wb\\\")\",\n \"def whriteInOuput(finalOutput):\\n\\n os.chdir(\\\"D:/IIHT/Python/Project/NRPT all companies scrapper/caches\\\")\\n #open text file, return an object of type io.TextIOWrapper\\n with open(\\\"Companies Website.txt\\\", \\\"w\\\") as writ:\\n #write each line in the object op, return an object of type int\\n writ.write('\\\\n'.join(finalOutput) + \\\"\\\\n\\\")\",\n \"def write(self, output: Any) -> None:\\n self._original.write(output)\\n self._handler.file_write(self._name, output)\",\n \"def writeToFile(rdd, parallelized, output, user, format, features):\\n fileEnd = \\\".\\\" + format\\n output_path = output + \\\"/ig/\\\" + user + \\\"/\\\" + user + fileEnd\\n if parallelized:\\n rdd.saveAsTextFile(output_path)\\n else:\\n arr = np.array(rdd.collect())\\n if not os.path.exists(os.path.dirname(output_path)):\\n os.makedirs(os.path.dirname(output_path))\\n with open(output_path, 'w+') as tsvfile:\\n for row in arr:\\n if format == \\\"json\\\":\\n tsvfile.write(row.encode(\\\"utf-8\\\", errors='ignore') + \\\"\\\\n\\\")\\n else:\\n tsvfile.write(row + \\\"\\\\n\\\")\\n if not format == \\\"json\\\":\\n output_path = output + \\\"/ig/\\\" + user + \\\"/\\\" + user + \\\".txt\\\"\\n saveCorpusFile(output_path, arr, format, features)\",\n \"def to_file(self, outfile):\\n\\n with open(outfile, \\\"w\\\") as outf:\\n outf.write(self.to_string())\",\n \"def write_output(content, dir_to_file):\\n\\n if not dir_to_file:\\n dir_to_file = '{0}output-{1}'.format(dir_to_file, uuid.uuid4())\\n\\n f = open(dir_to_file, 'a')\\n f.write(content)\\n f.close()\\n\\n log.info('function: {} dir_to_file: {}'.format('write_output', dir_to_file))\\n\\n return dir_to_file\",\n \"def write_to_file(file_name, content):\\n with open(file_name, \\\"w\\\") as text_file:\\n text_file.write(str(content))\",\n \"def spew(path, data):\\n with open(path, 'w+') as f:\\n f.write(data)\",\n \"def write_file(country, season, final, var):\\n if var=='label':\\n path='../results/kmeans/'\\n elif var=='cluster':\\n path='../results/sequence_analysis/'\\n country_ = country.lower()\\n season_ = season.replace('-','_')\\n file_name=country_+\\\"_\\\"+season_\\n newpath=path+file_name+'/'\\n if not os.path.exists(newpath):\\n os.makedirs(newpath)\\n f = open(newpath+file_name+\\\".txt\\\",\\\"w\\\") \\n f.write(final)\\n f.close()\",\n \"def write_data_to_file(data, filename):\\n with open(filename, 'wb') as outfile:\\n outfile.write(data)\",\n \"def write_file(l_dta, outputfile):\\n l_dta2 = []\\n for row in l_dta:\\n s = '\\\\t'.join(row)\\n l_dta2.append(s)\\n s_dta = \\\"\\\\r\\\\n\\\".join(l_dta2)\\n try:\\n with open(outputfile, 'w') as fd:\\n fd.write(s_dta)\\n except (IOError,) as e:\\n tracker()\\n return None\",\n \"def filewrite(self, filename):\\n io.write(self, filename)\",\n \"def create_input_file(self, polymer_identifier, format, outpath):\\n\\n\\t\\tsmiles = self.get_smiles_from_identifier(polymer_identifier)\\n\\t\\t\\n\\t\\tresult = generate_input_files(smiles, format)\\n\\t\\twith open(outpath, 'w+') as f:\\n\\t\\t\\tf.write(result)\",\n \"def Dump_File(output):\\n now = datetime.now()\\n log_date = now.strftime(\\\"%Y-%m-%d\\\")\\n log_file = str(log_date + \\\"-cisco_output.txt\\\")\\n try:\\n os.mknod(log_file)\\n with open(log_file, 'wa') as f:\\n f.write(output)\\n f.write(\\\"\\\\n\\\")\\n f.close()\\n except OSError as err:\\n with open(log_file, 'wa') as f:\\n f.write(output)\\n f.write(\\\"\\\\n\\\")\\n f.close()\",\n \"def _write_to_file(self, string):\\n with open(self.p.base_dir + '/' + self.p.filename, 'w') as f:\\n f.write(string)\",\n \"def savefile(self, x, o):\\n self.sep('save')\\n with open(o, 'w') as f:\\n f.write(x)\\n sys.exit('all done (%s bytes).. saved as %s' % (len(x), o))\",\n \"def beginFileOutput(self):\\n self._outputFilepath = self.dataSet[self._outputFileLabel]\\n self._outputFile = open(self._outputFilepath, 'w')\",\n \"def writeToFile(self, basedir, write_code=0):\",\n \"def _write_output_file(\\n result_ds: xr.Dataset,\\n input_time_encoding: dict | None,\\n netcdf_version: NetcdfVersion,\\n file_path: str,\\n) -> None:\\n if input_time_encoding:\\n time_encoding = {\\n \\\"calendar\\\": input_time_encoding.get(\\\"calendar\\\"),\\n UNITS_KEY: input_time_encoding.get(UNITS_KEY),\\n \\\"dtype\\\": input_time_encoding.get(\\\"dtype\\\"),\\n }\\n else:\\n time_encoding = {UNITS_KEY: \\\"days since 1850-1-1\\\"}\\n result_ds.to_netcdf(\\n file_path,\\n format=netcdf_version.name,\\n encoding={\\\"time\\\": time_encoding},\\n )\",\n \"def write_file(self):\\n\\n running_time = str(self.running_time_end - self.running_time_start)\\n rounded_running_time = '{:.10}'.format(running_time)\\n output = 'path_to_goal: ' + str(self.path_to_goal) + '\\\\n'\\n output += 'cost_of_path: ' + str(self.cost_of_path) + '\\\\n'\\n output += 'nodes_expanded: ' + str(self.nodes_expanded) + '\\\\n'\\n output += 'fringe_size: ' + str(self.fringe_size) + '\\\\n'\\n output += 'max_fringe_size: ' + str(self.max_fringe_size) + '\\\\n'\\n output += 'search_depth: ' + str(self.search_depth) + '\\\\n'\\n output += 'max_search_depth: ' + str(self.max_search_depth) + '\\\\n'\\n output += 'running_time: ' + rounded_running_time + '\\\\n'\\n\\n system_name = system()\\n if system_name == 'Windows':\\n output += 'max_ram_usage: (Not available on Windows OS)'\\n elif system_name == 'Linux':\\n output += 'max_ram_usage: ' + \\\\\\n str(getrusage(RUSAGE_SELF).ru_maxrss / 1024) + '\\\\n'\\n\\n file = open('output.txt', 'w+')\\n file.write(output)\\n print(output)\",\n \"def write_to_file(filename, content):\\n with open(filename, 'w') as f:\\n f.write(content)\",\n \"def test1_write():\\n with open(FILE_DIR + FILE_NAME, mode='w', encoding='utf-8') as f:\\n f.write(DATA)\",\n \"def write_output_shifts_to_file(self, shift_output):\\n pass\",\n \"def write_file(output_data, output_file):\\n output_file = utils._get_absolute_path(output_file)\\n with open(output_file, 'w') as json_file:\\n json.dump(output_data, json_file)\\n\\n return output_file\",\n \"def data_to_file(data, ta_file):\\n file_handle = file(ta_file, \\\"w\\\")\\n file_handle.write(data_to_string(data))\\n file_handle.close()\",\n \"def string_to_file(path_to_file, string_to_write):\\n\\t\\twith open(path_to_file, 'w+') as f:\\n\\t\\t\\tf.write(string_to_write)\",\n \"def write(self, output):\\n logging.info('write %s' % output)\\n make_folder(output)\\n f = open(output, 'w')\\n code = self.get_code()\\n if code:\\n f.write(code)\\n f.close()\",\n \"def writeOut(self):\\n # import time\\n self.outHeader = self.srcHeader\\n for line in self.outHeader:\\n self.outFile.write(line + '\\\\n')\\n # now = time.asctime(time.localtime(time.time()))\\n # self.outFile.write('%% -- %s -- Written to new alog' % now)\\n for time_s in sorted(self.outData):\\n for sens in self.outData[time_s]:\\n for meas in self.outData[time_s][sens]:\\n valu = self.outData[time_s][sens][meas]\\n msg_list = [str(time_s), meas, sens, str(valu)]\\n line_string = reconstructLine(msg_list)\\n self.outFile.write(line_string + '\\\\n')\",\n \"def writeText(outputText, fileName):\\n with open(fileName,\\\"w\\\") as fileObject:\\n fileObject.write(outputText)\",\n \"def write_to_file(filename, data):\\n with open(filename, \\\"a\\\") as file:\\n file.writelines(data)\",\n \"def write_to_file(filename, data):\\n with open(filename, \\\"a\\\") as file:\\n file.writelines(data)\",\n \"def write(self, outfile, rebasings=None):\\r\\n raise NotImplementedError()\",\n \"def write_puzzle(to_file: str, solution: str):\\n with open(to_file, \\\"w\\\") as file:\\n file.write(solution)\",\n \"def writeOutput(result, fname, output_dir):\\n\\n s = str(len(result)) + \\\"\\\\n\\\" + str(result).replace(\\\",\\\", \\\"\\\")[1:-1]\\n fname = fname[:fname.rfind(\\\".\\\")] + \\\".txt\\\"\\n os.makedirs(output_dir, exist_ok=True)\\n with open(output_dir + fname, \\\"w\\\") as f:\\n f.write(s)\\n\\n print(\\\"output written to: \\\" + output_dir + fname)\",\n \"def write_to_file(filepath, data):\\n\\n with open(filepath, 'w') as f:\\n f.write(str(data))\",\n \"def writefile(name, instream, start=None, end=None, append=False):\",\n \"def save_to_file(self, string):\\n with open(self.output_path, \\\"w\\\") as text_file:\\n text_file.write(string)\\n print \\\"Saved to file \\\" + self.output_path\",\n \"def write_to_output(output):\\n try:\\n # changing current directory to script directory\\n OutputWrite.change_to_script_directory(__file__)\\n # writing the output a file\\n timestamp_in_secs = time.time()\\n time_stamp_readable = datetime.datetime.fromtimestamp(\\n timestamp_in_secs).strftime(\\\"%Y_%m_%d-%Ih_%Mm_%Ss_%p\\\")\\n try:\\n if not os.path.isdir('../results'):\\n os.chdir('..')\\n print('Current directory {0}'.format(os.getcwd()))\\n os.mkdir('./results')\\n OutputWrite.change_to_script_directory(__file__)\\n except OSError as _ex_:\\n print(\\\"Unable to create results directory {0}\\\".format(_ex_))\\n abspath = os.path.abspath('..')\\n print('abspath of ..', abspath)\\n path = OutputWrite.create_dir_structure()\\n file_name = os.path.join(path, 'output_' +\\n time_stamp_readable)\\n print('The file name after joining', file_name)\\n with open(file_name, 'w') as file_obj:\\n file_obj.write(output)\\n\\n except FileNotFoundError as err:\\n print('Unable write the test results into the file {0}'.\\n format(err))\",\n \"def write_output_file(self, index):\\n ctx = self.block_store.make_local_output(self.expected_outputs[index])\\n self.open_output_contexts[index] = ctx\\n return ctx.get_filename()\",\n \"def saveIntoFile(self, fname, data, mode='a'):\\n\\t\\tg = open(fname, mode)\\n\\t\\tg.write(data)\\n\\t\\tg.close()\",\n \"def export_file(self):\\n if self.args.keyfilter:\\n self.filter_keys()\\n if self.args.datafilter:\\n self.filter_values()\\n json.dump(self.outputdata, self.outfile, indent=self.args.indent)\\n self.outfile.write('\\\\n')\",\n \"def make_outputfile(self, solved_status, filename):\\n filename = filename.split(\\\".\\\")\\n filename[0] = filename[0].replace(\\\"Input\\\",\\\"Output\\\")\\n str_filename = \\\".\\\"\\n str_filename = str_filename.join(filename)\\n # print(str_filename)\\n\\n f = open(str_filename,\\\"w+\\\")\\n\\n if(solved_status):\\n string_rep = self.values_to_grid()\\n ptr = 0\\n for row in range(0,9):\\n for col in range(0,9):\\n f.write(string_rep[ptr]+ \\\" \\\")\\n ptr += 1\\n f.write(\\\"\\\\r\\\\n\\\") #windows compatiable formatting...\\n else:\\n f.write(\\\"Unable to solve this puzzle.\\\")\\n\\n f.close()\",\n \"def file_writer(path, data):\\n with open(path, \\\"a\\\") as file:\\n file.write(data + \\\"\\\\n\\\")\",\n \"def __write_file(path, link_name, context):\\n file_name = ''\\n for strng in ['/', 'http:']:\\n if not file_name:\\n file_name = link_name.replace(strng, '')\\n else:\\n file_name = file_name.replace(strng, '')\\n\\n full_path = os.path.join(path)\\n if not os.path.exists(full_path):\\n os.makedirs(full_path)\\n open(full_path + '/' + file_name, 'w').write(context.encode('utf-8'))\\n logging.info('File: %s Created', full_path + '/' + file_name)\",\n \"def write_result(self, file_name):\\n f = file(file_name, \\\"w\\\")\\n f.write(self.m_result)\\n f.close()\",\n \"def to_file(self, filename=None):\\n name = None\\n if filename is not None:\\n name = filename\\n elif self.name:\\n name = self.name\\n\\n if name:\\n #f = open(self.name, 'w')\\n f = codecs.open(name, 'w', encoding='utf-8')\\n self.seek(0)\\n f.write(self.read())\\n f.close()\\n else:\\n print \\\"No log_name for this log\\\"\",\n \"def tofile(self, f):\\n raise NotImplementedError(\\\"RedisLocalBloomFilter not support tofile\\\")\",\n \"def write_text_tofile(text):\\n try:\\n with open(os.path.join(script_dir, 'output_file.txt'), 'a') as output:\\n output.write(text + '\\\\n')\\n except:\\n pass\",\n \"def process_output_file_write(output_file, response):\\n\\n with open(output_file, \\\"w\\\") as output_file:\\n output_file.write(response)\",\n \"def write(self):\\n # # Sometimes file is not written properly. So delete and rewrite it\\n # os.system('rm {}'.format(snip_dir + '/' + self.name))\\n # if 'NUM_TIME_STEPS' not in self.define.keys():\\n # warnings.warn('NUM_TIME_STEPS missing in header. Execution may hang!')\\n with open(snip_dir + '/' + self.name, 'w') as f:\\n f.write('/* Temporary generated file for snip process definitions before compilation */\\\\n')\\n f.write(self.__str__())\\n\\n # os.system('ls {}'.format(snip_dir + '/' + self.name))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7053892","0.67866904","0.668285","0.66073346","0.6562557","0.6537651","0.6532199","0.6498945","0.64802593","0.6445508","0.6445508","0.64421177","0.64155847","0.63887167","0.62964857","0.6274529","0.6260469","0.6249611","0.6246505","0.616572","0.6132764","0.6127372","0.61225563","0.6111018","0.61038035","0.6086001","0.6078048","0.6067646","0.6061735","0.605867","0.60586274","0.60531896","0.60513973","0.60513973","0.60303456","0.6029831","0.60016894","0.60001814","0.5999319","0.599587","0.59766954","0.59718835","0.5961006","0.59515125","0.5943434","0.5942599","0.591909","0.5907284","0.5898245","0.58959186","0.5892633","0.58876485","0.5877225","0.5867685","0.58575803","0.58538157","0.5844978","0.5844439","0.584362","0.58410615","0.5837476","0.58359283","0.58358675","0.58268404","0.58249354","0.5822424","0.5821378","0.58137125","0.5813117","0.5812364","0.5812045","0.58092284","0.5806275","0.5802164","0.57946587","0.5794465","0.5791119","0.57741684","0.57719773","0.5762941","0.5762283","0.5760757","0.575213","0.57516956","0.5745933","0.57385063","0.57340544","0.5732016","0.57300377","0.572397","0.57165205","0.57118225","0.57107544","0.57071346","0.57048464","0.57035","0.5699773","0.56989473","0.56981856","0.5697717","0.56942976"],"string":"[\n \"0.7053892\",\n \"0.67866904\",\n \"0.668285\",\n \"0.66073346\",\n \"0.6562557\",\n \"0.6537651\",\n \"0.6532199\",\n \"0.6498945\",\n \"0.64802593\",\n \"0.6445508\",\n \"0.6445508\",\n \"0.64421177\",\n \"0.64155847\",\n \"0.63887167\",\n \"0.62964857\",\n \"0.6274529\",\n \"0.6260469\",\n \"0.6249611\",\n \"0.6246505\",\n \"0.616572\",\n \"0.6132764\",\n \"0.6127372\",\n \"0.61225563\",\n \"0.6111018\",\n \"0.61038035\",\n \"0.6086001\",\n \"0.6078048\",\n \"0.6067646\",\n \"0.6061735\",\n \"0.605867\",\n \"0.60586274\",\n \"0.60531896\",\n \"0.60513973\",\n \"0.60513973\",\n \"0.60303456\",\n \"0.6029831\",\n \"0.60016894\",\n \"0.60001814\",\n \"0.5999319\",\n \"0.599587\",\n \"0.59766954\",\n \"0.59718835\",\n \"0.5961006\",\n \"0.59515125\",\n \"0.5943434\",\n \"0.5942599\",\n \"0.591909\",\n \"0.5907284\",\n \"0.5898245\",\n \"0.58959186\",\n \"0.5892633\",\n \"0.58876485\",\n \"0.5877225\",\n \"0.5867685\",\n \"0.58575803\",\n \"0.58538157\",\n \"0.5844978\",\n \"0.5844439\",\n \"0.584362\",\n \"0.58410615\",\n \"0.5837476\",\n \"0.58359283\",\n \"0.58358675\",\n \"0.58268404\",\n \"0.58249354\",\n \"0.5822424\",\n \"0.5821378\",\n \"0.58137125\",\n \"0.5813117\",\n \"0.5812364\",\n \"0.5812045\",\n \"0.58092284\",\n \"0.5806275\",\n \"0.5802164\",\n \"0.57946587\",\n \"0.5794465\",\n \"0.5791119\",\n \"0.57741684\",\n \"0.57719773\",\n \"0.5762941\",\n \"0.5762283\",\n \"0.5760757\",\n \"0.575213\",\n \"0.57516956\",\n \"0.5745933\",\n \"0.57385063\",\n \"0.57340544\",\n \"0.5732016\",\n \"0.57300377\",\n \"0.572397\",\n \"0.57165205\",\n \"0.57118225\",\n \"0.57107544\",\n \"0.57071346\",\n \"0.57048464\",\n \"0.57035\",\n \"0.5699773\",\n \"0.56989473\",\n \"0.56981856\",\n \"0.5697717\",\n \"0.56942976\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83163,"cells":{"query":{"kind":"string","value":"Test KS test for insertion indices with a specified mode"},"document":{"kind":"string","value":"def test_ks_test(mode):\n indices = np.random.randint(0, 1000, 1000)\n out = compute_indices_ks_test(indices, 1000, mode=mode)\n assert all([o > 0.0 for o in out])"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_ks_test_undefined_mode():\n indices = np.random.randint(0, 1000, 1000)\n with pytest.raises(RuntimeError):\n compute_indices_ks_test(indices, 1000, mode=\"two-sided\")","def test_ks_test_empty_indices():\n out = compute_indices_ks_test([], 1000, mode=\"D+\")\n assert all(o is None for o in out)","def test_k_rank_approximate(corpus):\n return","def test_single_run(self):\n\n traces = np.load('data/traces.npy')\n keys = np.load('data/key.npy')\n plain = np.load('data/plain.npy')\n correct_indices = [4254, 4257, 1400, 4429, 4919, 1399, 4918, 1398, 4917, 1397]\n\n indices = SOSTD.list_of_best_indices(traces, keys, plain, 10, 0)\n self.assertTrue(np.array_equal(indices, correct_indices))","def test_estimate_mode() -> None:\n # Create a set of random parameters\n parameters = np.sort(1 + 5 * np.random.rand(3))\n parameters[[2, 1]] = parameters[[1, 2]]\n\n # Create an instance\n my_univariate_input = UnivDist(\n distribution=DISTRIBUTION_NAME, parameters=parameters\n )\n\n # Generate a sample\n sample_size = 1000000 # Should give 1e-0 accuracy\n xx = my_univariate_input.get_sample(sample_size)\n\n # Estimated result\n y, edges = np.histogram(xx, bins=\"auto\")\n mode = edges[np.argmax(y)]\n\n # Analytical result\n mode_ref = parameters[2]\n\n # Assertion\n assert np.isclose(mode, mode_ref, rtol=1, atol=1)","def KS(dataDict=None, dataLabel='data', mode='two.sided'):\n\n # test calling values\n modes = ['two.sided', 'less', 'greater']\n if mode not in modes:\n raise ValueError('RSTATS.KS: mode must be in: ', modes)\n if (dataDict is None or not isinstance(dataDict, dict) \n or len(dataDict.keys()) != 2):\n raise ValueError('RSTATS.KS: dataDict must be a dictionary with '\n + 'exactly 2 keys')\n\n labels = list(dataDict.keys())\n# NGroups = len(labels)\n cmdx = 'X=c(%s)' % ', '.join(str(x) for x in dataDict[labels[0]])\n cmdy = 'Y=c(%s)' % ', '.join(str(y) for y in dataDict[labels[1]])\n# package \"perm\" not available on mac os x, use coin instead\n# importr('perm')\n robjects.r(cmdx)\n robjects.r(cmdy)\n\n# (pvalue, nmc) = permutation(dataDict, dataDict.keys())\n\n u = robjects.r(\"ks.test(X, Y, alternative='%s')\" % mode)\n\n pvalue = float(u[1][0])\n statvalue = float(u[0][0]) # get diff estimate\n if dataLabel is not None:\n print ('\\nKolmogorov-Smirnov test. Dataset = %s' % (dataLabel))\n print(u' Test statistic: {:8.4f}'.format(statvalue))\n print(u' p={:8.6f}, [mode={:s}]'.format(float(pvalue), mode))\n return pvalue","def test_determine_k(self):\n test_dir_name = os.path.dirname(__file__)\n feat_array_fn = os.path.join(\n test_dir_name, \"data\", \"four_clusters.csv\")\n df = pd.read_csv(feat_array_fn)\n feat_array = df[[\"x\", \"y\"]].values\n\n clusterer = Clusterer(feat_array_fn, \"/dev/null\", [])\n best_k = clusterer._determine_k(feat_array, 9)\n\n self.assertEqual(best_k, 4)\n\n feat_array_fn = os.path.join(\n test_dir_name, \"data\", \"iris.csv\")\n df = pd.read_csv(feat_array_fn)\n feat_array = df[[\n \"Sepal.Length\", \"Sepal.Width\", \"Petal.Length\",\n \"Petal.Width\"]].values\n\n clusterer = Clusterer(feat_array_fn, \"/dev/null\", [])\n best_k = clusterer._determine_k(feat_array, 9)\n\n self.assertEqual(best_k, 2)","def test_single_run_sosd(self):\n\n traces = np.load('data/traces.npy')[:1000]\n keys = np.load('data/key.npy')[:1000]\n plain = np.load('data/plain.npy')[:1000]\n correct_indices = [4371, 2401, 2402, 4878, 4370, 4877, 4882, 4369, 4881, 2723]\n\n indices = SOSTD.list_of_best_indices(traces, keys, plain, 10, 0, False)\n self.assertTrue(np.array_equal(indices, correct_indices))","def test_k_index():\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\n 400.]) * units.hPa\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\n -23.5]) * units.degC\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\n -57.5]) * units.degC\n ki = k_index(pressure, temperature, dewpoint)\n assert_almost_equal(ki, 33.5 * units.degC, 2)","def test_k_index_xarray(index_xarray_data):\n result = k_index(index_xarray_data.isobaric, index_xarray_data.temperature,\n index_xarray_data.dewpoint)\n assert_array_almost_equal(result,\n np.array([[[312., 311., 310.], [309., 308., 307.]]]) * units.K)","def add_mode_index(self) -> None:","def test_call_alt_threshold(self):\r\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\r\n\r\n exp = {0: ['cdhit_test_seqs_0'],\r\n 1: ['cdhit_test_seqs_1'],\r\n 2: ['cdhit_test_seqs_2'],\r\n 3: ['cdhit_test_seqs_3'],\r\n 4: ['cdhit_test_seqs_4'],\r\n 5: ['cdhit_test_seqs_5'],\r\n 6: ['cdhit_test_seqs_6', 'cdhit_test_seqs_8'],\r\n 7: ['cdhit_test_seqs_7'],\r\n 8: ['cdhit_test_seqs_9']}\r\n\r\n app = CdHitOtuPicker(params={'Similarity': 0.90})\r\n obs = app(self.tmp_seq_filepath1)\r\n self.assertEqual(obs, exp)","def test_result(mask, seg, mode='ec'):\n assert mask.shape == seg.shape, print('mask and seg must have the same shape.')\n temp = np.zeros(seg.shape)\n temp_mask = np.zeros(seg.shape)\n if mode == 'ec':\n temp[seg == 4] = 1\n temp_mask[mask == 4] = 1\n mts = Seg_metric(temp, temp_mask)\n\n elif mode == 'core':\n temp[seg == 4] = 1\n temp[seg == 1] = 1\n temp_mask[mask == 4] = 1\n temp_mask[mask == 1] = 1\n mts = Seg_metric(temp, temp_mask)\n\n elif mode == 'full':\n temp[seg != 0] = 1\n temp_mask[mask != 0] = 1\n mts = Seg_metric(temp, temp_mask)\n return mts.dice(), mts.iou(), mts.fp(), mts.fn()\n # print('dice:{},IoU:{}'.format(mts.dice(), mts.iou()))","def check_k_anonymity(data: np.ndarray, k: int, qi_indices=None):\n print(Counter(str(e) for e in data[:, qi_indices]))\n\n occurrences = list(Counter(str(e) for e in data[:, qi_indices]).values())\n for j in range(len(occurrences)):\n if occurrences[j] < k:\n return False\n return True","def ks_test_function(dim, thresh):\n def ks_test(table1, table2):\n from scipy.stats import ks_2samp\n sample1 = table1.get_cols(dim)[0]\n sample2 = table2.get_cols(dim)[0]\n if thresh != None:\n sample1[sample1<thresh] = 0\n sample2[sample2<thresh] = 0\n ks, p_ks = ks_2samp(sample1, sample2)\n return ks\n return ks_test","def ks_test(timeseries):\r\n\r\n hour_ago = time() - 3600\r\n ten_minutes_ago = time() - 600\r\n reference = scipy.array([x[1] for x in timeseries if x[0] >= hour_ago and x[0] < ten_minutes_ago])\r\n probe = scipy.array([x[1] for x in timeseries if x[0] >= ten_minutes_ago])\r\n\r\n if reference.size < 20 or probe.size < 20:\r\n return False\r\n\r\n ks_d,ks_p_value = scipy.stats.ks_2samp(reference, probe)\r\n\r\n if ks_p_value < 0.05 and ks_d > 0.5:\r\n adf = sm.tsa.stattools.adfuller(reference, 10)\r\n if adf[1] < 0.05:\r\n return True\r\n\r\n return False","def Q8_test():\n dispo = [False, True, True, False]\n tab_dist = [[0, 4.123105625617661, 4.242640687119285, 4.47213595499958], [4.123105625617661, 0, 4.123105625617661, 7.810249675906654], [4.242640687119285, 4.123105625617661, 0, 5.0990195135927845], [4.47213595499958, 7.810249675906654, 5.0990195135927845, 0]]\n return 1 == indice(0, tab_dist, dispo)","def test_binned_output(self, sparse, adapt, pad_to_max, mode, dtype):\n # Adapt breaks ties with sort order.\n vocab_data = [\"wind\", \"fire\", \"earth\", \"and\"]\n # IDF weight for a term in 1 out of 1 document is log(1 + 1/2).\n idf_data = [math.log(1.5)] * 4\n input_data = np.array(\n [\n [\"and\", \"earth\", \"fire\", \"and\", \"\"],\n [\"michigan\", \"wind\", \"and\", \"ohio\", \"\"],\n ]\n )\n\n if mode == \"count\":\n expected_output = np.array(\n [\n [0, 0, 1, 1, 2],\n [2, 1, 0, 0, 1],\n ]\n )\n elif mode == \"tf_idf\":\n expected_output = np.array(\n [\n [0, 0, 1, 1, 2],\n [2, 1, 0, 0, 1],\n ]\n ) * math.log(1.5)\n else:\n expected_output = np.array(\n [\n [0, 0, 1, 1, 1],\n [1, 1, 0, 0, 1],\n ]\n )\n expected_output_shape = [None, 5]\n if pad_to_max:\n expected_output = np.concatenate(\n (expected_output, [[0], [0]]), axis=1\n )\n expected_output_shape = [None, 6]\n\n inputs = keras.Input(shape=(None,), dtype=tf.string)\n layer = index_lookup.IndexLookup(\n max_tokens=6,\n num_oov_indices=1,\n mask_token=\"\",\n oov_token=\"[OOV]\",\n output_mode=mode,\n pad_to_max_tokens=pad_to_max,\n vocabulary_dtype=tf.string,\n sparse=sparse,\n vocabulary=None if adapt else vocab_data,\n idf_weights=None if adapt or mode != \"tf_idf\" else idf_data,\n dtype=dtype,\n )\n if adapt:\n layer.adapt(vocab_data)\n outputs = layer(inputs)\n model = keras.Model(inputs, outputs)\n output_data = model.predict(input_data)\n if sparse:\n output_data = tf.sparse.to_dense(output_data)\n # Check output data.\n self.assertAllClose(expected_output, output_data)\n # Check symbolic output shape.\n self.assertAllEqual(expected_output_shape, outputs.shape.as_list())\n # Check output dtype.\n self.assertAllEqual(dtype, output_data.dtype)","def kmeans(features, projection, ite = 20, k = 4, threshold = 1e-4):\n from scipy.cluster.vq import kmeans, vq\n import datetime\n\n from measures import spatial_coherence \n \n centroids, distance = kmeans(features, k, iter=ite, thresh=threshold)\n #code, _ = vq(features, centroids)\n \n run_ = datetime.datetime.now().strftime(\"%y_%m_%d_%H_%M\")\n \n params = \"projection_size=%d, k=%d\" %(len(projection), k)\n #clusters = clusters_from_code(code, k, projection)\n \n clustering_id = \"(%s)_(%s)_(%s)_(%s)\" %(\"exhaustive_kmeans\", params, run_, projection)\n #print clustering_id\n km_clt = KMClustering(algorithm =\"exhaustive_kmeans\", parameters = params, run = run_,\n clustering_id = clustering_id, clusters = [], ccontains_noise = False, cclustering_on_dimension = True)\n\n \n #measures = {'spatial_coherence': spatial_coherence(km_clt, len(features))[0], 'distortion': distance}\n #km_clt.update_measures(measures)\n \n return km_clt","def main_eaftest(point_ind, permutations=10240, alpha=0.05):\n \n # ------ Attainment indicator values information ------\n \n npoints = len(point_ind)\n nvars = len(point_ind[0]) # Número de execuções total\n nruns = nvars // 2 # Número de execuções de 1 algo\n \n print \"- Attainment indicator values information:\"\n print \" * Number of points:\", npoints\n print \" * Joint executions:\", nvars, \"(%d + %d)\" % (nruns, nruns)\n print\n \n assert nvars % 2 == 0, \"Number of total joint executions must be even.\"\n assert nvars <= 64, \"Not implemented with more than 64 joint executions.\"\n \n # ------ Test Statistic ------\n\n print \"- Computing the test statistic...\" \n stat2 = libaft.ksstat(point_ind, order=2)\n print \" * Test statistic = %d/%d\" % (stat2, nruns)\n print \" = %f\" % (stat2 / float(nruns)), '\\n'\n \n # ------ Estimate null distribution ------\n\n print \"- Using %d random permutations to estimate null distribution.\" % permutations\n print \" Please be patient...\"\n maxdist = np.zeros(permutations, dtype=np.int32) # Max distance array\n rtime = time.time()\n \n masks = bintools.make_masks(permutations, nvars, seed=64)\n for i, maxd in enumerate(KERNEL.runkernel(point_ind, masks)):\n maxdist[i] = maxd\n if (i+1) % (permutations//20) == 0:\n print \" %6d permutations, %7.3f sec\" % (i+1, time.time()-rtime)\n print \" * Time elapsed: %7.3f\" % (time.time()-rtime)\n \n # Compute null distribution from max distance array\n tail = np.bincount(maxdist, minlength=nruns+1)\n print \" * Non-normalized null distribution:\"\n print tail\n print\n \n # ------ Accept/reject null hypothesis ------\n \n # NB: -1 resulta das diferentes convenções para a definição de valor crítico\n crit = criticalvalue(tail, alpha * permutations) - 1\n pval = pvalue(tail, stat2) / float(permutations)\n \n print \"- Null hypothesis decision:\" \n print \" * Critical value = %d/%d\" % (crit, nruns)\n print \" = %f\" % (crit / float(nruns))\n print \" * p-value = %f\" % pval\n if pval <= alpha:\n print \" <= alpha (%s)\\n\" % alpha\n print \" * Decision: REJECT the null hypothesis\"\n else:\n print \" > alpha (%s)\\n\" % alpha\n print \" * Decision: do NOT REJECT the null hypothesis\"\n print","def test_jw_sparse_index(self):\n expected = [1, 2]\n calculated_indices = jw_number_indices(1, 2)\n self.assertEqual(expected, calculated_indices)\n\n expected = [3]\n calculated_indices = jw_number_indices(2, 2)\n self.assertEqual(expected, calculated_indices)","def test_k(self):\n\n # We have a new K. It should have nothing in it.\n loc_, sloc_, test_loc, test_sloc = self.k__.get_totals()\n self.assertEqual(loc_, 0)\n self.assertEqual(sloc_, 0)\n self.assertEqual(test_loc, 0)\n self.assertEqual(test_sloc, 0)\n\n self.check_counts('zz', 0, 0, 0, 0) # not in map\n self.check_counts('py', 0, 0, 0, 0) # not in map\n\n self.k__.add_counts('py', 7, 3)\n self.check_counts('py', 7, 3, 0, 0)\n self.k__.add_counts('py', 5, 2)\n self.check_counts('py', 12, 5, 0, 0)\n\n self.k__.add_test_counts('py', 8, 4)\n self.check_counts('py', 12, 5, 8, 4)\n self.k__.add_test_counts('py', 9, 3)\n self.check_counts('py', 12, 5, 17, 7)\n\n expected = \"py:%d/%d T%.1f%%\" % (12 + 17, 5 + 7, 700.0 / 12)\n # DEBUG\n # print(\"Expected: %s\" % expected)\n # END\n self.assertEqual(self.k__.pretty_counts('py'), expected)","def test_key_predicate(datum):\n return 0 < datum","def _kmedoids_run(X, n_clusters, dist_func, max_iter=1000, verbose=True):\n # Get initial centers\n n_samples, n_features = len(X), 2\n init_ids = _get_init_centers(n_clusters, X)\n if verbose:\n print('Initial centers are: {}'.format(init_ids))\n centers = init_ids\n members, costs, tot_cost, dist_mat = _get_cost(X, init_ids, dist_func)\n cc, swapped = 0, True\n while True:\n swapped = False\n for i in range(n_samples):\n if i not in centers:\n for j in range(len(centers)):\n centers_ = deepcopy(centers)\n centers_[j] = i\n members_, costs_, tot_cost_, dist_mat_ = _get_cost(X, centers_, dist_func)\n if tot_cost_ < tot_cost:\n members, costs, tot_cost, dist_mat = members_, costs_, tot_cost_, dist_mat_\n centers = centers_\n swapped = True\n if verbose:\n print('Change centers to {}'.format(centers))\n if cc > max_iter:\n if verbose:\n print('End Searching by reaching maximum iteration')\n break\n if not swapped:\n if verbose:\n print('End Searching by no swaps')\n break\n cc += 1\n return centers, members, costs, tot_cost, dist_mat","def do_knn(x_data):\n return True","def sample_features(self, X, mode='auto', return_index=False): \n\n X = check_array(X)\n n_features = X.shape[1]\n if mode in ['auto', 'sqrt']:\n sample_features = int(np.sqrt(n_features))\n elif mode == 'log2':\n sample_features = int(np.log(n_features))\n elif not mode:\n sample_features = n_features\n idx = np.random.choice(n_features, sample_features, replace=False)\n if return_index:\n return X[:, idx], idx\n return X[:, idx]","def test_sparse():\n\n rng = np.random.RandomState(0)\n\n X = rng.rand(20, 2)\n X[X < 0.8] = 0\n X_csr = sp.csr_matrix(X)\n\n bisect_means = BisectingKMeans(n_clusters=3, random_state=0)\n\n bisect_means.fit(X_csr)\n sparse_centers = bisect_means.cluster_centers_\n\n bisect_means.fit(X)\n normal_centers = bisect_means.cluster_centers_\n\n # Check if results is the same for dense and sparse data\n assert_allclose(normal_centers, sparse_centers, atol=1e-8)","def runcount(test_keys, sigma, sigma_max, sigma_step,\n npoints_min, npoints_max, npoints_step):\n run = 1\n for key in test_keys:\n if key:\n while sigma < sigma_max:\n npoints = npoints_min\n while npoints < npoints_max:\n npoints += npoints_step\n run += 1\n sigma += sigma_step\n return run","def test_genx(nsd, backend):\n # NCOLS of data:\n # 2 - test kernel only\n # 3 - test kernel and chi2 calculation\n # 4 - test resolution smearing and chi2 calculation\n\n test_name, slabs, data = nsd\n\n kernel_test(slabs, data, backend)","def test_keypoint_detection(init_env, config_file):\n run_all_steps(init_env, config_file)","def sortKey( self, mode, matrix ):\n # TODO: figure out how to handle \n return False,[],None","def test_integer_map_key_index():\n\tlib.backup_and_restore(\n\t\tlambda context: create_indexes(lib.create_integer_map_key_index),\n\t\tNone,\n\t\tlambda context: check_indexes(lib.check_map_key_index, 12345)\n\t)","def test_index_start(self):\n sp_file = os.path.join(\"tests\", \"data\", \"geolife\", \"geolife_staypoints.csv\")\n sp = ti.read_staypoints_csv(sp_file, tz=\"utc\", index_col=\"id\", crs=\"epsg:4326\")\n\n # reproject to WGS_1984_UTM_Zone_49N\n sp = sp.to_crs(\"epsg:32649\")\n\n distance_metric_ls = [\"haversine\", \"euclidean\"]\n agg_level_ls = [\"dataset\", \"user\"]\n for distance_metric in distance_metric_ls:\n for agg_level in agg_level_ls:\n _, locations = sp.as_staypoints.generate_locations(\n method=\"dbscan\", epsilon=10, num_samples=1, distance_metric=distance_metric, agg_level=agg_level\n )\n assert (locations.index == np.arange(len(locations))).any()","def example2():\r\n params = {'w': 2 * pi * 300 * nu.THz,\r\n 'd_list': [inf, inf],\r\n 'ex_list': [1, -5],\r\n 'ez_list': [1, 1],\r\n 'mu_list': [1.1, 1.3]}\r\n \r\n kx_list = find_kx(params, show_progress=False, grid_points=30,\r\n iterations=8, reduction_factor=14,\r\n plot_full_region=True)\r\n print('kx_list: ',\r\n ['(%.4g+%.4gj) rad/um' % (kx.real / nu.um**-1, kx.imag / nu.um**-1)\r\n for kx in kx_list])\r\n for kx in kx_list:\r\n new_params = deepcopy(params)\r\n new_params['kx'] = kx\r\n print('---')\r\n print('With kx =', '(%.4g+%.4gj) rad/um' % (kx.real / nu.um**-1, kx.imag / nu.um**-1),\r\n ', checking mode...')\r\n new_params = find_all_params_from_kx(new_params)\r\n print('kz in each layer:',\r\n ['(%.4g+%.4gj) rad/um' % (kz.real / nu.um**-1, kz.imag / nu.um**-1)\r\n for kz in new_params['kz_list']])\r\n check_mode_results = check_mode(new_params)\r\n if check_mode_results is not True:\r\n print('This seems not to be a real mode. Error code:')\r\n print(check_mode_results)\r\n else:\r\n print('The mode passes all tests! Plotting...')\r\n plot_mode(new_params)\r\n scale_factor = (5 * nu.nW/nu.um) / new_params['Sx_total']\r\n scaled_params = rescale_fields(scale_factor, new_params)\r\n print('If this wave carries 5 nW/um power (i.e. 5 nW travels in +x-direction')\r\n print('through the surface x=0, 0<y<1um, -inf<z<inf)')\r\n print('then |Ex(0,0)|=',\r\n abs(Ex(0, scaled_params)) / (nu.V/nu.m), 'V/m')","def test_fit_ks(distribution):\n print(\"TESTING: K-S fit for %s distribution\" % distribution.upper())\n print(\" fitting to others\")\n for sample_dist in dist.get():\n print(\" %s\" % sample_dist.upper())\n params = dist.DISTRIBUTIONS[sample_dist][dist.KEY_TEST_PARAMS]\n test_sample = dist.samples(sample_dist, params)\n fit_results = fit.fit_ks(distribution, test_sample)\n print(\" input parameters: %s\" % dist.get_params(params, sample_dist))\n print(\" fit parameters: %s\" % dist.get_params(fit_results['params'], distribution))\n print(\" log-likelihood: %r\" % fit_results['log-likelihood'])\n print(\" K-S statistics: %r\" % fit_results['D'])","def clustering_dbscan_o3d():\n pass","def test_main_on_cluster(self):\r\n\r\n command = \" \".join([\"denoiser.py\",\r\n \"--force\", \"-o\", self.test_dir, \"-c\", \"-n\", \"2\",\r\n \"-i\", \"%s/qiime/support_files/denoiser/TestData/denoiser_test_set.sff.txt\" % PROJECT_HOME,\r\n \"-f\", \"%s/qiime/support_files/denoiser/TestData/test_set_seqs.fna\" % PROJECT_HOME])\r\n\r\n result = Popen(command, shell=True, universal_newlines=True,\r\n stdout=PIPE, stderr=STDOUT).stdout.read()\r\n self.result_dir = self.test_dir\r\n\r\n observed = \"\".join(list(open(self.result_dir + \"centroids.fasta\")))\r\n self.assertEqual(observed, self.expected)","def KS(self, using, dx=0.0001):\n pits = np.array(self.PIT(using=using,dx=dx))\n ks_result = skgof.ks_test(pits, stats.uniform())\n return ks_result.statistic, ks_result.pvalue","def evaluate(inshp, kshp, (dx, dy)=(1, 1), nkern=1, mode='valid', ws=True):\r\n N = numpy\r\n\r\n # inshp contains either 2 entries (height,width) or 3 (nfeatures,h,w)\r\n # in the first case, default nfeatures to 1\r\n if N.size(inshp) == 2:\r\n inshp = (1,) + inshp\r\n\r\n inshp = N.array(inshp)\r\n kshp = N.array(kshp)\r\n ksize = N.prod(kshp)\r\n\r\n kern = ksize - 1 - N.arange(ksize)\r\n\r\n # size of output image if doing proper convolution\r\n # (mode='full',dx=dy=0) outshp is the actual output shape\r\n # given the parameters\r\n fulloutshp = inshp[1:] + kshp - 1\r\n if mode == 'valid':\r\n s = -1\r\n else:\r\n s = 1\r\n outshp = N.int64(N.ceil((inshp[1:] + s * kshp - s * 1) \\\r\n / N.array([dy, dx], dtype='float')))\r\n if any(outshp <= 0):\r\n err = 'Invalid kernel', kshp, 'and/or step size', (dx, dy),\\\r\n 'for given input shape', inshp\r\n raise ValueError(err)\r\n\r\n outsize = N.prod(outshp)\r\n insize = N.prod(inshp)\r\n\r\n # range of output units over which to iterate\r\n if mode == 'valid':\r\n lbound = N.array([kshp[0] - 1, kshp[1] - 1])\r\n ubound = lbound + (inshp[1:] - kshp + 1)\r\n else:\r\n lbound = N.zeros(2)\r\n ubound = fulloutshp\r\n\r\n # coordinates of image in \"fulloutshp\" coordinates\r\n topleft = N.array([kshp[0] - 1, kshp[1] - 1])\r\n # bound when counting the receptive field\r\n botright = topleft + inshp[1:]\r\n\r\n # sparse matrix specifics...\r\n if ws:\r\n spmatshp = (outsize * N.prod(kshp) * inshp[0], insize)\r\n else:\r\n spmatshp = (nkern * outsize, insize)\r\n spmat = scipy_sparse.lil_matrix(spmatshp)\r\n\r\n # loop over output image pixels\r\n z, zz = 0, 0\r\n\r\n # incremented every time we write something to the sparse\r\n # matrix this is used to track the ordering of filter tap\r\n # coefficient in sparse column ordering\r\n tapi, ntaps = 0, 0\r\n\r\n # Note: looping over the number of kernels could've been done\r\n # more efficiently as the last step (when writing to\r\n # spmat). However, this messes up the ordering of the column\r\n # values (order in which you write the values determines how\r\n # the vectorized data will get used later one)\r\n\r\n for fmapi in xrange(inshp[0]): # loop over input features\r\n # loop over number of kernels (nkern=1 for weight sharing)\r\n for n in xrange(nkern):\r\n\r\n # FOR EACH OUTPUT PIXEL...\r\n # loop over output image height\r\n for oy in N.arange(lbound[0], ubound[0], dy):\r\n # loop over output image width\r\n for ox in N.arange(lbound[1], ubound[1], dx):\r\n\r\n # kern[l] is filter value to apply at (oj,oi)\r\n # for (iy,ix)\r\n l = 0\r\n\r\n # ... ITERATE OVER INPUT UNITS IN RECEPTIVE FIELD\r\n for ky in oy + N.arange(kshp[0]):\r\n for kx in ox + N.arange(kshp[1]):\r\n\r\n # verify if we are still within image\r\n # boundaries. Equivalent to\r\n # zero-padding of the input image\r\n if (all((ky, kx) >= topleft) and\r\n all((ky, kx) < botright)):\r\n\r\n # convert to \"valid\" input space\r\n # coords used to determine column\r\n # index to write to in sparse mat\r\n iy, ix = N.array((ky, kx)) - topleft\r\n # determine raster-index of input pixel...\r\n\r\n # taking into account multiple\r\n # input features\r\n col = iy * inshp[2] + ix + \\\r\n fmapi * N.prod(inshp[1:])\r\n\r\n # convert oy,ox values to output\r\n # space coordinates\r\n if mode == 'full':\r\n (y, x) = (oy, ox)\r\n else:\r\n (y, x) = (oy, ox) - topleft\r\n # taking into account step size\r\n (y, x) = N.array([y, x]) / (dy, dx)\r\n\r\n # convert to row index of sparse matrix\r\n if ws:\r\n row = ((y * outshp[1] + x) *\r\n inshp[0] * ksize + l + fmapi *\r\n ksize)\r\n else:\r\n row = y * outshp[1] + x\r\n\r\n # Store something at that location\r\n # in sparse matrix. The written\r\n # value is only useful for the\r\n # sparse case. It will determine\r\n # the way kernel taps are mapped\r\n # onto the sparse columns (idea of\r\n # kernel map)\r\n # n*... only for sparse\r\n spmat[row + n * outsize, col] = tapi + 1\r\n\r\n # total number of active taps\r\n # (used for kmap)\r\n ntaps += 1\r\n\r\n # absolute tap index (total number of taps)\r\n tapi += 1\r\n # move on to next filter tap l=(l+1)%ksize\r\n l += 1\r\n\r\n if spmat.format != 'csc':\r\n spmat = spmat.tocsc().sorted_indices()\r\n else:\r\n # BUG ALERT: scipy0.6 has bug where data and indices are written in\r\n # reverse column ordering.\r\n # Explicit call to sorted_indices removes this problem.\r\n spmat = spmat.sorted_indices()\r\n\r\n if ws:\r\n kmap = None\r\n else:\r\n kmap = N.zeros(ntaps, dtype='int')\r\n k = 0\r\n #print 'TEMPORARY BUGFIX: REMOVE !!!'\r\n for j in xrange(spmat.shape[1]):\r\n for i_idx in xrange(spmat.indptr[j], spmat.indptr[j + 1]):\r\n if spmat.data[i_idx] != 0:\r\n # this is == spmat[i,j] - 1\r\n kmap[k] = spmat.data[i_idx] - 1\r\n k += 1\r\n\r\n # when in valid mode, it is more efficient to store in sparse row\r\n # TODO: need to implement structured dot for csr matrix\r\n assert spmat.format == 'csc'\r\n sptype = 'csc'\r\n #sptype = 'csr' if mode=='valid' else 'csc'\r\n if 0 and mode == 'valid':\r\n spmat = spmat.tocsr()\r\n\r\n rval = (spmat.indices[:spmat.size],\r\n spmat.indptr, spmatshp, sptype, outshp)\r\n if kmap is not None:\r\n rval += (kmap,)\r\n\r\n return rval","def chi2sf_inplace(x, k):","def k_nearest_neighbors(x_test, df_training, k):\n\n return np.argpartition(distance_to_each_training_point(x_test,\n df_training), k-1)[:,0:k]","def build_k_indices(num_row, k_fold, seed):\n #num_row = y.shape[0]\n interval = int(num_row / k_fold)\n np.random.seed(seed)\n indices = np.random.permutation(num_row)\n k_indices = [indices[k * interval: (k + 1) * interval]\n for k in range(k_fold)]\n return np.array(k_indices)","def findknn(xTr,xTe,k):\n\n # YOUR CODE HERE\n if k > len(xTr):\n k = len(xTr)\n \n D=l2distance(xTe, xTr)\n (m,n) = D.shape\n \n indices = []\n dists = []\n for i in range(m):\n smallest_indices = np.argsort(D[i])\n ind = smallest_indices[:k]\n dis = D[i,smallest_indices[:k]]\n indices.append(ind)\n dists.append(dis)\n \n indices = np.transpose(np.array(indices))\n dists = np.transpose(np.array(dists))\n return indices, dists","def test_n_clusters(n_clusters):\n\n rng = np.random.RandomState(0)\n X = rng.rand(10, 2)\n\n bisect_means = BisectingKMeans(n_clusters=n_clusters, random_state=0)\n bisect_means.fit(X)\n\n assert_array_equal(np.unique(bisect_means.labels_), np.arange(n_clusters))","def example1():\r\n params = {'w': 2 * pi * 300 * nu.THz,\r\n 'd_list': [inf, 40 * nu.nm, inf],\r\n 'ex_list': [1, -5 + 2j, 10],\r\n 'ez_list': [1, -3 + 3j, 7],\r\n 'mu_list': [1, 1.2, 1.3]}\r\n \r\n kx_list = find_kx(params, show_progress=False, grid_points=30,\r\n iterations=8, reduction_factor=14,\r\n plot_full_region=True)\r\n print('kx_list: ',\r\n ['(%.4g+%.4gj) rad/um' % (kx.real / nu.um**-1, kx.imag / nu.um**-1)\r\n for kx in kx_list])\r\n for kx in kx_list:\r\n new_params = deepcopy(params)\r\n new_params['kx'] = kx\r\n print('---')\r\n print('With kx =', '(%.4g+%.4gj) rad/um' % (kx.real / nu.um**-1, kx.imag / nu.um**-1),\r\n ', checking mode...')\r\n new_params = find_all_params_from_kx(new_params)\r\n print('kz in each layer:',\r\n ['(%.4g+%.4gj) rad/um' % (kz.real / nu.um**-1, kz.imag / nu.um**-1)\r\n for kz in new_params['kz_list']])\r\n check_mode_results = check_mode(new_params)\r\n if check_mode_results is not True:\r\n print('This seems not to be a real mode. Error code:')\r\n print(check_mode_results)\r\n else:\r\n print('The mode passes all tests! Plotting...')\r\n plot_mode(new_params)\r\n scale_factor = (5 * nu.nW/nu.um) / new_params['Sx_total']\r\n scaled_params = rescale_fields(scale_factor, new_params)\r\n print('If this wave carries 5 nW/um power (i.e. 5 nW travels in +x-direction')\r\n print('through the surface x=0, 0<y<1um, -inf<z<inf)')\r\n print('then |Ex(0,0)|=',\r\n abs(Ex(0, scaled_params)) / (nu.V/nu.m), 'V/m')","def test_oss_sk_estimator():\n check_estimator(OneSidedSelection)","def test_k_1(self):\n knn = KNeighborsClassifier(n_neighbors=1)\n knn.fit(X_train, y_train)\n prediction = knn.predict(X_test)\n\n knn2 = Knn(n_neighbors=1)\n knn2.fit(X_train, y_train)\n prediction2 = knn2.predict(X_test)\n\n assert np.alltrue(prediction == prediction2), \"Error testing knn with k=1\"","def get_data_indices(aperiodic_mode):\n\n indices = {\n 'CF' : 0,\n 'PW' : 1,\n 'BW' : 2,\n 'offset' : 0,\n 'knee' : 1 if aperiodic_mode == 'knee' else None,\n 'exponent' : 1 if aperiodic_mode == 'fixed' else 2\n }\n\n return indices","def test_st_facets00401m11_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m11.xsd\",\n instance=\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m11_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def test_st_facets00401m6_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m6.xsd\",\n instance=\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m6_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def key_filter(template_index, num_keys, row):\n\n template = nori.core.cfg['templates'][template_index]\n\n if (nori.core.cfg['key_mode'] == 'all' and\n template[T_KEY_MODE_KEY] == 'all'):\n return True\n\n if not check_key_list_match(nori.core.cfg['key_mode'],\n nori.core.cfg['key_list'], num_keys, row):\n return False\n\n if not check_key_list_match(template[T_KEY_MODE_KEY],\n template[T_KEY_LIST_KEY], num_keys, row):\n return False\n\n return True","def cv_msk(x, k, permu=True):\n n = x if isinstance(x, int) else len(x)\n idx = np.array(np.arange(np.ceil(n / float(k)) * k), '<i4')\n if permu:\n idx = np.random.permutation(idx)\n idx = idx.reshape(k, -1) % n\n msk = np.zeros((k, n), 'bool')\n for _ in range(k):\n msk[_, idx[_, ]] = True\n return msk","def find_nearest_neighbors_idx(X, x, k):\n ## homework:start\n result = \n ## homework:end\n return result","def __init__(self, mode) :\n\n self.mode = mode \n\n self.run_pairs = get_runs(self.mode, check_exists=True)\n\n if settings.RANK == 0 :\n print('%d samples in the %s set'%(len(self.run_pairs), str(mode)))","def _scipy_fk_test(self, mode='median', alpha=0.01):\n q0 = self.get_group_data(0, self.df_test_resampled, ['Q'])\n q1 = self.get_group_data(1, self.df_test_resampled, ['Q'])\n\n with warnings.catch_warnings(): # supress scipy warnings\n warnings.filterwarnings('ignore')\n fstats, pval = fligner(q0, q1, center=mode)\n\n stats_fk = {'z': fstats, 'pval': pval}\n\n if stats_fk['pval'] <= alpha: # With CHI2 approximation\n h = 1\n else:\n h = 0\n\n return h, stats_fk","def test_index_stability(self, example_staypoints):\n sp = example_staypoints\n sp2, locs = sp.as_staypoints.generate_locations(\n method=\"dbscan\", epsilon=10, num_samples=2, distance_metric=\"haversine\", agg_level=\"user\"\n )\n assert sp.index.equals(sp2.index)","def Test(self, K_test=5, n_eg=None, K=5, \\\n C_parameters=np.array([0.01, 0.1, 1.0, 10., 100.]), \\\n norm_SF=True, norm_plane=True, tol_=0.0001, \\\n max_iter_=10000):\n\n # test acc array\n test_acc = np.zeros((self.__n_type, 3))\n n_test_eg = np.zeros((self.__n_type, 3))\n\n # Saving examples for real training later and shuffling examples\n for idx_type, type_ in enumerate(self.__types_unique):\n np.random.shuffle(self.training_R[idx_type])\n np.random.shuffle(self.training_NR[idx_type])\n training_R = list(self.training_R)\n training_NR = list(self.training_NR)\n\n\n for K_ in range(K_test):\n print('K = '+str(K_))\n\n # Creates a testing an training set from original training set\n testing_R = []\n testing_NR = []\n for idx_type, type_ in enumerate(self.__types_unique):\n\n # Finds rearrangements and non-rearrangements of given particle\n # type\n Rs_type = self.training_R[idx_type]\n NRs_type = self.training_NR[idx_type]\n\n # Finds a test set of rearrangements\n Rs_type_test = Rs_type[K_::K_test]\n NRs_type_test = NRs_type[K_::K_test]\n n_test = min(len(Rs_type_test),len(NRs_type_test))\n Rs_type_test = Rs_type_test[:n_test]\n NRs_type_test = NRs_type_test[:n_test]\n testing_R.append(Rs_type_test)\n testing_NR.append(NRs_type_test)\n\n # Deletes test set from training set\n Rs_type = np.delete(Rs_type, \\\n list(range(K_,len(Rs_type),K_test)),axis=0)\n NRs_type = np.delete(NRs_type, \\\n list(range(K_,len(NRs_type),K_test)), axis=0)\n self.training_R[idx_type] = Rs_type\n self.training_NR[idx_type] = NRs_type\n\n # Trains softness model using reduced training set\n self.Train(n_eg=n_eg, K=K, \\\n C_parameters=C_parameters, norm_SF=norm_SF, \\\n norm_plane=norm_plane, tol_=tol_, \\\n max_iter_=max_iter_)\n\n # Tests new plane against test set\n for idx_type, type_ in enumerate(self.__types_unique):\n\n # Finds number of soft rearrangements and hard \n # non-rearrangements\n soft_Rs = self.GetSoft(testing_R[idx_type])\n soft_NRs = self.GetSoft(testing_NR[idx_type])\n nRs = np.sum(soft_Rs > 0)\n nNRs = np.sum(soft_NRs < 0)\n\n # Calculates # of correctly classified particles\n test_acc[idx_type][0] += nRs+nNRs\n n_test_eg[idx_type][0] += len(soft_Rs)+len(soft_NRs)\n test_acc[idx_type][1] += nRs\n n_test_eg[idx_type][1] += len(soft_Rs)\n test_acc[idx_type][2] += nNRs\n n_test_eg[idx_type][2] += len(soft_NRs)\n\n # Returns self.training_R and self.training_NR to original state\n self.training_R = list(training_R)\n self.training_NR = list(training_NR)\n\n # Calculates test set accuracy\n test_acc = test_acc / n_test_eg\n\n return test_acc","def test_ks_ms(distribution):\n print(\"TESTING: K-S model selection for %s distribution\" % distribution.upper())\n params = dist.DISTRIBUTIONS[distribution][dist.KEY_TEST_PARAMS]\n print(\" creating sample\")\n test_sample = dist.samples(distribution, params)\n print(\" calculating K-S statistics for all distributions\")\n print(\" input parameters: %s\" % dist.get_params(params, distribution))\n fit_results = {}\n best_ksd = 1.0\n best_model = dist.get()[0]\n for d in dist.get():\n print(\" %s:\" % d.upper())\n fit_results[d] = fit.fit_ks(d, test_sample)\n if fit_results[d]['D'] < best_ksd:\n best_ksd = fit_results[d]['D']\n best_model = d\n print(\" %s\" % dist.get_params(fit_results[d]['params'], d))\n print(\" D = %r\" % fit_results[d]['D'])\n params = fit_results[d]['params']\n p = 0\n for r in range(100):\n synthetic_sample = dist.samples(d, params, len(test_sample))\n ksd = me.ks_statistics(dist.get_sample_cdf(synthetic_sample), dist.cdf(d, params, np.max(synthetic_sample)))\n if ksd > fit_results[d]['D']:\n p += 1\n print(\" p = %r\" % (float(p)/100.0))\n print(\" Best fitting model: %s\" % best_model.upper())\n print_pmfs(test_sample, fit_results, 'TEST-KS.CSV')","def test_call_low_cluster_identity(self):\r\n\r\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\r\n # Should only get 6 clusters\r\n exp_otu_ids = [str(x) for x in range(6)]\r\n\r\n exp_clusters =\\\r\n [['uclust_test_seqs_0', 'uclust_test_seqs_6',\r\n 'uclust_test_seqs_9'], ['uclust_test_seqs_1'], ['uclust_test_seqs_2'],\r\n ['uclust_test_seqs_3',\r\n 'uclust_test_seqs_5',\r\n 'uclust_test_seqs_8'],\r\n ['uclust_test_seqs_4'], ['uclust_test_seqs_7']]\r\n\r\n app = UsearchOtuPicker(params={'save_intermediate_files': False,\r\n 'db_filepath': self.tmp_ref_database,\r\n 'output_dir': self.temp_dir,\r\n 'remove_usearch_logs': True,\r\n 'reference_chimera_detection': False,\r\n 'de_novo_chimera_detection': False,\r\n 'cluster_size_filtering': False,\r\n 'minlen': 12,\r\n 'w': 12,\r\n 'minsize': 1,\r\n 'percent_id': 0.80,\r\n 'percent_id_err': 0.97\r\n })\r\n\r\n obs = app(self.tmp_seq_filepath1)\r\n\r\n obs_otu_ids = sorted(obs.keys())\r\n obs_clusters = sorted(obs.values())\r\n # The relation between otu ids and clusters is abitrary, and\r\n # is not stable due to use of dicts when parsing clusters -- therefore\r\n # just checks that we have the expected group of each\r\n self.assertEqual(obs_otu_ids, exp_otu_ids)\r\n self.assertEqual(obs_clusters, exp_clusters)","def test_call_alt_threshold(self):\r\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\r\n\r\n exp_otu_ids = range(9)\r\n exp_clusters = [['uclust_test_seqs_0'],\r\n ['uclust_test_seqs_1'],\r\n ['uclust_test_seqs_2'],\r\n ['uclust_test_seqs_3'],\r\n ['uclust_test_seqs_4'],\r\n ['uclust_test_seqs_5'],\r\n ['uclust_test_seqs_6', 'uclust_test_seqs_8'],\r\n ['uclust_test_seqs_7'],\r\n ['uclust_test_seqs_9']]\r\n\r\n app = UclustOtuPicker(params={'Similarity': 0.90,\r\n 'suppress_sort': False,\r\n 'presort_by_abundance': False,\r\n 'save_uc_files': False})\r\n obs = app(self.tmp_seq_filepath1)\r\n obs_otu_ids = sorted(obs.keys())\r\n obs_clusters = sorted(obs.values())\r\n # The relation between otu ids and clusters is abitrary, and\r\n # is not stable due to use of dicts when parsing clusters -- therefore\r\n # just checks that we have the expected group of each\r\n self.assertEqual(obs_otu_ids, exp_otu_ids)\r\n self.assertEqual(obs_clusters, exp_clusters)","def test_spanner_indexer_individual_insert(testing_indexer):\n codec = IdCodec()\n indexed_string = get_random_string(10)\n\n model1_id = get_id()\n expected_key_result = KeyResults()\n expected_key_result.add_key_result(KeyResult(org_id=55555, string=indexed_string, id=model1_id))\n key_results1 = KeyResults()\n model1 = SpannerIndexerModel(\n id=codec.encode(model1_id),\n decoded_id=model1_id,\n string=indexed_string,\n organization_id=55555,\n date_added=datetime.now(),\n last_seen=datetime.now(),\n retention_days=55,\n )\n testing_indexer._insert_collisions_handled(UseCaseKey.PERFORMANCE, [model1], key_results1)\n assert (\n key_results1.get_mapped_key_strings_to_ints()\n == expected_key_result.get_mapped_key_strings_to_ints()\n )\n\n # Insert the same record with a different id but the key result would\n # have the id of model1.\n key_results2 = KeyResults()\n model2_id = get_id()\n model2 = SpannerIndexerModel(\n id=codec.encode(model2_id),\n decoded_id=model2_id,\n string=indexed_string,\n organization_id=55555,\n date_added=datetime.now(),\n last_seen=datetime.now(),\n retention_days=55,\n )\n testing_indexer._insert_collisions_handled(UseCaseKey.PERFORMANCE, [model2], key_results2)\n assert (\n key_results2.get_mapped_key_strings_to_ints()\n == expected_key_result.get_mapped_key_strings_to_ints()\n )","def kmeans_clustering(all_features, vocab_size, epsilon, max_iter):\n\n # Your code here. You should also change the return value.\n\n def _initiate_random_centroids(all_features, vocab_size):\n \"\"\"\n Initiate random centroids in the range of input\n\n :param all_features:\n :param vocab_size:\n :return:\n \"\"\"\n centroids = []\n # 1) Genereate points for initial centroids\n\n min_feat = np.ones(all_features[0].size)*np.inf\n max_feat = np.zeros(all_features[0].size)\n\n for a in all_features:\n for p in range(len(a)):\n if a[p] < min_feat[p]:\n min_feat[p] = a[p]\n else:\n if a[p] > max_feat[p]:\n max_feat[p] = a[p]\n\n\n for _ in range(vocab_size):\n random_vector = np.multiply(np.random.rand(1, all_features[0].size),\n max_feat-min_feat) + min_feat\n centroids.append(random_vector.flatten())\n\n return np.array(centroids)\n\n def _assign_vectors_to_nearest_centroid(all_features, centroid):\n \"\"\"\n Assign vectors to nearest centroids\n\n :param all_features:\n :param centroid:\n :return:\n \"\"\"\n #TODO: sprawdz co lepiej dziala\n new_centroid_coor = np.zeros([len(centroid), all_features[0].size])\n #new_centroid_coor = centroid\n new_centroid_counter = np.zeros(len(centroid))\n\n dist = pdist(centroid, all_features)\n #min_dist = dist.min(axis=0)\n min_dist_index = dist.argmin(axis=0)\n\n for x in range(len(min_dist_index)):\n id = min_dist_index[x]\n new_centroid_coor[id] = np.add(new_centroid_coor[id],\n all_features[x])\n new_centroid_counter[id] += 1\n\n new_centroid_coor_out = []\n for i in range(len(new_centroid_coor)):\n if new_centroid_counter[i] == 0:\n new_centroid_coor_out.append(centroid[i])\n else:\n new_centroid_coor_out.append(np.divide(new_centroid_coor[i],new_centroid_counter[i]))\n\n return np.array(new_centroid_coor_out), new_centroid_counter\n\n\n def _check_convergence_condition(old_centroids, new_centroids, epsilon):\n \"\"\"\n Check convergence confition\n\n :param old_centroids:\n :param new_centroids:\n :param epsilon: if every centroid is moved by dist < epsilon KMeans terminates\n :return:\n \"\"\"\n for i in range(len(old_centroids)):\n dist = euclidean(old_centroids[i], new_centroids[i])\n if dist > epsilon:\n return False\n\n return True\n\n def delete_small_clusters(new_centroids, centroid_counter, threshold):\n \"\"\"\n Potential extension of the algorithm -> if there is not any point in the cluster, delete this cluste\n\n :param new_centroids:\n :param centroid_counter:\n :param threshold:\n :return:\n \"\"\"\n\n out_centroids = []\n for n in range(len(new_centroids)):\n if centroid_counter[n] > threshold:\n out_centroids.append(new_centroids[n])\n out_centroids = np.array(out_centroids)\n return out_centroids\n\n #MAIN\n old_centroids = _initiate_random_centroids(all_features, vocab_size)\n\n for _ in range(max_iter):\n new_centroids, centroid_counter = _assign_vectors_to_nearest_centroid(all_features, old_centroids)\n if_convergenced = _check_convergence_condition(new_centroids, old_centroids, epsilon)\n\n if if_convergenced == True:\n # return centroids if algorithm is converged\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\n return new_centroids\n old_centroids = new_centroids\n\n # return centroids if reached max_iter\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\n return new_centroids","def test_jaccard_index_compiled():\n vector1 = np.array([1, 1, 0, 0])\n vector2 = np.array([1, 1, 1, 1])\n score11 = jaccard_index(vector1, vector1)\n score12 = jaccard_index(vector1, vector2)\n score22 = jaccard_index(vector2, vector2)\n\n assert score12 == 2 / 4, \"Expected different score.\"\n assert score11 == score22 == 1.0, \"Expected different score.\"","def testContains(self):\n\n N = randint(20,100)\n for i in xrange(N):\n self.s.insert(i,True)\n N-=(i in self.s)\n\n self.assertEqual(N,0)","def SSC_test():\n \n # generating data\n\n D = 40 # Dimension of ambient space\n k = 4 # Number of subspaces\n d = 1\n N = 90 # Number of points in subspaces\n # Generating N points in d dim. subspaces\n Xi = [np.random.randn(D, d).dot(np.random.randn(d, N))\n for _ in range(k)]\n X = np.concatenate(Xi, axis=1)\n\n # Generating the ground-truth for evaluating clustering results\n lbls = [i * np.ones([1, N]) for i in range(k)]\n s = np.concatenate(lbls, axis=1)\n r = 0 # Enter the projection dimension e.g. r = d*n, enter r = 0 to not project\n Cst = 0 # Enter 1 to use the additional affine constraint sum(c) == 1\n OptM = 'L1Noise' # OptM can be {'L1Perfect','L1Noise','Lasso','L1ED'}\n lmbda = 0.001 # Regularization parameter in 'Lasso' or the noise level for 'L1Noise'\n # Number of top coefficients to build the similarity graph, enter K=0 for using the whole coefficients\n K = 0 #max(d1, d2)\n if Cst == 1:\n K = d + 1 # For affine subspaces, the number of coefficients to pick is dimension + 1\n\n Xp = DataProjection(X, r, 'NormalProj')\n \n # testing clustering\n \n '''\n # using wrapper function\n Grps, sc = sparseSubspaceClustering(\n Xp.T, n, ground_truth=s, affine=Cst, OptM=OptM, lam=lmbda)\n Grps = BestMap(sc, Grps)\n Missrate = float(np.sum(sc != Grps)) / sc.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))\n '''\n \n '''\n # calling internal tools\n CMat = SparseCoefRecovery(Xp, Cst, OptM, lmbda)\n # Make small values 0\n eps = np.finfo(float).eps\n CMat[np.abs(CMat) < eps] = 0\n\n CMatC, sc, OutlierIndx, Fail = OutlierDetection(CMat, s)\n\n if Fail == False:\n CKSym = BuildAdjacency(CMatC, K)\n Grps = SpectralClustering(CKSym, n)\n Grps = BestMap(sc, Grps)\n Missrate = float(np.sum(sc != Grps)) / sc.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))\n else:\n print(\"Something failed\")\n '''\n \n labels, _, __ = KSubspaces(Xp.T, k, d)\n labels = BestMap(s, labels)\n Missrate = float(np.sum(s != labels)) / s.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))","def _assert_ks_postformat(self):\n if type(self.idxs) in [list, np.ndarray]:\n if self.ks is None:\n if self.staticneighs:\n pass\n else:\n self.ks = range(len(self.idxs))\n if self.staticneighs:\n pass\n else:\n# print self.ks, self.idxs, self.set_neighs, self.set_sp_rel_pos\n assert(len(self.ks) == len(self.idxs))\n ## Defining functions\n if self.sp_relative_pos is not None and self.staticneighs:\n self.get_sp_rel_pos = self._static_get_rel_pos\n elif not self.staticneighs:\n if type(self.sp_relative_pos) == list:\n self.get_sp_rel_pos = self._dynamic_rel_pos_list\n else:\n self.get_sp_rel_pos = self._dynamic_rel_pos_array\n if self.sp_relative_pos is None:\n self.set_sp_rel_pos = self._null_set_rel_pos\n self.get_sp_rel_pos = self._null_get_rel_pos\n ## Ensure correct k_ret\n if np.max(self.ks) > self._kret:\n self._kret = np.max(self.ks)","def test_st_facets00401m9_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m9.xsd\",\n instance=\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m9_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def test_main_on_cluster(self):\n\n command = \" \".join( [\"%s/denoiser.py\" % get_qiime_scripts_dir(),\n \"--force\",\"-o\", self.test_dir, \"-c\", \"-n\", \"2\",\n \"-i\", \"%s/qiime/support_files/denoiser/TestData/denoiser_test_set.sff.txt\" % PROJECT_HOME, \n \"-f\", \"%s/qiime/support_files/denoiser/TestData/test_set_seqs.fna\" % PROJECT_HOME] )\n\n result = Popen(command,shell=True,universal_newlines=True,\\\n stdout=PIPE,stderr=STDOUT).stdout.read()\n self.result_dir = self.test_dir\n\n observed = \"\".join(list(open(self.result_dir+ \"centroids.fasta\")))\n self.assertEqual(observed, self.expected)","def trainSOM_getK(model):\n model.detect_serialized_datasets()\n model.detect_prepared_datasets()\n model.train_SOM()\n model.detect_som_products()\n model.generate_k()\n cluster_num = model.get_k()\n return cluster_num","def threshold_trec_run(run, fold, k):\n filtered_run = defaultdict(dict)\n # This is possible because best_search_run is an OrderedDict\n for qid, docs in run.items():\n if qid in fold[\"predict\"][\"test\"]:\n for idx, (docid, score) in enumerate(docs.items()):\n if idx >= k:\n break\n filtered_run[qid][docid] = score\n\n return filtered_run","def main():\n if len(sys.argv) != 5:\n exit(\"Usage: python oneta.py train-corpus test-corpus kernel-size output\")\n\n w1Words = dict()\n w2Words = dict()\n W1 = 0\n W2 = 0\n\n D1 = int(sys.argv[3])\n\n sys.stderr.write(\"First scan of training data\\n\")\n \n J = 0\n # Read through the corpus to decided which words are in the dense set and which in the sparse set\n corpus = open(sys.argv[1],\"r\")\n for line in corpus:\n tokens = word_tokenize(line)\n for token in tokens:\n tk_decoded = token.decode(\"utf-8\")\n if J < D1 and tk_decoded not in w1Words:\n w1Words[tk_decoded] = W1\n W1 += 1\n elif J >= D1 and tk_decoded not in w2Words:\n w2Words[tk_decoded] = W2\n W2 += 1\n J += 1\n corpus.close()\n\n D2 = J - D1\n\n # Partition the corpus into a L-shaped matrix\n sys.stderr.write(\"Building matrices\")\n At = lil_matrix((D1,W1))\n B = lil_matrix((W1,D2))\n Ct = lil_matrix((D2,W2))\n\n corpus = open(sys.argv[1],\"r\")\n\n j = 0\n for line in corpus:\n sys.stderr.write(\".\")\n tokens = word_tokenize(line)\n docsq = 0.\n for token in tokens:\n tk_decoded = token.decode(\"utf-8\")\n if j < D1: # tk_decoded in w1words\n tkId = w1Words[tk_decoded]\n docsq += (At[j,tkId]+1)**2 - (At[j,tkId])**2\n At[j,tkId] += 1.\n elif tk_decoded in w1Words:\n tkId = w1Words[tk_decoded]\n docsq += (B[tkId,j-D1]+1)**2 - (B[tkId,j-D1])**2\n B[tkId,j-D1] += 1.\n else:\n tkId = w2Words[tk_decoded]\n docsq += (Ct[j-D1,tkId]+1)**2 - (Ct[j-D1,tkId])**2\n Ct[j-D1,tkId] += 1.\n if j < D1:\n At[j,:] /= math.sqrt(docsq)\n else:\n for w in range(0,W1):\n B[w,j-D1] /= math.sqrt(docsq)\n Ct[j-D1,:] /= math.sqrt(docsq)\n j += 1\n\n sys.stderr.write(\"\\nBuild Cn\\n\")\n Cn = zeros((D2,1))\n Ct = Ct.tocsr()\n for i in range(0,D2):\n v = ((Ct[i,:] * Ct[i,:].transpose())[0,0])\n if v == 0:\n Cn[i,0] = 1.\n else:\n Cn[i,0] = v\n\n # Building real matrices\n sys.stderr.write(\"Calculating ATA\\n\")\n ATA = (At * At.transpose()).todense() # D1 x D1\n At = At.tocsr()\n B = B.tocsc()\n\n sys.stderr.write(\"Solve inverse\\n\")\n ATAi = linalg.inv(ATA)\n\n # The real calculation is that if we have input vector [ d_1 d_2 ] ^ T \n # We yield [ (A^T * A)^-1 * A^T ( d1^T - B * (C^T * d2 / Cn) ) (C^T * d2 / Cn)\n sys.stderr.write(\"Calculating projected vectors\\n\")\n\n out = open(sys.argv[4],\"w\")\n testDocs = open(sys.argv[2],\"r\")\n for testDoc in testDocs:\n sys.stderr.write(\".\")\n corpus = open(sys.argv[1],\"r\")\n d1 = zeros((W1,1))\n d2 = zeros((W2,1))\n tokens = word_tokenize(testDoc)\n for token in tokens:\n tk_decoded = token.decode(\"utf-8\")\n if tk_decoded in w1Words:\n d1[w1Words[tk_decoded],0] += 1\n elif tk_decoded in w2Words:\n d2[w2Words[tk_decoded],0] += 1\n norm = sqrt(sum(d1**2) + sum(d2**2))\n d1 /= norm \n d2 /= norm\n v2 = (Ct * d2) / Cn\n v1 = ATAi * (At * (d1 - B * v2))\n for j in range(0,D1+D2):\n out.write(str(j) + \" \")\n out.write(\"||| \")\n for j in range(0,D1):\n out.write(str(v1[j,0]) + \" \")\n for j in range(0,D2):\n out.write(str(v2[j,0]) + \" \")\n out.write(\"\\n\")\n\n out.flush()\n out.close()\n sys.stderr.write(\"\\n\")","def test_st_facets00501m11_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/SType/ST_facets/ST_facets00501m/ST_facets00501m11.xsd\",\n instance=\"sunData/SType/ST_facets/ST_facets00501m/ST_facets00501m11_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def test_st_facets00401m10_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m10.xsd\",\n instance=\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m10_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def main():\n data = Dummy(n_samples=500, n_dim=3)\n X = data.get_dummy()\n clustering = Kmeans(X, K=5, display=False)\n clustering.run()\n print(f\"Number of iterations: {clustering.num_iterations}\\n\")\n\n \"\"\" Test example of clustering_kmeans with unknown number of clusters K \"\"\"\n clustering = Kmeans(X,)\n clustering.silhouette_find_k()\n print(f\"Number of centroids found: {clustering.num_K}\")","def kmeans_fast(features, k, num_iters=100):\n N = len(features)\n print(N)\n # Randomly initalize cluster centers\n centers, assignments = np.array([features[i] for i in sorted(random.sample(range(0, len(features)), K))]), {}\n _, dim = centers.shape\n\n tile_f = np.tile(features, (k, 1))\n for n in range(num_iters):\n tile_c = np.repeat(centers, N, axis=0)\n tile_sub = np.subtract(tile_f, tile_c)\n dist = np.linalg.norm(tile_sub, axis=1).reshape(k, N)\n assignments_new = np.argmin(dist, axis=0)\n if np.array_equal(assignments, assignments_new):\n break\n else:\n assignments = assignments_new\n\n old_centers, new_stats = centers[:], []\n for j in range(0, k):\n new_stats.append([0, []])\n for i in range(len(features)):\n c_ind = int(assignments[i])\n num, sum_vec = new_stats[c_ind]\n sum_vec_new = np.add(sum_vec, features[i]) if len(sum_vec) > 0 else features[i]\n new_stats[c_ind] = [num + 1, sum_vec_new]\n\n new_centers = np.zeros((k, dim))\n for j in range(0, k):\n num, new_center = new_stats[j]\n new_center = np.divide(new_center, num)\n new_centers[j] = np.array(new_center)\n centers = new_centers\n\n return centers, assignments, 0","def test_indices_distance(self):\n maze = Maze(10, 10)\n\n for test in range(1000):\n self.assertTrue(\n (abs(maze.entrance[0] - maze.exit[0]) +\n abs(maze.entrance[1] - maze.exit[1])) >= 9)","def skip_test(n):\n return k > 0 and magic * n * k**0.5 >= t4_ref","def knn(k, Xtrain, Ytrain, Xtest):\n d = euclidean_distances(Xtest, Xtrain, squared=True)\n nnc = Ytrain[np.argsort(d)[..., :k].flatten()].reshape(Xtest.shape[0], k)\n pred = [max(nnc[i], key=Counter(nnc[i]).get) for i in range(nnc.shape[0])]\n return np.array(pred)","def test_st_facets00401m21_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m21.xsd\",\n instance=\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m21_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def test_call_low_cluster_identity(self):\r\n\r\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\r\n # Should only get 6 clusters\r\n exp_otu_ids = [str(x) for x in range(10)]\r\n\r\n exp_clusters = [['uclust_test_seqs_0'],\r\n ['uclust_test_seqs_1'],\r\n ['uclust_test_seqs_2'],\r\n ['uclust_test_seqs_3'],\r\n ['uclust_test_seqs_4'],\r\n ['uclust_test_seqs_5'],\r\n ['uclust_test_seqs_6'],\r\n ['uclust_test_seqs_7'],\r\n ['uclust_test_seqs_8'],\r\n ['uclust_test_seqs_9']]\r\n\r\n app = UsearchReferenceOtuPicker(\r\n params={'save_intermediate_files': False,\r\n 'db_filepath':\r\n self.tmp_ref_database,\r\n 'output_dir': self.temp_dir,\r\n 'remove_usearch_logs': True,\r\n 'reference_chimera_detection':\r\n False,\r\n 'de_novo_chimera_detection':\r\n False,\r\n 'cluster_size_filtering':\r\n False,\r\n 'minlen': 12,\r\n 'w': 12,\r\n 'minsize': 1,\r\n 'percent_id': 0.80,\r\n 'percent_id_err': 0.97\r\n })\r\n\r\n obs = app(self.tmp_seq_filepath1, self.tmp_otu_ref_database)\r\n\r\n obs_otu_ids = sorted(obs.keys())\r\n obs_clusters = sorted(obs.values())\r\n # The relation between otu ids and clusters is abitrary, and\r\n # is not stable due to use of dicts when parsing clusters -- therefore\r\n # just checks that we have the expected group of each\r\n self.assertEqual(obs_otu_ids, exp_otu_ids)\r\n self.assertEqual(obs_clusters, exp_clusters)","def test_generated_sample_distribution(\n jax_dist, sp_dist, params, N_sample=100_000, key=random.PRNGKey(11)\n):\n\n if jax_dist not in [dist.Gumbel]:\n pytest.skip(\n \"{} sampling method taken from upstream, no need to\"\n \"test generated samples.\".format(jax_dist.__name__)\n )\n\n jax_dist = jax_dist(*params)\n if sp_dist and not jax_dist.event_shape and not jax_dist.batch_shape:\n our_samples = jax_dist.sample(key, (N_sample,))\n ks_result = osp.kstest(our_samples, sp_dist(*params).cdf)\n assert ks_result.pvalue > 0.05","def analyze_sensitivity_sparse_grid(sparse_grid,max_order=2):\n from pyapprox.multivariate_polynomials import \\\n define_poly_options_from_variable_transformation\n from pyapprox.adaptive_sparse_grid import \\\n convert_sparse_grid_to_polynomial_chaos_expansion\n pce_opts=define_poly_options_from_variable_transformation(\n sparse_grid.variable_transformation)\n pce = convert_sparse_grid_to_polynomial_chaos_expansion(\n sparse_grid,pce_opts)\n pce_main_effects,pce_total_effects=\\\n get_main_and_total_effect_indices_from_pce(\n pce.get_coefficients(),pce.get_indices())\n\n interaction_terms, pce_sobol_indices = get_sobol_indices(\n pce.get_coefficients(),pce.get_indices(),max_order=max_order)\n \n return SensivitityResult(\n {'main_effects':pce_main_effects,\n 'total_effects':pce_total_effects,\n 'sobol_indices':pce_sobol_indices,\n 'sobol_interaction_indices':interaction_terms,\n 'pce':pce})","def test_st_facets00201m11_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/SType/ST_facets/ST_facets00201m/ST_facets00201m11.xsd\",\n instance=\"sunData/SType/ST_facets/ST_facets00201m/ST_facets00201m11_p.xml\",\n class_name=\"Test\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def test_index_12(self):\n self.insert()\n data = self.tbl[2:6]\n assert self.check(self.idata[:2], data)","def test_st_facets00401m20_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m20.xsd\",\n instance=\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m20_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def __init__(self, mode=KSamplingModes.monkhorst, num_kpts= 0,\n kpts=((1, 1, 1),),\n kpt_shifts=(0.5, 0.5, 0.5),\n kpts_weights=None, use_symmetries=True, use_time_reversal=True, chksymbreak=None,\n comment=None):\n if isinstance(mode, str):\n mode = KSamplingModes[mode]\n\n super(KSampling, self).__init__()\n\n self.mode = mode\n self.comment = comment\n\n self.num_kpts = num_kpts\n self.kpts = kpts\n self.kpt_shifts = kpt_shifts\n self.kpts_weights = kpts_weights\n self.use_symmetries = use_symmetries\n self.use_time_reversal = use_time_reversal\n self.chksymbreak = chksymbreak\n\n abivars = {}\n\n if mode == KSamplingModes.monkhorst:\n assert num_kpts == 0\n ngkpt = np.reshape(kpts, 3)\n shiftk = np.reshape(kpt_shifts, (-1,3))\n\n if use_symmetries and use_time_reversal: kptopt = 1\n if not use_symmetries and use_time_reversal: kptopt = 2\n if not use_symmetries and not use_time_reversal: kptopt = 3\n if use_symmetries and not use_time_reversal: kptopt = 4\n\n abivars.update({\n \"ngkpt\" : ngkpt,\n \"shiftk\" : shiftk,\n \"nshiftk\" : len(shiftk),\n \"kptopt\" : kptopt,\n \"chksymbreak\": chksymbreak,\n })\n\n elif mode == KSamplingModes.path:\n if num_kpts <= 0:\n raise ValueError(\"For Path mode, num_kpts must be specified and >0\")\n\n kptbounds = np.reshape(kpts, (-1,3))\n #print(\"in path with kptbound: %s \" % kptbounds)\n\n abivars.update({\n \"ndivsm\" : num_kpts,\n \"kptbounds\": kptbounds,\n \"kptopt\" : -len(kptbounds)+1,\n })\n\n elif mode == KSamplingModes.automatic:\n kpts = np.reshape(kpts, (-1,3))\n if len(kpts) != num_kpts:\n raise ValueError(\"For Automatic mode, num_kpts must be specified.\")\n\n abivars.update({\n \"kptopt\" : 0,\n \"kpt\" : kpts,\n \"nkpt\" : num_kpts,\n \"kptnrm\" : np.ones(num_kpts),\n \"wtk\" : kpts_weights, # for iscf/=-2, wtk.\n \"chksymbreak\": chksymbreak,\n })\n\n else:\n raise ValueError(\"Unknown mode %s\" % mode)\n\n self.abivars = abivars\n #self.abivars[\"#comment\"] = comment","def test_calc_mode():\r\n lamb = 1.8e-6\r\n radius = 50e-6\r\n num_points = 50\r\n x = np.linspace(-1, 1, num_points) * radius\r\n y = np.linspace(-1, 1, num_points)[:, None] * radius\r\n r = (x ** 2 + y ** 2) ** 0.5\r\n theta = np.arctan2(x, y)\r\n dA = (x[1] - x[0]) * (y[1, 0] - y[0, 0])\r\n ##\r\n M = 5\r\n N = 3\r\n fields = []\r\n for m in np.arange(1, M + 1):\r\n for n in np.arange(-N, N + 1):\r\n for theta0 in (0, np.pi / 2):\r\n fields.append(hc.calc_mode(1.5, radius, n, m, lamb, r, theta, dA, theta0))\r\n rows = []\r\n for f1 in fields:\r\n row = []\r\n for f2 in fields:\r\n row.append(hc.calc_mode_overlap(f1, f2, dA))\r\n rows.append(row)\r\n overlap = np.array(rows)","def test_st_facets00501m6_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/SType/ST_facets/ST_facets00501m/ST_facets00501m6.xsd\",\n instance=\"sunData/SType/ST_facets/ST_facets00501m/ST_facets00501m6_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def testVerySmallClusters(input_img, input_mode, min_rad=7.5):\n\n if input_mode == 'fp':\n np_img = loadImage(input_img)\n elif input_mode == 'np':\n np_img = input_img\n else:\n return (input_mode, \" is not a supported mode. Supported modes are 'np' or 'fp'.\")\n dim = np_img.shape\n if dim[0] <= dim[1]:\n length = dim[0]\n else:\n length = dim[1]\n if length/2. < min_rad:\n return True\n else:\n return False","def test_st_facets00505m6_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/SType/ST_facets/ST_facets00505m/ST_facets00505m6.xsd\",\n instance=\"sunData/SType/ST_facets/ST_facets00505m/ST_facets00505m6_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def test_st_facets00124m1_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/SType/ST_facets/ST_facets00124m/ST_facets00124m1.xsd\",\n instance=\"sunData/SType/ST_facets/ST_facets00124m/ST_facets00124m1_p.xml\",\n class_name=\"Test\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def knn(p, k, x, t):\r\n\r\n # Number of instances in data set\r\n N = x.shape[0]\r\n\r\n Euclidean_Distance = numpy.square(x - p) #Euclidean distance\r\n dis = numpy.sum(Euclidean_Distance, axis=1) #sum of the euclidean distance\r\n inds = numpy.argsort(dis)[:k] #sort the indices of the distance array\r\n tgt_cat = Counter([t[i] for i in inds]) #count the times of equivalent target labels\r\n top_class = max(tgt_cat, key= tgt_cat.get) #top class among the k nearest points\r\n\r\n\r\n #top_class = 0\r\n\r\n return top_class","def pkscore(labels, preds, k=10):\n # Remove padding from labels and preds\n mask = np.where(labels<=1, True, False)\n labels = labels[mask]\n preds = preds[mask]\n\n num_windows = len(labels) - k + 1\n assert num_windows>0, 'Choose a smaller k value'\n\n correct = 0\n for i in range(num_windows):\n # calculate index of window close\n j = i + k\n\n # Get number of segment splits in labels and preds\n label_diff = sum(labels[i:j])\n pred_diff = sum(preds[i:j])\n\n # Check for agreement between labels and preds\n if (label_diff and pred_diff) or (not label_diff and not pred_diff):\n correct += 1\n return 1-(correct/(num_windows))","def test_fast_denoiser(self):\r\n\r\n actual_centroids, actual_otu_map = fast_denoiser(\r\n [self.sff_path2], self.seq_path, self.tmp_out_dir,\r\n num_cpus=1, primer=\"YATGCTGCCTCCCGTAGGAGT\", verbose=False)\r\n\r\n actual = list(actual_centroids)\r\n self.assertEqual(actual, expected_centroids)\r\n # centroids are sorted, so first one should be unique\r\n #(all others have cluster size 1, so relative ordering is not guaranteed\r\n self.assertEqual(actual[0], expected_centroids[0])\r\n self.assertEqual(actual_otu_map, expected_otu_map)","def test_jaccard_index():\n vector1 = np.array([1, 1, 0, 0])\n vector2 = np.array([1, 1, 1, 1])\n score11 = jaccard_index.py_func(vector1, vector1)\n score12 = jaccard_index.py_func(vector1, vector2)\n score22 = jaccard_index.py_func(vector2, vector2)\n\n assert score12 == 2 / 4, \"Expected different score.\"\n assert score11 == score22 == 1.0, \"Expected different score.\"","def test_getitem_array(self):\n random.seed(12345)\n\n nside_coverage = 32\n nside_map = 128\n\n full_map = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\n full_map[0: 5000] = random.random(size=5000)\n\n sparse_map = healsparse.HealSparseMap(healpix_map=full_map, nside_coverage=nside_coverage)\n\n indices = np.array([1, 2, 100, 500, 10000])\n testing.assert_array_almost_equal(sparse_map[indices], full_map[indices])\n testing.assert_almost_equal(sparse_map[indices[0]], full_map[indices[0]])\n\n indices = np.array([1., 2, 100, 500, 10000])\n self.assertRaises(IndexError, sparse_map.__getitem__, indices)\n self.assertRaises(IndexError, sparse_map.__getitem__, indices[0])","def build_k_indices(y, k_fold, seed):\n num_rows = y.shape[0]\n interval = int(num_rows / k_fold)\n np.random.seed(seed)\n indices = np.random.permutation(num_rows)\n k_indices = [indices[k * interval: (k + 1) * interval] for k in range(k_fold)]\n return np.array(k_indices)","def test_st_facets00501m10_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/SType/ST_facets/ST_facets00501m/ST_facets00501m10.xsd\",\n instance=\"sunData/SType/ST_facets/ST_facets00501m/ST_facets00501m10_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def testSubset(df, fullIndex, indexCol, members, gbCol='Stimulus', gbValues=None, countCol='Cells', min_count=7, nsamps=None, rseed=110820):\n\n if gbValues is None:\n gbValues = sorted(df[gbCol].unique())\n cnts = df.groupby([indexCol, gbCol])[countCol].agg(np.sum).unstack(gbCol, fill_value=0)[gbValues]\n cnts = cnts.reindex(fullIndex, axis=0, fill_value=0)\n resDf = testHClusters(cnts, members, gbValues, min_count=min_count)\n \n if not nsamps is None:\n \"\"\"Preliminarily, permutation-based p-values have correlated perfectly\n with the analytic p-values\"\"\"\n np.random.seed(rseed)\n rtmp = df.copy()\n rchi2 = np.zeros((resDf.shape[0], nsamps))\n rpvalue = np.zeros((resDf.shape[0], nsamps))\n for sampi in range(nsamps):\n rtmp.loc[:, gbCol] = rtmp[gbCol].values[np.random.permutation(rtmp.shape[0])]\n rcnts = rtmp.groupby([indexCol, gbCol])['Cells'].agg(np.sum).unstack(gbCol, fill_value=0)\n rcnts = rcnts.reindex(fullIndex, axis=0, fill_value=0)\n rres = testHClusters(rcnts, members, gbValues, min_count=min_count)\n rchi2[:, sampi] = rres['chi2']\n rpvalue[:, sampi] = rres['pvalue']\n ppvalue = ((rpvalue <= resDf['pvalue'].values[:, None]).sum(axis=1) + 1) / (nsamps + 1)\n pchi2 = ((rchi2 <= resDf['chi2'].values[:, None]).sum(axis=1) + 1) / (nsamps + 1)\n ppvalue[np.isnan(resDf['chi2'].values)] = np.nan\n pchi2[np.isnan(resDf['chi2'].values)] = np.nan\n resDf = resDf.assign(**{'Perm P-pvalue':ppvalue, 'Perm Chi2-pvalue':pchi2})\n\n return resDf","def test_st_facets00401m12_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m12.xsd\",\n instance=\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m12_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )"],"string":"[\n \"def test_ks_test_undefined_mode():\\n indices = np.random.randint(0, 1000, 1000)\\n with pytest.raises(RuntimeError):\\n compute_indices_ks_test(indices, 1000, mode=\\\"two-sided\\\")\",\n \"def test_ks_test_empty_indices():\\n out = compute_indices_ks_test([], 1000, mode=\\\"D+\\\")\\n assert all(o is None for o in out)\",\n \"def test_k_rank_approximate(corpus):\\n return\",\n \"def test_single_run(self):\\n\\n traces = np.load('data/traces.npy')\\n keys = np.load('data/key.npy')\\n plain = np.load('data/plain.npy')\\n correct_indices = [4254, 4257, 1400, 4429, 4919, 1399, 4918, 1398, 4917, 1397]\\n\\n indices = SOSTD.list_of_best_indices(traces, keys, plain, 10, 0)\\n self.assertTrue(np.array_equal(indices, correct_indices))\",\n \"def test_estimate_mode() -> None:\\n # Create a set of random parameters\\n parameters = np.sort(1 + 5 * np.random.rand(3))\\n parameters[[2, 1]] = parameters[[1, 2]]\\n\\n # Create an instance\\n my_univariate_input = UnivDist(\\n distribution=DISTRIBUTION_NAME, parameters=parameters\\n )\\n\\n # Generate a sample\\n sample_size = 1000000 # Should give 1e-0 accuracy\\n xx = my_univariate_input.get_sample(sample_size)\\n\\n # Estimated result\\n y, edges = np.histogram(xx, bins=\\\"auto\\\")\\n mode = edges[np.argmax(y)]\\n\\n # Analytical result\\n mode_ref = parameters[2]\\n\\n # Assertion\\n assert np.isclose(mode, mode_ref, rtol=1, atol=1)\",\n \"def KS(dataDict=None, dataLabel='data', mode='two.sided'):\\n\\n # test calling values\\n modes = ['two.sided', 'less', 'greater']\\n if mode not in modes:\\n raise ValueError('RSTATS.KS: mode must be in: ', modes)\\n if (dataDict is None or not isinstance(dataDict, dict) \\n or len(dataDict.keys()) != 2):\\n raise ValueError('RSTATS.KS: dataDict must be a dictionary with '\\n + 'exactly 2 keys')\\n\\n labels = list(dataDict.keys())\\n# NGroups = len(labels)\\n cmdx = 'X=c(%s)' % ', '.join(str(x) for x in dataDict[labels[0]])\\n cmdy = 'Y=c(%s)' % ', '.join(str(y) for y in dataDict[labels[1]])\\n# package \\\"perm\\\" not available on mac os x, use coin instead\\n# importr('perm')\\n robjects.r(cmdx)\\n robjects.r(cmdy)\\n\\n# (pvalue, nmc) = permutation(dataDict, dataDict.keys())\\n\\n u = robjects.r(\\\"ks.test(X, Y, alternative='%s')\\\" % mode)\\n\\n pvalue = float(u[1][0])\\n statvalue = float(u[0][0]) # get diff estimate\\n if dataLabel is not None:\\n print ('\\\\nKolmogorov-Smirnov test. Dataset = %s' % (dataLabel))\\n print(u' Test statistic: {:8.4f}'.format(statvalue))\\n print(u' p={:8.6f}, [mode={:s}]'.format(float(pvalue), mode))\\n return pvalue\",\n \"def test_determine_k(self):\\n test_dir_name = os.path.dirname(__file__)\\n feat_array_fn = os.path.join(\\n test_dir_name, \\\"data\\\", \\\"four_clusters.csv\\\")\\n df = pd.read_csv(feat_array_fn)\\n feat_array = df[[\\\"x\\\", \\\"y\\\"]].values\\n\\n clusterer = Clusterer(feat_array_fn, \\\"/dev/null\\\", [])\\n best_k = clusterer._determine_k(feat_array, 9)\\n\\n self.assertEqual(best_k, 4)\\n\\n feat_array_fn = os.path.join(\\n test_dir_name, \\\"data\\\", \\\"iris.csv\\\")\\n df = pd.read_csv(feat_array_fn)\\n feat_array = df[[\\n \\\"Sepal.Length\\\", \\\"Sepal.Width\\\", \\\"Petal.Length\\\",\\n \\\"Petal.Width\\\"]].values\\n\\n clusterer = Clusterer(feat_array_fn, \\\"/dev/null\\\", [])\\n best_k = clusterer._determine_k(feat_array, 9)\\n\\n self.assertEqual(best_k, 2)\",\n \"def test_single_run_sosd(self):\\n\\n traces = np.load('data/traces.npy')[:1000]\\n keys = np.load('data/key.npy')[:1000]\\n plain = np.load('data/plain.npy')[:1000]\\n correct_indices = [4371, 2401, 2402, 4878, 4370, 4877, 4882, 4369, 4881, 2723]\\n\\n indices = SOSTD.list_of_best_indices(traces, keys, plain, 10, 0, False)\\n self.assertTrue(np.array_equal(indices, correct_indices))\",\n \"def test_k_index():\\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\\n 400.]) * units.hPa\\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\\n -23.5]) * units.degC\\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\\n -57.5]) * units.degC\\n ki = k_index(pressure, temperature, dewpoint)\\n assert_almost_equal(ki, 33.5 * units.degC, 2)\",\n \"def test_k_index_xarray(index_xarray_data):\\n result = k_index(index_xarray_data.isobaric, index_xarray_data.temperature,\\n index_xarray_data.dewpoint)\\n assert_array_almost_equal(result,\\n np.array([[[312., 311., 310.], [309., 308., 307.]]]) * units.K)\",\n \"def add_mode_index(self) -> None:\",\n \"def test_call_alt_threshold(self):\\r\\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\\r\\n\\r\\n exp = {0: ['cdhit_test_seqs_0'],\\r\\n 1: ['cdhit_test_seqs_1'],\\r\\n 2: ['cdhit_test_seqs_2'],\\r\\n 3: ['cdhit_test_seqs_3'],\\r\\n 4: ['cdhit_test_seqs_4'],\\r\\n 5: ['cdhit_test_seqs_5'],\\r\\n 6: ['cdhit_test_seqs_6', 'cdhit_test_seqs_8'],\\r\\n 7: ['cdhit_test_seqs_7'],\\r\\n 8: ['cdhit_test_seqs_9']}\\r\\n\\r\\n app = CdHitOtuPicker(params={'Similarity': 0.90})\\r\\n obs = app(self.tmp_seq_filepath1)\\r\\n self.assertEqual(obs, exp)\",\n \"def test_result(mask, seg, mode='ec'):\\n assert mask.shape == seg.shape, print('mask and seg must have the same shape.')\\n temp = np.zeros(seg.shape)\\n temp_mask = np.zeros(seg.shape)\\n if mode == 'ec':\\n temp[seg == 4] = 1\\n temp_mask[mask == 4] = 1\\n mts = Seg_metric(temp, temp_mask)\\n\\n elif mode == 'core':\\n temp[seg == 4] = 1\\n temp[seg == 1] = 1\\n temp_mask[mask == 4] = 1\\n temp_mask[mask == 1] = 1\\n mts = Seg_metric(temp, temp_mask)\\n\\n elif mode == 'full':\\n temp[seg != 0] = 1\\n temp_mask[mask != 0] = 1\\n mts = Seg_metric(temp, temp_mask)\\n return mts.dice(), mts.iou(), mts.fp(), mts.fn()\\n # print('dice:{},IoU:{}'.format(mts.dice(), mts.iou()))\",\n \"def check_k_anonymity(data: np.ndarray, k: int, qi_indices=None):\\n print(Counter(str(e) for e in data[:, qi_indices]))\\n\\n occurrences = list(Counter(str(e) for e in data[:, qi_indices]).values())\\n for j in range(len(occurrences)):\\n if occurrences[j] < k:\\n return False\\n return True\",\n \"def ks_test_function(dim, thresh):\\n def ks_test(table1, table2):\\n from scipy.stats import ks_2samp\\n sample1 = table1.get_cols(dim)[0]\\n sample2 = table2.get_cols(dim)[0]\\n if thresh != None:\\n sample1[sample1<thresh] = 0\\n sample2[sample2<thresh] = 0\\n ks, p_ks = ks_2samp(sample1, sample2)\\n return ks\\n return ks_test\",\n \"def ks_test(timeseries):\\r\\n\\r\\n hour_ago = time() - 3600\\r\\n ten_minutes_ago = time() - 600\\r\\n reference = scipy.array([x[1] for x in timeseries if x[0] >= hour_ago and x[0] < ten_minutes_ago])\\r\\n probe = scipy.array([x[1] for x in timeseries if x[0] >= ten_minutes_ago])\\r\\n\\r\\n if reference.size < 20 or probe.size < 20:\\r\\n return False\\r\\n\\r\\n ks_d,ks_p_value = scipy.stats.ks_2samp(reference, probe)\\r\\n\\r\\n if ks_p_value < 0.05 and ks_d > 0.5:\\r\\n adf = sm.tsa.stattools.adfuller(reference, 10)\\r\\n if adf[1] < 0.05:\\r\\n return True\\r\\n\\r\\n return False\",\n \"def Q8_test():\\n dispo = [False, True, True, False]\\n tab_dist = [[0, 4.123105625617661, 4.242640687119285, 4.47213595499958], [4.123105625617661, 0, 4.123105625617661, 7.810249675906654], [4.242640687119285, 4.123105625617661, 0, 5.0990195135927845], [4.47213595499958, 7.810249675906654, 5.0990195135927845, 0]]\\n return 1 == indice(0, tab_dist, dispo)\",\n \"def test_binned_output(self, sparse, adapt, pad_to_max, mode, dtype):\\n # Adapt breaks ties with sort order.\\n vocab_data = [\\\"wind\\\", \\\"fire\\\", \\\"earth\\\", \\\"and\\\"]\\n # IDF weight for a term in 1 out of 1 document is log(1 + 1/2).\\n idf_data = [math.log(1.5)] * 4\\n input_data = np.array(\\n [\\n [\\\"and\\\", \\\"earth\\\", \\\"fire\\\", \\\"and\\\", \\\"\\\"],\\n [\\\"michigan\\\", \\\"wind\\\", \\\"and\\\", \\\"ohio\\\", \\\"\\\"],\\n ]\\n )\\n\\n if mode == \\\"count\\\":\\n expected_output = np.array(\\n [\\n [0, 0, 1, 1, 2],\\n [2, 1, 0, 0, 1],\\n ]\\n )\\n elif mode == \\\"tf_idf\\\":\\n expected_output = np.array(\\n [\\n [0, 0, 1, 1, 2],\\n [2, 1, 0, 0, 1],\\n ]\\n ) * math.log(1.5)\\n else:\\n expected_output = np.array(\\n [\\n [0, 0, 1, 1, 1],\\n [1, 1, 0, 0, 1],\\n ]\\n )\\n expected_output_shape = [None, 5]\\n if pad_to_max:\\n expected_output = np.concatenate(\\n (expected_output, [[0], [0]]), axis=1\\n )\\n expected_output_shape = [None, 6]\\n\\n inputs = keras.Input(shape=(None,), dtype=tf.string)\\n layer = index_lookup.IndexLookup(\\n max_tokens=6,\\n num_oov_indices=1,\\n mask_token=\\\"\\\",\\n oov_token=\\\"[OOV]\\\",\\n output_mode=mode,\\n pad_to_max_tokens=pad_to_max,\\n vocabulary_dtype=tf.string,\\n sparse=sparse,\\n vocabulary=None if adapt else vocab_data,\\n idf_weights=None if adapt or mode != \\\"tf_idf\\\" else idf_data,\\n dtype=dtype,\\n )\\n if adapt:\\n layer.adapt(vocab_data)\\n outputs = layer(inputs)\\n model = keras.Model(inputs, outputs)\\n output_data = model.predict(input_data)\\n if sparse:\\n output_data = tf.sparse.to_dense(output_data)\\n # Check output data.\\n self.assertAllClose(expected_output, output_data)\\n # Check symbolic output shape.\\n self.assertAllEqual(expected_output_shape, outputs.shape.as_list())\\n # Check output dtype.\\n self.assertAllEqual(dtype, output_data.dtype)\",\n \"def kmeans(features, projection, ite = 20, k = 4, threshold = 1e-4):\\n from scipy.cluster.vq import kmeans, vq\\n import datetime\\n\\n from measures import spatial_coherence \\n \\n centroids, distance = kmeans(features, k, iter=ite, thresh=threshold)\\n #code, _ = vq(features, centroids)\\n \\n run_ = datetime.datetime.now().strftime(\\\"%y_%m_%d_%H_%M\\\")\\n \\n params = \\\"projection_size=%d, k=%d\\\" %(len(projection), k)\\n #clusters = clusters_from_code(code, k, projection)\\n \\n clustering_id = \\\"(%s)_(%s)_(%s)_(%s)\\\" %(\\\"exhaustive_kmeans\\\", params, run_, projection)\\n #print clustering_id\\n km_clt = KMClustering(algorithm =\\\"exhaustive_kmeans\\\", parameters = params, run = run_,\\n clustering_id = clustering_id, clusters = [], ccontains_noise = False, cclustering_on_dimension = True)\\n\\n \\n #measures = {'spatial_coherence': spatial_coherence(km_clt, len(features))[0], 'distortion': distance}\\n #km_clt.update_measures(measures)\\n \\n return km_clt\",\n \"def main_eaftest(point_ind, permutations=10240, alpha=0.05):\\n \\n # ------ Attainment indicator values information ------\\n \\n npoints = len(point_ind)\\n nvars = len(point_ind[0]) # Número de execuções total\\n nruns = nvars // 2 # Número de execuções de 1 algo\\n \\n print \\\"- Attainment indicator values information:\\\"\\n print \\\" * Number of points:\\\", npoints\\n print \\\" * Joint executions:\\\", nvars, \\\"(%d + %d)\\\" % (nruns, nruns)\\n print\\n \\n assert nvars % 2 == 0, \\\"Number of total joint executions must be even.\\\"\\n assert nvars <= 64, \\\"Not implemented with more than 64 joint executions.\\\"\\n \\n # ------ Test Statistic ------\\n\\n print \\\"- Computing the test statistic...\\\" \\n stat2 = libaft.ksstat(point_ind, order=2)\\n print \\\" * Test statistic = %d/%d\\\" % (stat2, nruns)\\n print \\\" = %f\\\" % (stat2 / float(nruns)), '\\\\n'\\n \\n # ------ Estimate null distribution ------\\n\\n print \\\"- Using %d random permutations to estimate null distribution.\\\" % permutations\\n print \\\" Please be patient...\\\"\\n maxdist = np.zeros(permutations, dtype=np.int32) # Max distance array\\n rtime = time.time()\\n \\n masks = bintools.make_masks(permutations, nvars, seed=64)\\n for i, maxd in enumerate(KERNEL.runkernel(point_ind, masks)):\\n maxdist[i] = maxd\\n if (i+1) % (permutations//20) == 0:\\n print \\\" %6d permutations, %7.3f sec\\\" % (i+1, time.time()-rtime)\\n print \\\" * Time elapsed: %7.3f\\\" % (time.time()-rtime)\\n \\n # Compute null distribution from max distance array\\n tail = np.bincount(maxdist, minlength=nruns+1)\\n print \\\" * Non-normalized null distribution:\\\"\\n print tail\\n print\\n \\n # ------ Accept/reject null hypothesis ------\\n \\n # NB: -1 resulta das diferentes convenções para a definição de valor crítico\\n crit = criticalvalue(tail, alpha * permutations) - 1\\n pval = pvalue(tail, stat2) / float(permutations)\\n \\n print \\\"- Null hypothesis decision:\\\" \\n print \\\" * Critical value = %d/%d\\\" % (crit, nruns)\\n print \\\" = %f\\\" % (crit / float(nruns))\\n print \\\" * p-value = %f\\\" % pval\\n if pval <= alpha:\\n print \\\" <= alpha (%s)\\\\n\\\" % alpha\\n print \\\" * Decision: REJECT the null hypothesis\\\"\\n else:\\n print \\\" > alpha (%s)\\\\n\\\" % alpha\\n print \\\" * Decision: do NOT REJECT the null hypothesis\\\"\\n print\",\n \"def test_jw_sparse_index(self):\\n expected = [1, 2]\\n calculated_indices = jw_number_indices(1, 2)\\n self.assertEqual(expected, calculated_indices)\\n\\n expected = [3]\\n calculated_indices = jw_number_indices(2, 2)\\n self.assertEqual(expected, calculated_indices)\",\n \"def test_k(self):\\n\\n # We have a new K. It should have nothing in it.\\n loc_, sloc_, test_loc, test_sloc = self.k__.get_totals()\\n self.assertEqual(loc_, 0)\\n self.assertEqual(sloc_, 0)\\n self.assertEqual(test_loc, 0)\\n self.assertEqual(test_sloc, 0)\\n\\n self.check_counts('zz', 0, 0, 0, 0) # not in map\\n self.check_counts('py', 0, 0, 0, 0) # not in map\\n\\n self.k__.add_counts('py', 7, 3)\\n self.check_counts('py', 7, 3, 0, 0)\\n self.k__.add_counts('py', 5, 2)\\n self.check_counts('py', 12, 5, 0, 0)\\n\\n self.k__.add_test_counts('py', 8, 4)\\n self.check_counts('py', 12, 5, 8, 4)\\n self.k__.add_test_counts('py', 9, 3)\\n self.check_counts('py', 12, 5, 17, 7)\\n\\n expected = \\\"py:%d/%d T%.1f%%\\\" % (12 + 17, 5 + 7, 700.0 / 12)\\n # DEBUG\\n # print(\\\"Expected: %s\\\" % expected)\\n # END\\n self.assertEqual(self.k__.pretty_counts('py'), expected)\",\n \"def test_key_predicate(datum):\\n return 0 < datum\",\n \"def _kmedoids_run(X, n_clusters, dist_func, max_iter=1000, verbose=True):\\n # Get initial centers\\n n_samples, n_features = len(X), 2\\n init_ids = _get_init_centers(n_clusters, X)\\n if verbose:\\n print('Initial centers are: {}'.format(init_ids))\\n centers = init_ids\\n members, costs, tot_cost, dist_mat = _get_cost(X, init_ids, dist_func)\\n cc, swapped = 0, True\\n while True:\\n swapped = False\\n for i in range(n_samples):\\n if i not in centers:\\n for j in range(len(centers)):\\n centers_ = deepcopy(centers)\\n centers_[j] = i\\n members_, costs_, tot_cost_, dist_mat_ = _get_cost(X, centers_, dist_func)\\n if tot_cost_ < tot_cost:\\n members, costs, tot_cost, dist_mat = members_, costs_, tot_cost_, dist_mat_\\n centers = centers_\\n swapped = True\\n if verbose:\\n print('Change centers to {}'.format(centers))\\n if cc > max_iter:\\n if verbose:\\n print('End Searching by reaching maximum iteration')\\n break\\n if not swapped:\\n if verbose:\\n print('End Searching by no swaps')\\n break\\n cc += 1\\n return centers, members, costs, tot_cost, dist_mat\",\n \"def do_knn(x_data):\\n return True\",\n \"def sample_features(self, X, mode='auto', return_index=False): \\n\\n X = check_array(X)\\n n_features = X.shape[1]\\n if mode in ['auto', 'sqrt']:\\n sample_features = int(np.sqrt(n_features))\\n elif mode == 'log2':\\n sample_features = int(np.log(n_features))\\n elif not mode:\\n sample_features = n_features\\n idx = np.random.choice(n_features, sample_features, replace=False)\\n if return_index:\\n return X[:, idx], idx\\n return X[:, idx]\",\n \"def test_sparse():\\n\\n rng = np.random.RandomState(0)\\n\\n X = rng.rand(20, 2)\\n X[X < 0.8] = 0\\n X_csr = sp.csr_matrix(X)\\n\\n bisect_means = BisectingKMeans(n_clusters=3, random_state=0)\\n\\n bisect_means.fit(X_csr)\\n sparse_centers = bisect_means.cluster_centers_\\n\\n bisect_means.fit(X)\\n normal_centers = bisect_means.cluster_centers_\\n\\n # Check if results is the same for dense and sparse data\\n assert_allclose(normal_centers, sparse_centers, atol=1e-8)\",\n \"def runcount(test_keys, sigma, sigma_max, sigma_step,\\n npoints_min, npoints_max, npoints_step):\\n run = 1\\n for key in test_keys:\\n if key:\\n while sigma < sigma_max:\\n npoints = npoints_min\\n while npoints < npoints_max:\\n npoints += npoints_step\\n run += 1\\n sigma += sigma_step\\n return run\",\n \"def test_genx(nsd, backend):\\n # NCOLS of data:\\n # 2 - test kernel only\\n # 3 - test kernel and chi2 calculation\\n # 4 - test resolution smearing and chi2 calculation\\n\\n test_name, slabs, data = nsd\\n\\n kernel_test(slabs, data, backend)\",\n \"def test_keypoint_detection(init_env, config_file):\\n run_all_steps(init_env, config_file)\",\n \"def sortKey( self, mode, matrix ):\\n # TODO: figure out how to handle \\n return False,[],None\",\n \"def test_integer_map_key_index():\\n\\tlib.backup_and_restore(\\n\\t\\tlambda context: create_indexes(lib.create_integer_map_key_index),\\n\\t\\tNone,\\n\\t\\tlambda context: check_indexes(lib.check_map_key_index, 12345)\\n\\t)\",\n \"def test_index_start(self):\\n sp_file = os.path.join(\\\"tests\\\", \\\"data\\\", \\\"geolife\\\", \\\"geolife_staypoints.csv\\\")\\n sp = ti.read_staypoints_csv(sp_file, tz=\\\"utc\\\", index_col=\\\"id\\\", crs=\\\"epsg:4326\\\")\\n\\n # reproject to WGS_1984_UTM_Zone_49N\\n sp = sp.to_crs(\\\"epsg:32649\\\")\\n\\n distance_metric_ls = [\\\"haversine\\\", \\\"euclidean\\\"]\\n agg_level_ls = [\\\"dataset\\\", \\\"user\\\"]\\n for distance_metric in distance_metric_ls:\\n for agg_level in agg_level_ls:\\n _, locations = sp.as_staypoints.generate_locations(\\n method=\\\"dbscan\\\", epsilon=10, num_samples=1, distance_metric=distance_metric, agg_level=agg_level\\n )\\n assert (locations.index == np.arange(len(locations))).any()\",\n \"def example2():\\r\\n params = {'w': 2 * pi * 300 * nu.THz,\\r\\n 'd_list': [inf, inf],\\r\\n 'ex_list': [1, -5],\\r\\n 'ez_list': [1, 1],\\r\\n 'mu_list': [1.1, 1.3]}\\r\\n \\r\\n kx_list = find_kx(params, show_progress=False, grid_points=30,\\r\\n iterations=8, reduction_factor=14,\\r\\n plot_full_region=True)\\r\\n print('kx_list: ',\\r\\n ['(%.4g+%.4gj) rad/um' % (kx.real / nu.um**-1, kx.imag / nu.um**-1)\\r\\n for kx in kx_list])\\r\\n for kx in kx_list:\\r\\n new_params = deepcopy(params)\\r\\n new_params['kx'] = kx\\r\\n print('---')\\r\\n print('With kx =', '(%.4g+%.4gj) rad/um' % (kx.real / nu.um**-1, kx.imag / nu.um**-1),\\r\\n ', checking mode...')\\r\\n new_params = find_all_params_from_kx(new_params)\\r\\n print('kz in each layer:',\\r\\n ['(%.4g+%.4gj) rad/um' % (kz.real / nu.um**-1, kz.imag / nu.um**-1)\\r\\n for kz in new_params['kz_list']])\\r\\n check_mode_results = check_mode(new_params)\\r\\n if check_mode_results is not True:\\r\\n print('This seems not to be a real mode. Error code:')\\r\\n print(check_mode_results)\\r\\n else:\\r\\n print('The mode passes all tests! Plotting...')\\r\\n plot_mode(new_params)\\r\\n scale_factor = (5 * nu.nW/nu.um) / new_params['Sx_total']\\r\\n scaled_params = rescale_fields(scale_factor, new_params)\\r\\n print('If this wave carries 5 nW/um power (i.e. 5 nW travels in +x-direction')\\r\\n print('through the surface x=0, 0<y<1um, -inf<z<inf)')\\r\\n print('then |Ex(0,0)|=',\\r\\n abs(Ex(0, scaled_params)) / (nu.V/nu.m), 'V/m')\",\n \"def test_fit_ks(distribution):\\n print(\\\"TESTING: K-S fit for %s distribution\\\" % distribution.upper())\\n print(\\\" fitting to others\\\")\\n for sample_dist in dist.get():\\n print(\\\" %s\\\" % sample_dist.upper())\\n params = dist.DISTRIBUTIONS[sample_dist][dist.KEY_TEST_PARAMS]\\n test_sample = dist.samples(sample_dist, params)\\n fit_results = fit.fit_ks(distribution, test_sample)\\n print(\\\" input parameters: %s\\\" % dist.get_params(params, sample_dist))\\n print(\\\" fit parameters: %s\\\" % dist.get_params(fit_results['params'], distribution))\\n print(\\\" log-likelihood: %r\\\" % fit_results['log-likelihood'])\\n print(\\\" K-S statistics: %r\\\" % fit_results['D'])\",\n \"def clustering_dbscan_o3d():\\n pass\",\n \"def test_main_on_cluster(self):\\r\\n\\r\\n command = \\\" \\\".join([\\\"denoiser.py\\\",\\r\\n \\\"--force\\\", \\\"-o\\\", self.test_dir, \\\"-c\\\", \\\"-n\\\", \\\"2\\\",\\r\\n \\\"-i\\\", \\\"%s/qiime/support_files/denoiser/TestData/denoiser_test_set.sff.txt\\\" % PROJECT_HOME,\\r\\n \\\"-f\\\", \\\"%s/qiime/support_files/denoiser/TestData/test_set_seqs.fna\\\" % PROJECT_HOME])\\r\\n\\r\\n result = Popen(command, shell=True, universal_newlines=True,\\r\\n stdout=PIPE, stderr=STDOUT).stdout.read()\\r\\n self.result_dir = self.test_dir\\r\\n\\r\\n observed = \\\"\\\".join(list(open(self.result_dir + \\\"centroids.fasta\\\")))\\r\\n self.assertEqual(observed, self.expected)\",\n \"def KS(self, using, dx=0.0001):\\n pits = np.array(self.PIT(using=using,dx=dx))\\n ks_result = skgof.ks_test(pits, stats.uniform())\\n return ks_result.statistic, ks_result.pvalue\",\n \"def evaluate(inshp, kshp, (dx, dy)=(1, 1), nkern=1, mode='valid', ws=True):\\r\\n N = numpy\\r\\n\\r\\n # inshp contains either 2 entries (height,width) or 3 (nfeatures,h,w)\\r\\n # in the first case, default nfeatures to 1\\r\\n if N.size(inshp) == 2:\\r\\n inshp = (1,) + inshp\\r\\n\\r\\n inshp = N.array(inshp)\\r\\n kshp = N.array(kshp)\\r\\n ksize = N.prod(kshp)\\r\\n\\r\\n kern = ksize - 1 - N.arange(ksize)\\r\\n\\r\\n # size of output image if doing proper convolution\\r\\n # (mode='full',dx=dy=0) outshp is the actual output shape\\r\\n # given the parameters\\r\\n fulloutshp = inshp[1:] + kshp - 1\\r\\n if mode == 'valid':\\r\\n s = -1\\r\\n else:\\r\\n s = 1\\r\\n outshp = N.int64(N.ceil((inshp[1:] + s * kshp - s * 1) \\\\\\r\\n / N.array([dy, dx], dtype='float')))\\r\\n if any(outshp <= 0):\\r\\n err = 'Invalid kernel', kshp, 'and/or step size', (dx, dy),\\\\\\r\\n 'for given input shape', inshp\\r\\n raise ValueError(err)\\r\\n\\r\\n outsize = N.prod(outshp)\\r\\n insize = N.prod(inshp)\\r\\n\\r\\n # range of output units over which to iterate\\r\\n if mode == 'valid':\\r\\n lbound = N.array([kshp[0] - 1, kshp[1] - 1])\\r\\n ubound = lbound + (inshp[1:] - kshp + 1)\\r\\n else:\\r\\n lbound = N.zeros(2)\\r\\n ubound = fulloutshp\\r\\n\\r\\n # coordinates of image in \\\"fulloutshp\\\" coordinates\\r\\n topleft = N.array([kshp[0] - 1, kshp[1] - 1])\\r\\n # bound when counting the receptive field\\r\\n botright = topleft + inshp[1:]\\r\\n\\r\\n # sparse matrix specifics...\\r\\n if ws:\\r\\n spmatshp = (outsize * N.prod(kshp) * inshp[0], insize)\\r\\n else:\\r\\n spmatshp = (nkern * outsize, insize)\\r\\n spmat = scipy_sparse.lil_matrix(spmatshp)\\r\\n\\r\\n # loop over output image pixels\\r\\n z, zz = 0, 0\\r\\n\\r\\n # incremented every time we write something to the sparse\\r\\n # matrix this is used to track the ordering of filter tap\\r\\n # coefficient in sparse column ordering\\r\\n tapi, ntaps = 0, 0\\r\\n\\r\\n # Note: looping over the number of kernels could've been done\\r\\n # more efficiently as the last step (when writing to\\r\\n # spmat). However, this messes up the ordering of the column\\r\\n # values (order in which you write the values determines how\\r\\n # the vectorized data will get used later one)\\r\\n\\r\\n for fmapi in xrange(inshp[0]): # loop over input features\\r\\n # loop over number of kernels (nkern=1 for weight sharing)\\r\\n for n in xrange(nkern):\\r\\n\\r\\n # FOR EACH OUTPUT PIXEL...\\r\\n # loop over output image height\\r\\n for oy in N.arange(lbound[0], ubound[0], dy):\\r\\n # loop over output image width\\r\\n for ox in N.arange(lbound[1], ubound[1], dx):\\r\\n\\r\\n # kern[l] is filter value to apply at (oj,oi)\\r\\n # for (iy,ix)\\r\\n l = 0\\r\\n\\r\\n # ... ITERATE OVER INPUT UNITS IN RECEPTIVE FIELD\\r\\n for ky in oy + N.arange(kshp[0]):\\r\\n for kx in ox + N.arange(kshp[1]):\\r\\n\\r\\n # verify if we are still within image\\r\\n # boundaries. Equivalent to\\r\\n # zero-padding of the input image\\r\\n if (all((ky, kx) >= topleft) and\\r\\n all((ky, kx) < botright)):\\r\\n\\r\\n # convert to \\\"valid\\\" input space\\r\\n # coords used to determine column\\r\\n # index to write to in sparse mat\\r\\n iy, ix = N.array((ky, kx)) - topleft\\r\\n # determine raster-index of input pixel...\\r\\n\\r\\n # taking into account multiple\\r\\n # input features\\r\\n col = iy * inshp[2] + ix + \\\\\\r\\n fmapi * N.prod(inshp[1:])\\r\\n\\r\\n # convert oy,ox values to output\\r\\n # space coordinates\\r\\n if mode == 'full':\\r\\n (y, x) = (oy, ox)\\r\\n else:\\r\\n (y, x) = (oy, ox) - topleft\\r\\n # taking into account step size\\r\\n (y, x) = N.array([y, x]) / (dy, dx)\\r\\n\\r\\n # convert to row index of sparse matrix\\r\\n if ws:\\r\\n row = ((y * outshp[1] + x) *\\r\\n inshp[0] * ksize + l + fmapi *\\r\\n ksize)\\r\\n else:\\r\\n row = y * outshp[1] + x\\r\\n\\r\\n # Store something at that location\\r\\n # in sparse matrix. The written\\r\\n # value is only useful for the\\r\\n # sparse case. It will determine\\r\\n # the way kernel taps are mapped\\r\\n # onto the sparse columns (idea of\\r\\n # kernel map)\\r\\n # n*... only for sparse\\r\\n spmat[row + n * outsize, col] = tapi + 1\\r\\n\\r\\n # total number of active taps\\r\\n # (used for kmap)\\r\\n ntaps += 1\\r\\n\\r\\n # absolute tap index (total number of taps)\\r\\n tapi += 1\\r\\n # move on to next filter tap l=(l+1)%ksize\\r\\n l += 1\\r\\n\\r\\n if spmat.format != 'csc':\\r\\n spmat = spmat.tocsc().sorted_indices()\\r\\n else:\\r\\n # BUG ALERT: scipy0.6 has bug where data and indices are written in\\r\\n # reverse column ordering.\\r\\n # Explicit call to sorted_indices removes this problem.\\r\\n spmat = spmat.sorted_indices()\\r\\n\\r\\n if ws:\\r\\n kmap = None\\r\\n else:\\r\\n kmap = N.zeros(ntaps, dtype='int')\\r\\n k = 0\\r\\n #print 'TEMPORARY BUGFIX: REMOVE !!!'\\r\\n for j in xrange(spmat.shape[1]):\\r\\n for i_idx in xrange(spmat.indptr[j], spmat.indptr[j + 1]):\\r\\n if spmat.data[i_idx] != 0:\\r\\n # this is == spmat[i,j] - 1\\r\\n kmap[k] = spmat.data[i_idx] - 1\\r\\n k += 1\\r\\n\\r\\n # when in valid mode, it is more efficient to store in sparse row\\r\\n # TODO: need to implement structured dot for csr matrix\\r\\n assert spmat.format == 'csc'\\r\\n sptype = 'csc'\\r\\n #sptype = 'csr' if mode=='valid' else 'csc'\\r\\n if 0 and mode == 'valid':\\r\\n spmat = spmat.tocsr()\\r\\n\\r\\n rval = (spmat.indices[:spmat.size],\\r\\n spmat.indptr, spmatshp, sptype, outshp)\\r\\n if kmap is not None:\\r\\n rval += (kmap,)\\r\\n\\r\\n return rval\",\n \"def chi2sf_inplace(x, k):\",\n \"def k_nearest_neighbors(x_test, df_training, k):\\n\\n return np.argpartition(distance_to_each_training_point(x_test,\\n df_training), k-1)[:,0:k]\",\n \"def build_k_indices(num_row, k_fold, seed):\\n #num_row = y.shape[0]\\n interval = int(num_row / k_fold)\\n np.random.seed(seed)\\n indices = np.random.permutation(num_row)\\n k_indices = [indices[k * interval: (k + 1) * interval]\\n for k in range(k_fold)]\\n return np.array(k_indices)\",\n \"def findknn(xTr,xTe,k):\\n\\n # YOUR CODE HERE\\n if k > len(xTr):\\n k = len(xTr)\\n \\n D=l2distance(xTe, xTr)\\n (m,n) = D.shape\\n \\n indices = []\\n dists = []\\n for i in range(m):\\n smallest_indices = np.argsort(D[i])\\n ind = smallest_indices[:k]\\n dis = D[i,smallest_indices[:k]]\\n indices.append(ind)\\n dists.append(dis)\\n \\n indices = np.transpose(np.array(indices))\\n dists = np.transpose(np.array(dists))\\n return indices, dists\",\n \"def test_n_clusters(n_clusters):\\n\\n rng = np.random.RandomState(0)\\n X = rng.rand(10, 2)\\n\\n bisect_means = BisectingKMeans(n_clusters=n_clusters, random_state=0)\\n bisect_means.fit(X)\\n\\n assert_array_equal(np.unique(bisect_means.labels_), np.arange(n_clusters))\",\n \"def example1():\\r\\n params = {'w': 2 * pi * 300 * nu.THz,\\r\\n 'd_list': [inf, 40 * nu.nm, inf],\\r\\n 'ex_list': [1, -5 + 2j, 10],\\r\\n 'ez_list': [1, -3 + 3j, 7],\\r\\n 'mu_list': [1, 1.2, 1.3]}\\r\\n \\r\\n kx_list = find_kx(params, show_progress=False, grid_points=30,\\r\\n iterations=8, reduction_factor=14,\\r\\n plot_full_region=True)\\r\\n print('kx_list: ',\\r\\n ['(%.4g+%.4gj) rad/um' % (kx.real / nu.um**-1, kx.imag / nu.um**-1)\\r\\n for kx in kx_list])\\r\\n for kx in kx_list:\\r\\n new_params = deepcopy(params)\\r\\n new_params['kx'] = kx\\r\\n print('---')\\r\\n print('With kx =', '(%.4g+%.4gj) rad/um' % (kx.real / nu.um**-1, kx.imag / nu.um**-1),\\r\\n ', checking mode...')\\r\\n new_params = find_all_params_from_kx(new_params)\\r\\n print('kz in each layer:',\\r\\n ['(%.4g+%.4gj) rad/um' % (kz.real / nu.um**-1, kz.imag / nu.um**-1)\\r\\n for kz in new_params['kz_list']])\\r\\n check_mode_results = check_mode(new_params)\\r\\n if check_mode_results is not True:\\r\\n print('This seems not to be a real mode. Error code:')\\r\\n print(check_mode_results)\\r\\n else:\\r\\n print('The mode passes all tests! Plotting...')\\r\\n plot_mode(new_params)\\r\\n scale_factor = (5 * nu.nW/nu.um) / new_params['Sx_total']\\r\\n scaled_params = rescale_fields(scale_factor, new_params)\\r\\n print('If this wave carries 5 nW/um power (i.e. 5 nW travels in +x-direction')\\r\\n print('through the surface x=0, 0<y<1um, -inf<z<inf)')\\r\\n print('then |Ex(0,0)|=',\\r\\n abs(Ex(0, scaled_params)) / (nu.V/nu.m), 'V/m')\",\n \"def test_oss_sk_estimator():\\n check_estimator(OneSidedSelection)\",\n \"def test_k_1(self):\\n knn = KNeighborsClassifier(n_neighbors=1)\\n knn.fit(X_train, y_train)\\n prediction = knn.predict(X_test)\\n\\n knn2 = Knn(n_neighbors=1)\\n knn2.fit(X_train, y_train)\\n prediction2 = knn2.predict(X_test)\\n\\n assert np.alltrue(prediction == prediction2), \\\"Error testing knn with k=1\\\"\",\n \"def get_data_indices(aperiodic_mode):\\n\\n indices = {\\n 'CF' : 0,\\n 'PW' : 1,\\n 'BW' : 2,\\n 'offset' : 0,\\n 'knee' : 1 if aperiodic_mode == 'knee' else None,\\n 'exponent' : 1 if aperiodic_mode == 'fixed' else 2\\n }\\n\\n return indices\",\n \"def test_st_facets00401m11_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m11.xsd\\\",\\n instance=\\\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m11_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def test_st_facets00401m6_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m6.xsd\\\",\\n instance=\\\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m6_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def key_filter(template_index, num_keys, row):\\n\\n template = nori.core.cfg['templates'][template_index]\\n\\n if (nori.core.cfg['key_mode'] == 'all' and\\n template[T_KEY_MODE_KEY] == 'all'):\\n return True\\n\\n if not check_key_list_match(nori.core.cfg['key_mode'],\\n nori.core.cfg['key_list'], num_keys, row):\\n return False\\n\\n if not check_key_list_match(template[T_KEY_MODE_KEY],\\n template[T_KEY_LIST_KEY], num_keys, row):\\n return False\\n\\n return True\",\n \"def cv_msk(x, k, permu=True):\\n n = x if isinstance(x, int) else len(x)\\n idx = np.array(np.arange(np.ceil(n / float(k)) * k), '<i4')\\n if permu:\\n idx = np.random.permutation(idx)\\n idx = idx.reshape(k, -1) % n\\n msk = np.zeros((k, n), 'bool')\\n for _ in range(k):\\n msk[_, idx[_, ]] = True\\n return msk\",\n \"def find_nearest_neighbors_idx(X, x, k):\\n ## homework:start\\n result = \\n ## homework:end\\n return result\",\n \"def __init__(self, mode) :\\n\\n self.mode = mode \\n\\n self.run_pairs = get_runs(self.mode, check_exists=True)\\n\\n if settings.RANK == 0 :\\n print('%d samples in the %s set'%(len(self.run_pairs), str(mode)))\",\n \"def _scipy_fk_test(self, mode='median', alpha=0.01):\\n q0 = self.get_group_data(0, self.df_test_resampled, ['Q'])\\n q1 = self.get_group_data(1, self.df_test_resampled, ['Q'])\\n\\n with warnings.catch_warnings(): # supress scipy warnings\\n warnings.filterwarnings('ignore')\\n fstats, pval = fligner(q0, q1, center=mode)\\n\\n stats_fk = {'z': fstats, 'pval': pval}\\n\\n if stats_fk['pval'] <= alpha: # With CHI2 approximation\\n h = 1\\n else:\\n h = 0\\n\\n return h, stats_fk\",\n \"def test_index_stability(self, example_staypoints):\\n sp = example_staypoints\\n sp2, locs = sp.as_staypoints.generate_locations(\\n method=\\\"dbscan\\\", epsilon=10, num_samples=2, distance_metric=\\\"haversine\\\", agg_level=\\\"user\\\"\\n )\\n assert sp.index.equals(sp2.index)\",\n \"def Test(self, K_test=5, n_eg=None, K=5, \\\\\\n C_parameters=np.array([0.01, 0.1, 1.0, 10., 100.]), \\\\\\n norm_SF=True, norm_plane=True, tol_=0.0001, \\\\\\n max_iter_=10000):\\n\\n # test acc array\\n test_acc = np.zeros((self.__n_type, 3))\\n n_test_eg = np.zeros((self.__n_type, 3))\\n\\n # Saving examples for real training later and shuffling examples\\n for idx_type, type_ in enumerate(self.__types_unique):\\n np.random.shuffle(self.training_R[idx_type])\\n np.random.shuffle(self.training_NR[idx_type])\\n training_R = list(self.training_R)\\n training_NR = list(self.training_NR)\\n\\n\\n for K_ in range(K_test):\\n print('K = '+str(K_))\\n\\n # Creates a testing an training set from original training set\\n testing_R = []\\n testing_NR = []\\n for idx_type, type_ in enumerate(self.__types_unique):\\n\\n # Finds rearrangements and non-rearrangements of given particle\\n # type\\n Rs_type = self.training_R[idx_type]\\n NRs_type = self.training_NR[idx_type]\\n\\n # Finds a test set of rearrangements\\n Rs_type_test = Rs_type[K_::K_test]\\n NRs_type_test = NRs_type[K_::K_test]\\n n_test = min(len(Rs_type_test),len(NRs_type_test))\\n Rs_type_test = Rs_type_test[:n_test]\\n NRs_type_test = NRs_type_test[:n_test]\\n testing_R.append(Rs_type_test)\\n testing_NR.append(NRs_type_test)\\n\\n # Deletes test set from training set\\n Rs_type = np.delete(Rs_type, \\\\\\n list(range(K_,len(Rs_type),K_test)),axis=0)\\n NRs_type = np.delete(NRs_type, \\\\\\n list(range(K_,len(NRs_type),K_test)), axis=0)\\n self.training_R[idx_type] = Rs_type\\n self.training_NR[idx_type] = NRs_type\\n\\n # Trains softness model using reduced training set\\n self.Train(n_eg=n_eg, K=K, \\\\\\n C_parameters=C_parameters, norm_SF=norm_SF, \\\\\\n norm_plane=norm_plane, tol_=tol_, \\\\\\n max_iter_=max_iter_)\\n\\n # Tests new plane against test set\\n for idx_type, type_ in enumerate(self.__types_unique):\\n\\n # Finds number of soft rearrangements and hard \\n # non-rearrangements\\n soft_Rs = self.GetSoft(testing_R[idx_type])\\n soft_NRs = self.GetSoft(testing_NR[idx_type])\\n nRs = np.sum(soft_Rs > 0)\\n nNRs = np.sum(soft_NRs < 0)\\n\\n # Calculates # of correctly classified particles\\n test_acc[idx_type][0] += nRs+nNRs\\n n_test_eg[idx_type][0] += len(soft_Rs)+len(soft_NRs)\\n test_acc[idx_type][1] += nRs\\n n_test_eg[idx_type][1] += len(soft_Rs)\\n test_acc[idx_type][2] += nNRs\\n n_test_eg[idx_type][2] += len(soft_NRs)\\n\\n # Returns self.training_R and self.training_NR to original state\\n self.training_R = list(training_R)\\n self.training_NR = list(training_NR)\\n\\n # Calculates test set accuracy\\n test_acc = test_acc / n_test_eg\\n\\n return test_acc\",\n \"def test_ks_ms(distribution):\\n print(\\\"TESTING: K-S model selection for %s distribution\\\" % distribution.upper())\\n params = dist.DISTRIBUTIONS[distribution][dist.KEY_TEST_PARAMS]\\n print(\\\" creating sample\\\")\\n test_sample = dist.samples(distribution, params)\\n print(\\\" calculating K-S statistics for all distributions\\\")\\n print(\\\" input parameters: %s\\\" % dist.get_params(params, distribution))\\n fit_results = {}\\n best_ksd = 1.0\\n best_model = dist.get()[0]\\n for d in dist.get():\\n print(\\\" %s:\\\" % d.upper())\\n fit_results[d] = fit.fit_ks(d, test_sample)\\n if fit_results[d]['D'] < best_ksd:\\n best_ksd = fit_results[d]['D']\\n best_model = d\\n print(\\\" %s\\\" % dist.get_params(fit_results[d]['params'], d))\\n print(\\\" D = %r\\\" % fit_results[d]['D'])\\n params = fit_results[d]['params']\\n p = 0\\n for r in range(100):\\n synthetic_sample = dist.samples(d, params, len(test_sample))\\n ksd = me.ks_statistics(dist.get_sample_cdf(synthetic_sample), dist.cdf(d, params, np.max(synthetic_sample)))\\n if ksd > fit_results[d]['D']:\\n p += 1\\n print(\\\" p = %r\\\" % (float(p)/100.0))\\n print(\\\" Best fitting model: %s\\\" % best_model.upper())\\n print_pmfs(test_sample, fit_results, 'TEST-KS.CSV')\",\n \"def test_call_low_cluster_identity(self):\\r\\n\\r\\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\\r\\n # Should only get 6 clusters\\r\\n exp_otu_ids = [str(x) for x in range(6)]\\r\\n\\r\\n exp_clusters =\\\\\\r\\n [['uclust_test_seqs_0', 'uclust_test_seqs_6',\\r\\n 'uclust_test_seqs_9'], ['uclust_test_seqs_1'], ['uclust_test_seqs_2'],\\r\\n ['uclust_test_seqs_3',\\r\\n 'uclust_test_seqs_5',\\r\\n 'uclust_test_seqs_8'],\\r\\n ['uclust_test_seqs_4'], ['uclust_test_seqs_7']]\\r\\n\\r\\n app = UsearchOtuPicker(params={'save_intermediate_files': False,\\r\\n 'db_filepath': self.tmp_ref_database,\\r\\n 'output_dir': self.temp_dir,\\r\\n 'remove_usearch_logs': True,\\r\\n 'reference_chimera_detection': False,\\r\\n 'de_novo_chimera_detection': False,\\r\\n 'cluster_size_filtering': False,\\r\\n 'minlen': 12,\\r\\n 'w': 12,\\r\\n 'minsize': 1,\\r\\n 'percent_id': 0.80,\\r\\n 'percent_id_err': 0.97\\r\\n })\\r\\n\\r\\n obs = app(self.tmp_seq_filepath1)\\r\\n\\r\\n obs_otu_ids = sorted(obs.keys())\\r\\n obs_clusters = sorted(obs.values())\\r\\n # The relation between otu ids and clusters is abitrary, and\\r\\n # is not stable due to use of dicts when parsing clusters -- therefore\\r\\n # just checks that we have the expected group of each\\r\\n self.assertEqual(obs_otu_ids, exp_otu_ids)\\r\\n self.assertEqual(obs_clusters, exp_clusters)\",\n \"def test_call_alt_threshold(self):\\r\\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\\r\\n\\r\\n exp_otu_ids = range(9)\\r\\n exp_clusters = [['uclust_test_seqs_0'],\\r\\n ['uclust_test_seqs_1'],\\r\\n ['uclust_test_seqs_2'],\\r\\n ['uclust_test_seqs_3'],\\r\\n ['uclust_test_seqs_4'],\\r\\n ['uclust_test_seqs_5'],\\r\\n ['uclust_test_seqs_6', 'uclust_test_seqs_8'],\\r\\n ['uclust_test_seqs_7'],\\r\\n ['uclust_test_seqs_9']]\\r\\n\\r\\n app = UclustOtuPicker(params={'Similarity': 0.90,\\r\\n 'suppress_sort': False,\\r\\n 'presort_by_abundance': False,\\r\\n 'save_uc_files': False})\\r\\n obs = app(self.tmp_seq_filepath1)\\r\\n obs_otu_ids = sorted(obs.keys())\\r\\n obs_clusters = sorted(obs.values())\\r\\n # The relation between otu ids and clusters is abitrary, and\\r\\n # is not stable due to use of dicts when parsing clusters -- therefore\\r\\n # just checks that we have the expected group of each\\r\\n self.assertEqual(obs_otu_ids, exp_otu_ids)\\r\\n self.assertEqual(obs_clusters, exp_clusters)\",\n \"def test_spanner_indexer_individual_insert(testing_indexer):\\n codec = IdCodec()\\n indexed_string = get_random_string(10)\\n\\n model1_id = get_id()\\n expected_key_result = KeyResults()\\n expected_key_result.add_key_result(KeyResult(org_id=55555, string=indexed_string, id=model1_id))\\n key_results1 = KeyResults()\\n model1 = SpannerIndexerModel(\\n id=codec.encode(model1_id),\\n decoded_id=model1_id,\\n string=indexed_string,\\n organization_id=55555,\\n date_added=datetime.now(),\\n last_seen=datetime.now(),\\n retention_days=55,\\n )\\n testing_indexer._insert_collisions_handled(UseCaseKey.PERFORMANCE, [model1], key_results1)\\n assert (\\n key_results1.get_mapped_key_strings_to_ints()\\n == expected_key_result.get_mapped_key_strings_to_ints()\\n )\\n\\n # Insert the same record with a different id but the key result would\\n # have the id of model1.\\n key_results2 = KeyResults()\\n model2_id = get_id()\\n model2 = SpannerIndexerModel(\\n id=codec.encode(model2_id),\\n decoded_id=model2_id,\\n string=indexed_string,\\n organization_id=55555,\\n date_added=datetime.now(),\\n last_seen=datetime.now(),\\n retention_days=55,\\n )\\n testing_indexer._insert_collisions_handled(UseCaseKey.PERFORMANCE, [model2], key_results2)\\n assert (\\n key_results2.get_mapped_key_strings_to_ints()\\n == expected_key_result.get_mapped_key_strings_to_ints()\\n )\",\n \"def kmeans_clustering(all_features, vocab_size, epsilon, max_iter):\\n\\n # Your code here. You should also change the return value.\\n\\n def _initiate_random_centroids(all_features, vocab_size):\\n \\\"\\\"\\\"\\n Initiate random centroids in the range of input\\n\\n :param all_features:\\n :param vocab_size:\\n :return:\\n \\\"\\\"\\\"\\n centroids = []\\n # 1) Genereate points for initial centroids\\n\\n min_feat = np.ones(all_features[0].size)*np.inf\\n max_feat = np.zeros(all_features[0].size)\\n\\n for a in all_features:\\n for p in range(len(a)):\\n if a[p] < min_feat[p]:\\n min_feat[p] = a[p]\\n else:\\n if a[p] > max_feat[p]:\\n max_feat[p] = a[p]\\n\\n\\n for _ in range(vocab_size):\\n random_vector = np.multiply(np.random.rand(1, all_features[0].size),\\n max_feat-min_feat) + min_feat\\n centroids.append(random_vector.flatten())\\n\\n return np.array(centroids)\\n\\n def _assign_vectors_to_nearest_centroid(all_features, centroid):\\n \\\"\\\"\\\"\\n Assign vectors to nearest centroids\\n\\n :param all_features:\\n :param centroid:\\n :return:\\n \\\"\\\"\\\"\\n #TODO: sprawdz co lepiej dziala\\n new_centroid_coor = np.zeros([len(centroid), all_features[0].size])\\n #new_centroid_coor = centroid\\n new_centroid_counter = np.zeros(len(centroid))\\n\\n dist = pdist(centroid, all_features)\\n #min_dist = dist.min(axis=0)\\n min_dist_index = dist.argmin(axis=0)\\n\\n for x in range(len(min_dist_index)):\\n id = min_dist_index[x]\\n new_centroid_coor[id] = np.add(new_centroid_coor[id],\\n all_features[x])\\n new_centroid_counter[id] += 1\\n\\n new_centroid_coor_out = []\\n for i in range(len(new_centroid_coor)):\\n if new_centroid_counter[i] == 0:\\n new_centroid_coor_out.append(centroid[i])\\n else:\\n new_centroid_coor_out.append(np.divide(new_centroid_coor[i],new_centroid_counter[i]))\\n\\n return np.array(new_centroid_coor_out), new_centroid_counter\\n\\n\\n def _check_convergence_condition(old_centroids, new_centroids, epsilon):\\n \\\"\\\"\\\"\\n Check convergence confition\\n\\n :param old_centroids:\\n :param new_centroids:\\n :param epsilon: if every centroid is moved by dist < epsilon KMeans terminates\\n :return:\\n \\\"\\\"\\\"\\n for i in range(len(old_centroids)):\\n dist = euclidean(old_centroids[i], new_centroids[i])\\n if dist > epsilon:\\n return False\\n\\n return True\\n\\n def delete_small_clusters(new_centroids, centroid_counter, threshold):\\n \\\"\\\"\\\"\\n Potential extension of the algorithm -> if there is not any point in the cluster, delete this cluste\\n\\n :param new_centroids:\\n :param centroid_counter:\\n :param threshold:\\n :return:\\n \\\"\\\"\\\"\\n\\n out_centroids = []\\n for n in range(len(new_centroids)):\\n if centroid_counter[n] > threshold:\\n out_centroids.append(new_centroids[n])\\n out_centroids = np.array(out_centroids)\\n return out_centroids\\n\\n #MAIN\\n old_centroids = _initiate_random_centroids(all_features, vocab_size)\\n\\n for _ in range(max_iter):\\n new_centroids, centroid_counter = _assign_vectors_to_nearest_centroid(all_features, old_centroids)\\n if_convergenced = _check_convergence_condition(new_centroids, old_centroids, epsilon)\\n\\n if if_convergenced == True:\\n # return centroids if algorithm is converged\\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\\n return new_centroids\\n old_centroids = new_centroids\\n\\n # return centroids if reached max_iter\\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\\n return new_centroids\",\n \"def test_jaccard_index_compiled():\\n vector1 = np.array([1, 1, 0, 0])\\n vector2 = np.array([1, 1, 1, 1])\\n score11 = jaccard_index(vector1, vector1)\\n score12 = jaccard_index(vector1, vector2)\\n score22 = jaccard_index(vector2, vector2)\\n\\n assert score12 == 2 / 4, \\\"Expected different score.\\\"\\n assert score11 == score22 == 1.0, \\\"Expected different score.\\\"\",\n \"def testContains(self):\\n\\n N = randint(20,100)\\n for i in xrange(N):\\n self.s.insert(i,True)\\n N-=(i in self.s)\\n\\n self.assertEqual(N,0)\",\n \"def SSC_test():\\n \\n # generating data\\n\\n D = 40 # Dimension of ambient space\\n k = 4 # Number of subspaces\\n d = 1\\n N = 90 # Number of points in subspaces\\n # Generating N points in d dim. subspaces\\n Xi = [np.random.randn(D, d).dot(np.random.randn(d, N))\\n for _ in range(k)]\\n X = np.concatenate(Xi, axis=1)\\n\\n # Generating the ground-truth for evaluating clustering results\\n lbls = [i * np.ones([1, N]) for i in range(k)]\\n s = np.concatenate(lbls, axis=1)\\n r = 0 # Enter the projection dimension e.g. r = d*n, enter r = 0 to not project\\n Cst = 0 # Enter 1 to use the additional affine constraint sum(c) == 1\\n OptM = 'L1Noise' # OptM can be {'L1Perfect','L1Noise','Lasso','L1ED'}\\n lmbda = 0.001 # Regularization parameter in 'Lasso' or the noise level for 'L1Noise'\\n # Number of top coefficients to build the similarity graph, enter K=0 for using the whole coefficients\\n K = 0 #max(d1, d2)\\n if Cst == 1:\\n K = d + 1 # For affine subspaces, the number of coefficients to pick is dimension + 1\\n\\n Xp = DataProjection(X, r, 'NormalProj')\\n \\n # testing clustering\\n \\n '''\\n # using wrapper function\\n Grps, sc = sparseSubspaceClustering(\\n Xp.T, n, ground_truth=s, affine=Cst, OptM=OptM, lam=lmbda)\\n Grps = BestMap(sc, Grps)\\n Missrate = float(np.sum(sc != Grps)) / sc.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\\n '''\\n \\n '''\\n # calling internal tools\\n CMat = SparseCoefRecovery(Xp, Cst, OptM, lmbda)\\n # Make small values 0\\n eps = np.finfo(float).eps\\n CMat[np.abs(CMat) < eps] = 0\\n\\n CMatC, sc, OutlierIndx, Fail = OutlierDetection(CMat, s)\\n\\n if Fail == False:\\n CKSym = BuildAdjacency(CMatC, K)\\n Grps = SpectralClustering(CKSym, n)\\n Grps = BestMap(sc, Grps)\\n Missrate = float(np.sum(sc != Grps)) / sc.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\\n else:\\n print(\\\"Something failed\\\")\\n '''\\n \\n labels, _, __ = KSubspaces(Xp.T, k, d)\\n labels = BestMap(s, labels)\\n Missrate = float(np.sum(s != labels)) / s.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\",\n \"def _assert_ks_postformat(self):\\n if type(self.idxs) in [list, np.ndarray]:\\n if self.ks is None:\\n if self.staticneighs:\\n pass\\n else:\\n self.ks = range(len(self.idxs))\\n if self.staticneighs:\\n pass\\n else:\\n# print self.ks, self.idxs, self.set_neighs, self.set_sp_rel_pos\\n assert(len(self.ks) == len(self.idxs))\\n ## Defining functions\\n if self.sp_relative_pos is not None and self.staticneighs:\\n self.get_sp_rel_pos = self._static_get_rel_pos\\n elif not self.staticneighs:\\n if type(self.sp_relative_pos) == list:\\n self.get_sp_rel_pos = self._dynamic_rel_pos_list\\n else:\\n self.get_sp_rel_pos = self._dynamic_rel_pos_array\\n if self.sp_relative_pos is None:\\n self.set_sp_rel_pos = self._null_set_rel_pos\\n self.get_sp_rel_pos = self._null_get_rel_pos\\n ## Ensure correct k_ret\\n if np.max(self.ks) > self._kret:\\n self._kret = np.max(self.ks)\",\n \"def test_st_facets00401m9_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m9.xsd\\\",\\n instance=\\\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m9_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def test_main_on_cluster(self):\\n\\n command = \\\" \\\".join( [\\\"%s/denoiser.py\\\" % get_qiime_scripts_dir(),\\n \\\"--force\\\",\\\"-o\\\", self.test_dir, \\\"-c\\\", \\\"-n\\\", \\\"2\\\",\\n \\\"-i\\\", \\\"%s/qiime/support_files/denoiser/TestData/denoiser_test_set.sff.txt\\\" % PROJECT_HOME, \\n \\\"-f\\\", \\\"%s/qiime/support_files/denoiser/TestData/test_set_seqs.fna\\\" % PROJECT_HOME] )\\n\\n result = Popen(command,shell=True,universal_newlines=True,\\\\\\n stdout=PIPE,stderr=STDOUT).stdout.read()\\n self.result_dir = self.test_dir\\n\\n observed = \\\"\\\".join(list(open(self.result_dir+ \\\"centroids.fasta\\\")))\\n self.assertEqual(observed, self.expected)\",\n \"def trainSOM_getK(model):\\n model.detect_serialized_datasets()\\n model.detect_prepared_datasets()\\n model.train_SOM()\\n model.detect_som_products()\\n model.generate_k()\\n cluster_num = model.get_k()\\n return cluster_num\",\n \"def threshold_trec_run(run, fold, k):\\n filtered_run = defaultdict(dict)\\n # This is possible because best_search_run is an OrderedDict\\n for qid, docs in run.items():\\n if qid in fold[\\\"predict\\\"][\\\"test\\\"]:\\n for idx, (docid, score) in enumerate(docs.items()):\\n if idx >= k:\\n break\\n filtered_run[qid][docid] = score\\n\\n return filtered_run\",\n \"def main():\\n if len(sys.argv) != 5:\\n exit(\\\"Usage: python oneta.py train-corpus test-corpus kernel-size output\\\")\\n\\n w1Words = dict()\\n w2Words = dict()\\n W1 = 0\\n W2 = 0\\n\\n D1 = int(sys.argv[3])\\n\\n sys.stderr.write(\\\"First scan of training data\\\\n\\\")\\n \\n J = 0\\n # Read through the corpus to decided which words are in the dense set and which in the sparse set\\n corpus = open(sys.argv[1],\\\"r\\\")\\n for line in corpus:\\n tokens = word_tokenize(line)\\n for token in tokens:\\n tk_decoded = token.decode(\\\"utf-8\\\")\\n if J < D1 and tk_decoded not in w1Words:\\n w1Words[tk_decoded] = W1\\n W1 += 1\\n elif J >= D1 and tk_decoded not in w2Words:\\n w2Words[tk_decoded] = W2\\n W2 += 1\\n J += 1\\n corpus.close()\\n\\n D2 = J - D1\\n\\n # Partition the corpus into a L-shaped matrix\\n sys.stderr.write(\\\"Building matrices\\\")\\n At = lil_matrix((D1,W1))\\n B = lil_matrix((W1,D2))\\n Ct = lil_matrix((D2,W2))\\n\\n corpus = open(sys.argv[1],\\\"r\\\")\\n\\n j = 0\\n for line in corpus:\\n sys.stderr.write(\\\".\\\")\\n tokens = word_tokenize(line)\\n docsq = 0.\\n for token in tokens:\\n tk_decoded = token.decode(\\\"utf-8\\\")\\n if j < D1: # tk_decoded in w1words\\n tkId = w1Words[tk_decoded]\\n docsq += (At[j,tkId]+1)**2 - (At[j,tkId])**2\\n At[j,tkId] += 1.\\n elif tk_decoded in w1Words:\\n tkId = w1Words[tk_decoded]\\n docsq += (B[tkId,j-D1]+1)**2 - (B[tkId,j-D1])**2\\n B[tkId,j-D1] += 1.\\n else:\\n tkId = w2Words[tk_decoded]\\n docsq += (Ct[j-D1,tkId]+1)**2 - (Ct[j-D1,tkId])**2\\n Ct[j-D1,tkId] += 1.\\n if j < D1:\\n At[j,:] /= math.sqrt(docsq)\\n else:\\n for w in range(0,W1):\\n B[w,j-D1] /= math.sqrt(docsq)\\n Ct[j-D1,:] /= math.sqrt(docsq)\\n j += 1\\n\\n sys.stderr.write(\\\"\\\\nBuild Cn\\\\n\\\")\\n Cn = zeros((D2,1))\\n Ct = Ct.tocsr()\\n for i in range(0,D2):\\n v = ((Ct[i,:] * Ct[i,:].transpose())[0,0])\\n if v == 0:\\n Cn[i,0] = 1.\\n else:\\n Cn[i,0] = v\\n\\n # Building real matrices\\n sys.stderr.write(\\\"Calculating ATA\\\\n\\\")\\n ATA = (At * At.transpose()).todense() # D1 x D1\\n At = At.tocsr()\\n B = B.tocsc()\\n\\n sys.stderr.write(\\\"Solve inverse\\\\n\\\")\\n ATAi = linalg.inv(ATA)\\n\\n # The real calculation is that if we have input vector [ d_1 d_2 ] ^ T \\n # We yield [ (A^T * A)^-1 * A^T ( d1^T - B * (C^T * d2 / Cn) ) (C^T * d2 / Cn)\\n sys.stderr.write(\\\"Calculating projected vectors\\\\n\\\")\\n\\n out = open(sys.argv[4],\\\"w\\\")\\n testDocs = open(sys.argv[2],\\\"r\\\")\\n for testDoc in testDocs:\\n sys.stderr.write(\\\".\\\")\\n corpus = open(sys.argv[1],\\\"r\\\")\\n d1 = zeros((W1,1))\\n d2 = zeros((W2,1))\\n tokens = word_tokenize(testDoc)\\n for token in tokens:\\n tk_decoded = token.decode(\\\"utf-8\\\")\\n if tk_decoded in w1Words:\\n d1[w1Words[tk_decoded],0] += 1\\n elif tk_decoded in w2Words:\\n d2[w2Words[tk_decoded],0] += 1\\n norm = sqrt(sum(d1**2) + sum(d2**2))\\n d1 /= norm \\n d2 /= norm\\n v2 = (Ct * d2) / Cn\\n v1 = ATAi * (At * (d1 - B * v2))\\n for j in range(0,D1+D2):\\n out.write(str(j) + \\\" \\\")\\n out.write(\\\"||| \\\")\\n for j in range(0,D1):\\n out.write(str(v1[j,0]) + \\\" \\\")\\n for j in range(0,D2):\\n out.write(str(v2[j,0]) + \\\" \\\")\\n out.write(\\\"\\\\n\\\")\\n\\n out.flush()\\n out.close()\\n sys.stderr.write(\\\"\\\\n\\\")\",\n \"def test_st_facets00501m11_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/SType/ST_facets/ST_facets00501m/ST_facets00501m11.xsd\\\",\\n instance=\\\"sunData/SType/ST_facets/ST_facets00501m/ST_facets00501m11_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def test_st_facets00401m10_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m10.xsd\\\",\\n instance=\\\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m10_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def main():\\n data = Dummy(n_samples=500, n_dim=3)\\n X = data.get_dummy()\\n clustering = Kmeans(X, K=5, display=False)\\n clustering.run()\\n print(f\\\"Number of iterations: {clustering.num_iterations}\\\\n\\\")\\n\\n \\\"\\\"\\\" Test example of clustering_kmeans with unknown number of clusters K \\\"\\\"\\\"\\n clustering = Kmeans(X,)\\n clustering.silhouette_find_k()\\n print(f\\\"Number of centroids found: {clustering.num_K}\\\")\",\n \"def kmeans_fast(features, k, num_iters=100):\\n N = len(features)\\n print(N)\\n # Randomly initalize cluster centers\\n centers, assignments = np.array([features[i] for i in sorted(random.sample(range(0, len(features)), K))]), {}\\n _, dim = centers.shape\\n\\n tile_f = np.tile(features, (k, 1))\\n for n in range(num_iters):\\n tile_c = np.repeat(centers, N, axis=0)\\n tile_sub = np.subtract(tile_f, tile_c)\\n dist = np.linalg.norm(tile_sub, axis=1).reshape(k, N)\\n assignments_new = np.argmin(dist, axis=0)\\n if np.array_equal(assignments, assignments_new):\\n break\\n else:\\n assignments = assignments_new\\n\\n old_centers, new_stats = centers[:], []\\n for j in range(0, k):\\n new_stats.append([0, []])\\n for i in range(len(features)):\\n c_ind = int(assignments[i])\\n num, sum_vec = new_stats[c_ind]\\n sum_vec_new = np.add(sum_vec, features[i]) if len(sum_vec) > 0 else features[i]\\n new_stats[c_ind] = [num + 1, sum_vec_new]\\n\\n new_centers = np.zeros((k, dim))\\n for j in range(0, k):\\n num, new_center = new_stats[j]\\n new_center = np.divide(new_center, num)\\n new_centers[j] = np.array(new_center)\\n centers = new_centers\\n\\n return centers, assignments, 0\",\n \"def test_indices_distance(self):\\n maze = Maze(10, 10)\\n\\n for test in range(1000):\\n self.assertTrue(\\n (abs(maze.entrance[0] - maze.exit[0]) +\\n abs(maze.entrance[1] - maze.exit[1])) >= 9)\",\n \"def skip_test(n):\\n return k > 0 and magic * n * k**0.5 >= t4_ref\",\n \"def knn(k, Xtrain, Ytrain, Xtest):\\n d = euclidean_distances(Xtest, Xtrain, squared=True)\\n nnc = Ytrain[np.argsort(d)[..., :k].flatten()].reshape(Xtest.shape[0], k)\\n pred = [max(nnc[i], key=Counter(nnc[i]).get) for i in range(nnc.shape[0])]\\n return np.array(pred)\",\n \"def test_st_facets00401m21_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m21.xsd\\\",\\n instance=\\\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m21_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def test_call_low_cluster_identity(self):\\r\\n\\r\\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\\r\\n # Should only get 6 clusters\\r\\n exp_otu_ids = [str(x) for x in range(10)]\\r\\n\\r\\n exp_clusters = [['uclust_test_seqs_0'],\\r\\n ['uclust_test_seqs_1'],\\r\\n ['uclust_test_seqs_2'],\\r\\n ['uclust_test_seqs_3'],\\r\\n ['uclust_test_seqs_4'],\\r\\n ['uclust_test_seqs_5'],\\r\\n ['uclust_test_seqs_6'],\\r\\n ['uclust_test_seqs_7'],\\r\\n ['uclust_test_seqs_8'],\\r\\n ['uclust_test_seqs_9']]\\r\\n\\r\\n app = UsearchReferenceOtuPicker(\\r\\n params={'save_intermediate_files': False,\\r\\n 'db_filepath':\\r\\n self.tmp_ref_database,\\r\\n 'output_dir': self.temp_dir,\\r\\n 'remove_usearch_logs': True,\\r\\n 'reference_chimera_detection':\\r\\n False,\\r\\n 'de_novo_chimera_detection':\\r\\n False,\\r\\n 'cluster_size_filtering':\\r\\n False,\\r\\n 'minlen': 12,\\r\\n 'w': 12,\\r\\n 'minsize': 1,\\r\\n 'percent_id': 0.80,\\r\\n 'percent_id_err': 0.97\\r\\n })\\r\\n\\r\\n obs = app(self.tmp_seq_filepath1, self.tmp_otu_ref_database)\\r\\n\\r\\n obs_otu_ids = sorted(obs.keys())\\r\\n obs_clusters = sorted(obs.values())\\r\\n # The relation between otu ids and clusters is abitrary, and\\r\\n # is not stable due to use of dicts when parsing clusters -- therefore\\r\\n # just checks that we have the expected group of each\\r\\n self.assertEqual(obs_otu_ids, exp_otu_ids)\\r\\n self.assertEqual(obs_clusters, exp_clusters)\",\n \"def test_generated_sample_distribution(\\n jax_dist, sp_dist, params, N_sample=100_000, key=random.PRNGKey(11)\\n):\\n\\n if jax_dist not in [dist.Gumbel]:\\n pytest.skip(\\n \\\"{} sampling method taken from upstream, no need to\\\"\\n \\\"test generated samples.\\\".format(jax_dist.__name__)\\n )\\n\\n jax_dist = jax_dist(*params)\\n if sp_dist and not jax_dist.event_shape and not jax_dist.batch_shape:\\n our_samples = jax_dist.sample(key, (N_sample,))\\n ks_result = osp.kstest(our_samples, sp_dist(*params).cdf)\\n assert ks_result.pvalue > 0.05\",\n \"def analyze_sensitivity_sparse_grid(sparse_grid,max_order=2):\\n from pyapprox.multivariate_polynomials import \\\\\\n define_poly_options_from_variable_transformation\\n from pyapprox.adaptive_sparse_grid import \\\\\\n convert_sparse_grid_to_polynomial_chaos_expansion\\n pce_opts=define_poly_options_from_variable_transformation(\\n sparse_grid.variable_transformation)\\n pce = convert_sparse_grid_to_polynomial_chaos_expansion(\\n sparse_grid,pce_opts)\\n pce_main_effects,pce_total_effects=\\\\\\n get_main_and_total_effect_indices_from_pce(\\n pce.get_coefficients(),pce.get_indices())\\n\\n interaction_terms, pce_sobol_indices = get_sobol_indices(\\n pce.get_coefficients(),pce.get_indices(),max_order=max_order)\\n \\n return SensivitityResult(\\n {'main_effects':pce_main_effects,\\n 'total_effects':pce_total_effects,\\n 'sobol_indices':pce_sobol_indices,\\n 'sobol_interaction_indices':interaction_terms,\\n 'pce':pce})\",\n \"def test_st_facets00201m11_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/SType/ST_facets/ST_facets00201m/ST_facets00201m11.xsd\\\",\\n instance=\\\"sunData/SType/ST_facets/ST_facets00201m/ST_facets00201m11_p.xml\\\",\\n class_name=\\\"Test\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def test_index_12(self):\\n self.insert()\\n data = self.tbl[2:6]\\n assert self.check(self.idata[:2], data)\",\n \"def test_st_facets00401m20_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m20.xsd\\\",\\n instance=\\\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m20_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def __init__(self, mode=KSamplingModes.monkhorst, num_kpts= 0,\\n kpts=((1, 1, 1),),\\n kpt_shifts=(0.5, 0.5, 0.5),\\n kpts_weights=None, use_symmetries=True, use_time_reversal=True, chksymbreak=None,\\n comment=None):\\n if isinstance(mode, str):\\n mode = KSamplingModes[mode]\\n\\n super(KSampling, self).__init__()\\n\\n self.mode = mode\\n self.comment = comment\\n\\n self.num_kpts = num_kpts\\n self.kpts = kpts\\n self.kpt_shifts = kpt_shifts\\n self.kpts_weights = kpts_weights\\n self.use_symmetries = use_symmetries\\n self.use_time_reversal = use_time_reversal\\n self.chksymbreak = chksymbreak\\n\\n abivars = {}\\n\\n if mode == KSamplingModes.monkhorst:\\n assert num_kpts == 0\\n ngkpt = np.reshape(kpts, 3)\\n shiftk = np.reshape(kpt_shifts, (-1,3))\\n\\n if use_symmetries and use_time_reversal: kptopt = 1\\n if not use_symmetries and use_time_reversal: kptopt = 2\\n if not use_symmetries and not use_time_reversal: kptopt = 3\\n if use_symmetries and not use_time_reversal: kptopt = 4\\n\\n abivars.update({\\n \\\"ngkpt\\\" : ngkpt,\\n \\\"shiftk\\\" : shiftk,\\n \\\"nshiftk\\\" : len(shiftk),\\n \\\"kptopt\\\" : kptopt,\\n \\\"chksymbreak\\\": chksymbreak,\\n })\\n\\n elif mode == KSamplingModes.path:\\n if num_kpts <= 0:\\n raise ValueError(\\\"For Path mode, num_kpts must be specified and >0\\\")\\n\\n kptbounds = np.reshape(kpts, (-1,3))\\n #print(\\\"in path with kptbound: %s \\\" % kptbounds)\\n\\n abivars.update({\\n \\\"ndivsm\\\" : num_kpts,\\n \\\"kptbounds\\\": kptbounds,\\n \\\"kptopt\\\" : -len(kptbounds)+1,\\n })\\n\\n elif mode == KSamplingModes.automatic:\\n kpts = np.reshape(kpts, (-1,3))\\n if len(kpts) != num_kpts:\\n raise ValueError(\\\"For Automatic mode, num_kpts must be specified.\\\")\\n\\n abivars.update({\\n \\\"kptopt\\\" : 0,\\n \\\"kpt\\\" : kpts,\\n \\\"nkpt\\\" : num_kpts,\\n \\\"kptnrm\\\" : np.ones(num_kpts),\\n \\\"wtk\\\" : kpts_weights, # for iscf/=-2, wtk.\\n \\\"chksymbreak\\\": chksymbreak,\\n })\\n\\n else:\\n raise ValueError(\\\"Unknown mode %s\\\" % mode)\\n\\n self.abivars = abivars\\n #self.abivars[\\\"#comment\\\"] = comment\",\n \"def test_calc_mode():\\r\\n lamb = 1.8e-6\\r\\n radius = 50e-6\\r\\n num_points = 50\\r\\n x = np.linspace(-1, 1, num_points) * radius\\r\\n y = np.linspace(-1, 1, num_points)[:, None] * radius\\r\\n r = (x ** 2 + y ** 2) ** 0.5\\r\\n theta = np.arctan2(x, y)\\r\\n dA = (x[1] - x[0]) * (y[1, 0] - y[0, 0])\\r\\n ##\\r\\n M = 5\\r\\n N = 3\\r\\n fields = []\\r\\n for m in np.arange(1, M + 1):\\r\\n for n in np.arange(-N, N + 1):\\r\\n for theta0 in (0, np.pi / 2):\\r\\n fields.append(hc.calc_mode(1.5, radius, n, m, lamb, r, theta, dA, theta0))\\r\\n rows = []\\r\\n for f1 in fields:\\r\\n row = []\\r\\n for f2 in fields:\\r\\n row.append(hc.calc_mode_overlap(f1, f2, dA))\\r\\n rows.append(row)\\r\\n overlap = np.array(rows)\",\n \"def test_st_facets00501m6_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/SType/ST_facets/ST_facets00501m/ST_facets00501m6.xsd\\\",\\n instance=\\\"sunData/SType/ST_facets/ST_facets00501m/ST_facets00501m6_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def testVerySmallClusters(input_img, input_mode, min_rad=7.5):\\n\\n if input_mode == 'fp':\\n np_img = loadImage(input_img)\\n elif input_mode == 'np':\\n np_img = input_img\\n else:\\n return (input_mode, \\\" is not a supported mode. Supported modes are 'np' or 'fp'.\\\")\\n dim = np_img.shape\\n if dim[0] <= dim[1]:\\n length = dim[0]\\n else:\\n length = dim[1]\\n if length/2. < min_rad:\\n return True\\n else:\\n return False\",\n \"def test_st_facets00505m6_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/SType/ST_facets/ST_facets00505m/ST_facets00505m6.xsd\\\",\\n instance=\\\"sunData/SType/ST_facets/ST_facets00505m/ST_facets00505m6_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def test_st_facets00124m1_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/SType/ST_facets/ST_facets00124m/ST_facets00124m1.xsd\\\",\\n instance=\\\"sunData/SType/ST_facets/ST_facets00124m/ST_facets00124m1_p.xml\\\",\\n class_name=\\\"Test\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def knn(p, k, x, t):\\r\\n\\r\\n # Number of instances in data set\\r\\n N = x.shape[0]\\r\\n\\r\\n Euclidean_Distance = numpy.square(x - p) #Euclidean distance\\r\\n dis = numpy.sum(Euclidean_Distance, axis=1) #sum of the euclidean distance\\r\\n inds = numpy.argsort(dis)[:k] #sort the indices of the distance array\\r\\n tgt_cat = Counter([t[i] for i in inds]) #count the times of equivalent target labels\\r\\n top_class = max(tgt_cat, key= tgt_cat.get) #top class among the k nearest points\\r\\n\\r\\n\\r\\n #top_class = 0\\r\\n\\r\\n return top_class\",\n \"def pkscore(labels, preds, k=10):\\n # Remove padding from labels and preds\\n mask = np.where(labels<=1, True, False)\\n labels = labels[mask]\\n preds = preds[mask]\\n\\n num_windows = len(labels) - k + 1\\n assert num_windows>0, 'Choose a smaller k value'\\n\\n correct = 0\\n for i in range(num_windows):\\n # calculate index of window close\\n j = i + k\\n\\n # Get number of segment splits in labels and preds\\n label_diff = sum(labels[i:j])\\n pred_diff = sum(preds[i:j])\\n\\n # Check for agreement between labels and preds\\n if (label_diff and pred_diff) or (not label_diff and not pred_diff):\\n correct += 1\\n return 1-(correct/(num_windows))\",\n \"def test_fast_denoiser(self):\\r\\n\\r\\n actual_centroids, actual_otu_map = fast_denoiser(\\r\\n [self.sff_path2], self.seq_path, self.tmp_out_dir,\\r\\n num_cpus=1, primer=\\\"YATGCTGCCTCCCGTAGGAGT\\\", verbose=False)\\r\\n\\r\\n actual = list(actual_centroids)\\r\\n self.assertEqual(actual, expected_centroids)\\r\\n # centroids are sorted, so first one should be unique\\r\\n #(all others have cluster size 1, so relative ordering is not guaranteed\\r\\n self.assertEqual(actual[0], expected_centroids[0])\\r\\n self.assertEqual(actual_otu_map, expected_otu_map)\",\n \"def test_jaccard_index():\\n vector1 = np.array([1, 1, 0, 0])\\n vector2 = np.array([1, 1, 1, 1])\\n score11 = jaccard_index.py_func(vector1, vector1)\\n score12 = jaccard_index.py_func(vector1, vector2)\\n score22 = jaccard_index.py_func(vector2, vector2)\\n\\n assert score12 == 2 / 4, \\\"Expected different score.\\\"\\n assert score11 == score22 == 1.0, \\\"Expected different score.\\\"\",\n \"def test_getitem_array(self):\\n random.seed(12345)\\n\\n nside_coverage = 32\\n nside_map = 128\\n\\n full_map = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\\n full_map[0: 5000] = random.random(size=5000)\\n\\n sparse_map = healsparse.HealSparseMap(healpix_map=full_map, nside_coverage=nside_coverage)\\n\\n indices = np.array([1, 2, 100, 500, 10000])\\n testing.assert_array_almost_equal(sparse_map[indices], full_map[indices])\\n testing.assert_almost_equal(sparse_map[indices[0]], full_map[indices[0]])\\n\\n indices = np.array([1., 2, 100, 500, 10000])\\n self.assertRaises(IndexError, sparse_map.__getitem__, indices)\\n self.assertRaises(IndexError, sparse_map.__getitem__, indices[0])\",\n \"def build_k_indices(y, k_fold, seed):\\n num_rows = y.shape[0]\\n interval = int(num_rows / k_fold)\\n np.random.seed(seed)\\n indices = np.random.permutation(num_rows)\\n k_indices = [indices[k * interval: (k + 1) * interval] for k in range(k_fold)]\\n return np.array(k_indices)\",\n \"def test_st_facets00501m10_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/SType/ST_facets/ST_facets00501m/ST_facets00501m10.xsd\\\",\\n instance=\\\"sunData/SType/ST_facets/ST_facets00501m/ST_facets00501m10_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def testSubset(df, fullIndex, indexCol, members, gbCol='Stimulus', gbValues=None, countCol='Cells', min_count=7, nsamps=None, rseed=110820):\\n\\n if gbValues is None:\\n gbValues = sorted(df[gbCol].unique())\\n cnts = df.groupby([indexCol, gbCol])[countCol].agg(np.sum).unstack(gbCol, fill_value=0)[gbValues]\\n cnts = cnts.reindex(fullIndex, axis=0, fill_value=0)\\n resDf = testHClusters(cnts, members, gbValues, min_count=min_count)\\n \\n if not nsamps is None:\\n \\\"\\\"\\\"Preliminarily, permutation-based p-values have correlated perfectly\\n with the analytic p-values\\\"\\\"\\\"\\n np.random.seed(rseed)\\n rtmp = df.copy()\\n rchi2 = np.zeros((resDf.shape[0], nsamps))\\n rpvalue = np.zeros((resDf.shape[0], nsamps))\\n for sampi in range(nsamps):\\n rtmp.loc[:, gbCol] = rtmp[gbCol].values[np.random.permutation(rtmp.shape[0])]\\n rcnts = rtmp.groupby([indexCol, gbCol])['Cells'].agg(np.sum).unstack(gbCol, fill_value=0)\\n rcnts = rcnts.reindex(fullIndex, axis=0, fill_value=0)\\n rres = testHClusters(rcnts, members, gbValues, min_count=min_count)\\n rchi2[:, sampi] = rres['chi2']\\n rpvalue[:, sampi] = rres['pvalue']\\n ppvalue = ((rpvalue <= resDf['pvalue'].values[:, None]).sum(axis=1) + 1) / (nsamps + 1)\\n pchi2 = ((rchi2 <= resDf['chi2'].values[:, None]).sum(axis=1) + 1) / (nsamps + 1)\\n ppvalue[np.isnan(resDf['chi2'].values)] = np.nan\\n pchi2[np.isnan(resDf['chi2'].values)] = np.nan\\n resDf = resDf.assign(**{'Perm P-pvalue':ppvalue, 'Perm Chi2-pvalue':pchi2})\\n\\n return resDf\",\n \"def test_st_facets00401m12_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m12.xsd\\\",\\n instance=\\\"sunData/SType/ST_facets/ST_facets00401m/ST_facets00401m12_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67841566","0.57195204","0.5679095","0.5437452","0.53641367","0.53341633","0.5320182","0.5270428","0.5263456","0.52053756","0.51995933","0.5183746","0.51783615","0.51379323","0.51002336","0.5085314","0.5072776","0.50716794","0.50716245","0.50713897","0.5045924","0.5026655","0.49762145","0.4969926","0.49686092","0.49567515","0.4950477","0.4938627","0.49321547","0.49121737","0.49075222","0.4889425","0.4876776","0.48752806","0.48611644","0.4850888","0.4834377","0.48266083","0.48233914","0.4821674","0.48104897","0.48100019","0.4804719","0.48036537","0.4801095","0.47987393","0.4792642","0.47921786","0.47916925","0.47882745","0.47877258","0.4787258","0.4785868","0.47774342","0.4776482","0.47705927","0.4769898","0.47672412","0.47576368","0.47563586","0.47525582","0.47432014","0.47403514","0.4737468","0.47366118","0.47311392","0.4728838","0.47256446","0.472558","0.47241244","0.4720981","0.47197878","0.47181305","0.4715372","0.4708402","0.4707518","0.4706984","0.4689973","0.46878627","0.4686894","0.46857566","0.4681079","0.46808368","0.46806043","0.46805257","0.4678387","0.46751186","0.46735144","0.4669154","0.46682155","0.46676275","0.4667174","0.4666947","0.46643203","0.46611533","0.46611226","0.466015","0.46566346","0.46537897","0.4651451"],"string":"[\n \"0.67841566\",\n \"0.57195204\",\n \"0.5679095\",\n \"0.5437452\",\n \"0.53641367\",\n \"0.53341633\",\n \"0.5320182\",\n \"0.5270428\",\n \"0.5263456\",\n \"0.52053756\",\n \"0.51995933\",\n \"0.5183746\",\n \"0.51783615\",\n \"0.51379323\",\n \"0.51002336\",\n \"0.5085314\",\n \"0.5072776\",\n \"0.50716794\",\n \"0.50716245\",\n \"0.50713897\",\n \"0.5045924\",\n \"0.5026655\",\n \"0.49762145\",\n \"0.4969926\",\n \"0.49686092\",\n \"0.49567515\",\n \"0.4950477\",\n \"0.4938627\",\n \"0.49321547\",\n \"0.49121737\",\n \"0.49075222\",\n \"0.4889425\",\n \"0.4876776\",\n \"0.48752806\",\n \"0.48611644\",\n \"0.4850888\",\n \"0.4834377\",\n \"0.48266083\",\n \"0.48233914\",\n \"0.4821674\",\n \"0.48104897\",\n \"0.48100019\",\n \"0.4804719\",\n \"0.48036537\",\n \"0.4801095\",\n \"0.47987393\",\n \"0.4792642\",\n \"0.47921786\",\n \"0.47916925\",\n \"0.47882745\",\n \"0.47877258\",\n \"0.4787258\",\n \"0.4785868\",\n \"0.47774342\",\n \"0.4776482\",\n \"0.47705927\",\n \"0.4769898\",\n \"0.47672412\",\n \"0.47576368\",\n \"0.47563586\",\n \"0.47525582\",\n \"0.47432014\",\n \"0.47403514\",\n \"0.4737468\",\n \"0.47366118\",\n \"0.47311392\",\n \"0.4728838\",\n \"0.47256446\",\n \"0.472558\",\n \"0.47241244\",\n \"0.4720981\",\n \"0.47197878\",\n \"0.47181305\",\n \"0.4715372\",\n \"0.4708402\",\n \"0.4707518\",\n \"0.4706984\",\n \"0.4689973\",\n \"0.46878627\",\n \"0.4686894\",\n \"0.46857566\",\n \"0.4681079\",\n \"0.46808368\",\n \"0.46806043\",\n \"0.46805257\",\n \"0.4678387\",\n \"0.46751186\",\n \"0.46735144\",\n \"0.4669154\",\n \"0.46682155\",\n \"0.46676275\",\n \"0.4667174\",\n \"0.4666947\",\n \"0.46643203\",\n \"0.46611533\",\n \"0.46611226\",\n \"0.466015\",\n \"0.46566346\",\n \"0.46537897\",\n \"0.4651451\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7882716"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83164,"cells":{"query":{"kind":"string","value":"Test KS test for insertion indices with undefined mode"},"document":{"kind":"string","value":"def test_ks_test_undefined_mode():\n indices = np.random.randint(0, 1000, 1000)\n with pytest.raises(RuntimeError):\n compute_indices_ks_test(indices, 1000, mode=\"two-sided\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_ks_test(mode):\n indices = np.random.randint(0, 1000, 1000)\n out = compute_indices_ks_test(indices, 1000, mode=mode)\n assert all([o > 0.0 for o in out])","def test_ks_test_empty_indices():\n out = compute_indices_ks_test([], 1000, mode=\"D+\")\n assert all(o is None for o in out)","def _assert_ks_postformat(self):\n if type(self.idxs) in [list, np.ndarray]:\n if self.ks is None:\n if self.staticneighs:\n pass\n else:\n self.ks = range(len(self.idxs))\n if self.staticneighs:\n pass\n else:\n# print self.ks, self.idxs, self.set_neighs, self.set_sp_rel_pos\n assert(len(self.ks) == len(self.idxs))\n ## Defining functions\n if self.sp_relative_pos is not None and self.staticneighs:\n self.get_sp_rel_pos = self._static_get_rel_pos\n elif not self.staticneighs:\n if type(self.sp_relative_pos) == list:\n self.get_sp_rel_pos = self._dynamic_rel_pos_list\n else:\n self.get_sp_rel_pos = self._dynamic_rel_pos_array\n if self.sp_relative_pos is None:\n self.set_sp_rel_pos = self._null_set_rel_pos\n self.get_sp_rel_pos = self._null_get_rel_pos\n ## Ensure correct k_ret\n if np.max(self.ks) > self._kret:\n self._kret = np.max(self.ks)","def test_k_rank_approximate(corpus):\n return","def test_k_index():\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\n 400.]) * units.hPa\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\n -23.5]) * units.degC\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\n -57.5]) * units.degC\n ki = k_index(pressure, temperature, dewpoint)\n assert_almost_equal(ki, 33.5 * units.degC, 2)","def check_k_anonymity(data: np.ndarray, k: int, qi_indices=None):\n print(Counter(str(e) for e in data[:, qi_indices]))\n\n occurrences = list(Counter(str(e) for e in data[:, qi_indices]).values())\n for j in range(len(occurrences)):\n if occurrences[j] < k:\n return False\n return True","def test_single_run(self):\n\n traces = np.load('data/traces.npy')\n keys = np.load('data/key.npy')\n plain = np.load('data/plain.npy')\n correct_indices = [4254, 4257, 1400, 4429, 4919, 1399, 4918, 1398, 4917, 1397]\n\n indices = SOSTD.list_of_best_indices(traces, keys, plain, 10, 0)\n self.assertTrue(np.array_equal(indices, correct_indices))","def test_sparse():\n\n rng = np.random.RandomState(0)\n\n X = rng.rand(20, 2)\n X[X < 0.8] = 0\n X_csr = sp.csr_matrix(X)\n\n bisect_means = BisectingKMeans(n_clusters=3, random_state=0)\n\n bisect_means.fit(X_csr)\n sparse_centers = bisect_means.cluster_centers_\n\n bisect_means.fit(X)\n normal_centers = bisect_means.cluster_centers_\n\n # Check if results is the same for dense and sparse data\n assert_allclose(normal_centers, sparse_centers, atol=1e-8)","def test_k_index_xarray(index_xarray_data):\n result = k_index(index_xarray_data.isobaric, index_xarray_data.temperature,\n index_xarray_data.dewpoint)\n assert_array_almost_equal(result,\n np.array([[[312., 311., 310.], [309., 308., 307.]]]) * units.K)","def main_eaftest(point_ind, permutations=10240, alpha=0.05):\n \n # ------ Attainment indicator values information ------\n \n npoints = len(point_ind)\n nvars = len(point_ind[0]) # Número de execuções total\n nruns = nvars // 2 # Número de execuções de 1 algo\n \n print \"- Attainment indicator values information:\"\n print \" * Number of points:\", npoints\n print \" * Joint executions:\", nvars, \"(%d + %d)\" % (nruns, nruns)\n print\n \n assert nvars % 2 == 0, \"Number of total joint executions must be even.\"\n assert nvars <= 64, \"Not implemented with more than 64 joint executions.\"\n \n # ------ Test Statistic ------\n\n print \"- Computing the test statistic...\" \n stat2 = libaft.ksstat(point_ind, order=2)\n print \" * Test statistic = %d/%d\" % (stat2, nruns)\n print \" = %f\" % (stat2 / float(nruns)), '\\n'\n \n # ------ Estimate null distribution ------\n\n print \"- Using %d random permutations to estimate null distribution.\" % permutations\n print \" Please be patient...\"\n maxdist = np.zeros(permutations, dtype=np.int32) # Max distance array\n rtime = time.time()\n \n masks = bintools.make_masks(permutations, nvars, seed=64)\n for i, maxd in enumerate(KERNEL.runkernel(point_ind, masks)):\n maxdist[i] = maxd\n if (i+1) % (permutations//20) == 0:\n print \" %6d permutations, %7.3f sec\" % (i+1, time.time()-rtime)\n print \" * Time elapsed: %7.3f\" % (time.time()-rtime)\n \n # Compute null distribution from max distance array\n tail = np.bincount(maxdist, minlength=nruns+1)\n print \" * Non-normalized null distribution:\"\n print tail\n print\n \n # ------ Accept/reject null hypothesis ------\n \n # NB: -1 resulta das diferentes convenções para a definição de valor crítico\n crit = criticalvalue(tail, alpha * permutations) - 1\n pval = pvalue(tail, stat2) / float(permutations)\n \n print \"- Null hypothesis decision:\" \n print \" * Critical value = %d/%d\" % (crit, nruns)\n print \" = %f\" % (crit / float(nruns))\n print \" * p-value = %f\" % pval\n if pval <= alpha:\n print \" <= alpha (%s)\\n\" % alpha\n print \" * Decision: REJECT the null hypothesis\"\n else:\n print \" > alpha (%s)\\n\" % alpha\n print \" * Decision: do NOT REJECT the null hypothesis\"\n print","def test_single_run_sosd(self):\n\n traces = np.load('data/traces.npy')[:1000]\n keys = np.load('data/key.npy')[:1000]\n plain = np.load('data/plain.npy')[:1000]\n correct_indices = [4371, 2401, 2402, 4878, 4370, 4877, 4882, 4369, 4881, 2723]\n\n indices = SOSTD.list_of_best_indices(traces, keys, plain, 10, 0, False)\n self.assertTrue(np.array_equal(indices, correct_indices))","def test_key_predicate(datum):\n return 0 < datum","def test_eigenvalues_of_too_few_points_results_in_0():\n a = np.array([5])\n pc = create_point_cloud(a, a, a)\n\n compute_features(pc, [[0]], pc, [\"eigenv_1\", \"eigenv_2\", \"eigenv_3\"], InfiniteCylinder(5))\n\n eigen_val_123 = np.array([pc[keys.point]['eigenv_{}'.format(i)]['data'] for i in [1, 2, 3]])\n assert not np.any(np.isnan(eigen_val_123))\n assert not np.any(np.isinf(eigen_val_123))","def ks_test(timeseries):\r\n\r\n hour_ago = time() - 3600\r\n ten_minutes_ago = time() - 600\r\n reference = scipy.array([x[1] for x in timeseries if x[0] >= hour_ago and x[0] < ten_minutes_ago])\r\n probe = scipy.array([x[1] for x in timeseries if x[0] >= ten_minutes_ago])\r\n\r\n if reference.size < 20 or probe.size < 20:\r\n return False\r\n\r\n ks_d,ks_p_value = scipy.stats.ks_2samp(reference, probe)\r\n\r\n if ks_p_value < 0.05 and ks_d > 0.5:\r\n adf = sm.tsa.stattools.adfuller(reference, 10)\r\n if adf[1] < 0.05:\r\n return True\r\n\r\n return False","def skip_test(n):\n return k > 0 and magic * n * k**0.5 >= t4_ref","def ks_test_function(dim, thresh):\n def ks_test(table1, table2):\n from scipy.stats import ks_2samp\n sample1 = table1.get_cols(dim)[0]\n sample2 = table2.get_cols(dim)[0]\n if thresh != None:\n sample1[sample1<thresh] = 0\n sample2[sample2<thresh] = 0\n ks, p_ks = ks_2samp(sample1, sample2)\n return ks\n return ks_test","def test_k(self):\n\n # We have a new K. It should have nothing in it.\n loc_, sloc_, test_loc, test_sloc = self.k__.get_totals()\n self.assertEqual(loc_, 0)\n self.assertEqual(sloc_, 0)\n self.assertEqual(test_loc, 0)\n self.assertEqual(test_sloc, 0)\n\n self.check_counts('zz', 0, 0, 0, 0) # not in map\n self.check_counts('py', 0, 0, 0, 0) # not in map\n\n self.k__.add_counts('py', 7, 3)\n self.check_counts('py', 7, 3, 0, 0)\n self.k__.add_counts('py', 5, 2)\n self.check_counts('py', 12, 5, 0, 0)\n\n self.k__.add_test_counts('py', 8, 4)\n self.check_counts('py', 12, 5, 8, 4)\n self.k__.add_test_counts('py', 9, 3)\n self.check_counts('py', 12, 5, 17, 7)\n\n expected = \"py:%d/%d T%.1f%%\" % (12 + 17, 5 + 7, 700.0 / 12)\n # DEBUG\n # print(\"Expected: %s\" % expected)\n # END\n self.assertEqual(self.k__.pretty_counts('py'), expected)","def test_optimalk_cluster_array_values_error():\n from sklearn.datasets.samples_generator import make_blobs\n from gap_statistic import OptimalK\n\n # Create optimalK instance\n optimalK = OptimalK(parallel_backend=None, n_jobs=-1)\n\n # Create data\n X, y = make_blobs(n_samples=int(1e3), n_features=2, centers=3)\n\n with pytest.raises(ValueError) as excinfo:\n optimalK(X, cluster_array=[0, -1, 1, 2, 3])\n assert 'cluster_array contains values less than 1' in str(excinfo.value)","def test_sparsity_topk_mask_dykstra(self, l=1e-2):\n n = int(1e3)\n seed = np.random.RandomState(0)\n y = jnp.array(seed.randn(n))\n k = 10\n out_top_k_dykstra = sparse_soft_topk_mask_dykstra(y, k, l=l)\n self.assertAlmostEqual(\n y.argsort()[::-1][:k].sort().sum(),\n out_top_k_dykstra.argsort()[::-1][:k].sort().sum(),\n )\n self.assertAlmostEqual(len(jnp.where(out_top_k_dykstra > 0)[0]), k)","def test_fast_denoiser(self):\r\n\r\n actual_centroids, actual_otu_map = fast_denoiser(\r\n [self.sff_path2], self.seq_path, self.tmp_out_dir,\r\n num_cpus=1, primer=\"YATGCTGCCTCCCGTAGGAGT\", verbose=False)\r\n\r\n actual = list(actual_centroids)\r\n self.assertEqual(actual, expected_centroids)\r\n # centroids are sorted, so first one should be unique\r\n #(all others have cluster size 1, so relative ordering is not guaranteed\r\n self.assertEqual(actual[0], expected_centroids[0])\r\n self.assertEqual(actual_otu_map, expected_otu_map)","def test_determine_k(self):\n test_dir_name = os.path.dirname(__file__)\n feat_array_fn = os.path.join(\n test_dir_name, \"data\", \"four_clusters.csv\")\n df = pd.read_csv(feat_array_fn)\n feat_array = df[[\"x\", \"y\"]].values\n\n clusterer = Clusterer(feat_array_fn, \"/dev/null\", [])\n best_k = clusterer._determine_k(feat_array, 9)\n\n self.assertEqual(best_k, 4)\n\n feat_array_fn = os.path.join(\n test_dir_name, \"data\", \"iris.csv\")\n df = pd.read_csv(feat_array_fn)\n feat_array = df[[\n \"Sepal.Length\", \"Sepal.Width\", \"Petal.Length\",\n \"Petal.Width\"]].values\n\n clusterer = Clusterer(feat_array_fn, \"/dev/null\", [])\n best_k = clusterer._determine_k(feat_array, 9)\n\n self.assertEqual(best_k, 2)","def chi2sf_inplace(x, k):","def test_jw_sparse_index(self):\n expected = [1, 2]\n calculated_indices = jw_number_indices(1, 2)\n self.assertEqual(expected, calculated_indices)\n\n expected = [3]\n calculated_indices = jw_number_indices(2, 2)\n self.assertEqual(expected, calculated_indices)","def test_optimalk_cluster_array_empty_error():\n from sklearn.datasets.samples_generator import make_blobs\n from gap_statistic import OptimalK\n\n # Create optimalK instance\n optimalK = OptimalK(parallel_backend=None, n_jobs=-1)\n\n # Create data\n X, y = make_blobs(n_samples=int(1e3), n_features=2, centers=3)\n\n with pytest.raises(ValueError) as excinfo:\n optimalK(X, cluster_array=[])\n assert 'The supplied cluster_array has no values.' in str(excinfo.value)","def do_knn(x_data):\n return True","def test_index_stability(self, example_staypoints):\n sp = example_staypoints\n sp2, locs = sp.as_staypoints.generate_locations(\n method=\"dbscan\", epsilon=10, num_samples=2, distance_metric=\"haversine\", agg_level=\"user\"\n )\n assert sp.index.equals(sp2.index)","def test_index_start(self):\n sp_file = os.path.join(\"tests\", \"data\", \"geolife\", \"geolife_staypoints.csv\")\n sp = ti.read_staypoints_csv(sp_file, tz=\"utc\", index_col=\"id\", crs=\"epsg:4326\")\n\n # reproject to WGS_1984_UTM_Zone_49N\n sp = sp.to_crs(\"epsg:32649\")\n\n distance_metric_ls = [\"haversine\", \"euclidean\"]\n agg_level_ls = [\"dataset\", \"user\"]\n for distance_metric in distance_metric_ls:\n for agg_level in agg_level_ls:\n _, locations = sp.as_staypoints.generate_locations(\n method=\"dbscan\", epsilon=10, num_samples=1, distance_metric=distance_metric, agg_level=agg_level\n )\n assert (locations.index == np.arange(len(locations))).any()","def SSC_test():\n \n # generating data\n\n D = 40 # Dimension of ambient space\n k = 4 # Number of subspaces\n d = 1\n N = 90 # Number of points in subspaces\n # Generating N points in d dim. subspaces\n Xi = [np.random.randn(D, d).dot(np.random.randn(d, N))\n for _ in range(k)]\n X = np.concatenate(Xi, axis=1)\n\n # Generating the ground-truth for evaluating clustering results\n lbls = [i * np.ones([1, N]) for i in range(k)]\n s = np.concatenate(lbls, axis=1)\n r = 0 # Enter the projection dimension e.g. r = d*n, enter r = 0 to not project\n Cst = 0 # Enter 1 to use the additional affine constraint sum(c) == 1\n OptM = 'L1Noise' # OptM can be {'L1Perfect','L1Noise','Lasso','L1ED'}\n lmbda = 0.001 # Regularization parameter in 'Lasso' or the noise level for 'L1Noise'\n # Number of top coefficients to build the similarity graph, enter K=0 for using the whole coefficients\n K = 0 #max(d1, d2)\n if Cst == 1:\n K = d + 1 # For affine subspaces, the number of coefficients to pick is dimension + 1\n\n Xp = DataProjection(X, r, 'NormalProj')\n \n # testing clustering\n \n '''\n # using wrapper function\n Grps, sc = sparseSubspaceClustering(\n Xp.T, n, ground_truth=s, affine=Cst, OptM=OptM, lam=lmbda)\n Grps = BestMap(sc, Grps)\n Missrate = float(np.sum(sc != Grps)) / sc.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))\n '''\n \n '''\n # calling internal tools\n CMat = SparseCoefRecovery(Xp, Cst, OptM, lmbda)\n # Make small values 0\n eps = np.finfo(float).eps\n CMat[np.abs(CMat) < eps] = 0\n\n CMatC, sc, OutlierIndx, Fail = OutlierDetection(CMat, s)\n\n if Fail == False:\n CKSym = BuildAdjacency(CMatC, K)\n Grps = SpectralClustering(CKSym, n)\n Grps = BestMap(sc, Grps)\n Missrate = float(np.sum(sc != Grps)) / sc.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))\n else:\n print(\"Something failed\")\n '''\n \n labels, _, __ = KSubspaces(Xp.T, k, d)\n labels = BestMap(s, labels)\n Missrate = float(np.sum(s != labels)) / s.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))","def test_batch_missing_data():\n\n\n def fx(x, dt):\n F = np.array([[1, dt, 0, 0],\n [0, 1, 0, 0],\n [0, 0, 1, dt],\n [0, 0, 0, 1]], dtype=float)\n\n return np.dot(F, x)\n\n def hx(x):\n return np.array([x[0], x[2]])\n\n\n dt = 0.1\n points = MerweScaledSigmaPoints(4, .1, 2., -1)\n kf = UKF(dim_x=4, dim_z=2, dt=dt, fx=fx, hx=hx, points=points)\n\n\n kf.x = np.array([-1., 1., -1., 1])\n kf.P*=0.0001\n\n zs = []\n for i in range(20):\n z = np.array([i+randn()*0.1, i+randn()*0.1])\n zs.append(z)\n\n zs[2] = None\n Rs = [1]*len(zs)\n Rs[2] = None\n Ms, Ps = kf.batch_filter(zs)","def test_call_alt_threshold(self):\r\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\r\n\r\n exp = {0: ['cdhit_test_seqs_0'],\r\n 1: ['cdhit_test_seqs_1'],\r\n 2: ['cdhit_test_seqs_2'],\r\n 3: ['cdhit_test_seqs_3'],\r\n 4: ['cdhit_test_seqs_4'],\r\n 5: ['cdhit_test_seqs_5'],\r\n 6: ['cdhit_test_seqs_6', 'cdhit_test_seqs_8'],\r\n 7: ['cdhit_test_seqs_7'],\r\n 8: ['cdhit_test_seqs_9']}\r\n\r\n app = CdHitOtuPicker(params={'Similarity': 0.90})\r\n obs = app(self.tmp_seq_filepath1)\r\n self.assertEqual(obs, exp)","def test_jaccard_index_all_zeros():\n vector1 = np.array([0, 0, 0, 0])\n vector2 = np.array([1, 1, 1, 1])\n score11 = jaccard_index.py_func(vector1, vector1)\n score12 = jaccard_index.py_func(vector1, vector2)\n score22 = jaccard_index.py_func(vector2, vector2)\n\n assert score11 == score12 == 0.0, \"Expected different score.\"\n assert score22 == 1.0, \"Expected different score.\"","def test_jaccard_index_all_zeros_compiled():\n vector1 = np.array([0, 0, 0, 0])\n vector2 = np.array([1, 1, 1, 1])\n score11 = jaccard_index(vector1, vector1)\n score12 = jaccard_index(vector1, vector2)\n score22 = jaccard_index(vector2, vector2)\n\n assert score11 == score12 == 0.0, \"Expected different score.\"\n assert score22 == 1.0, \"Expected different score.\"","def Q8_test():\n dispo = [False, True, True, False]\n tab_dist = [[0, 4.123105625617661, 4.242640687119285, 4.47213595499958], [4.123105625617661, 0, 4.123105625617661, 7.810249675906654], [4.242640687119285, 4.123105625617661, 0, 5.0990195135927845], [4.47213595499958, 7.810249675906654, 5.0990195135927845, 0]]\n return 1 == indice(0, tab_dist, dispo)","def test_sparsity_topk_mag_dykstra(self, l=1e-3):\n n = int(1e3)\n seed = np.random.RandomState(0)\n y = jnp.array(seed.randn(n))\n k = 10\n out_top_k_dykstra = sparse_soft_topk_mag_dykstra(y, k, l=l)\n self.assertAlmostEqual(\n len(jnp.where(jnp.absolute(out_top_k_dykstra) > 0)[0]), k\n )","def sparse(n, k):\n z = np.zeros(n)\n for i in np.random.choice( np.arange(n), k, replace=None ): # supports of nonzero entries\n z[i] = np.random.randn()\n return z","def test_ks2x(self):\n D, Pval = ks_test(self.x1, self.x2)\n assert_allclose((D, Pval), (0.46, 3.801e-05), rtol=1e-4)\n D, Pval = ks_test(self.x1, self.x2, exact=False)\n assert_allclose((D, Pval), (0.46, 5.084e-05), rtol=1e-4)\n D, Pval = ks_test(self.x1, self.x2[:20])\n assert_allclose((D, Pval), (0.53, 0.0003576), rtol=1e-4)\n D, Pval = ks_test(self.x2[:20], self.x1)\n assert_allclose((D, Pval), (0.53, 0.0003576), rtol=1e-4)\n D, Pval = ks_test(self.x1[:20], self.x2)\n assert_allclose((D, Pval), (0.48, 0.001772), rtol=1e-3)\n D, Pval = ks_test(self.x1, self.x2, alt=\"greater\")\n assert_allclose((D, Pval), (0.46, 2.542e-05), rtol=1e-4)\n D, Pval = ks_test(self.x1, self.x2, alt=\"g\")\n assert_allclose((D, Pval), (0.46, 2.542e-05), rtol=1e-4)\n D, Pval = ks_test(self.x1, self.x2, alt=\"less\")\n assert_allclose((D, Pval), (6.9388939039072284e-18, 1.0), rtol=1e-4)\n D, Pval = ks_test(self.x2, self.x1, alt=\"l\")\n assert_allclose((D, Pval), (0.46, 2.542e-05), rtol=1e-4)","def test_ks2x(self):\n D, Pval = ks_test(self.x1, self.x2)\n self.assertFloatEqual((D, Pval), (0.46, 3.801e-05), eps=1e-4)\n D, Pval = ks_test(self.x1, self.x2, exact=False)\n self.assertFloatEqual((D, Pval), (0.46, 5.084e-05), eps=1e-4)\n D, Pval = ks_test(self.x1, self.x2[:20])\n self.assertFloatEqual((D,Pval), (0.53, 0.0003576), eps=1e-4)\n D, Pval = ks_test(self.x2[:20], self.x1)\n self.assertFloatEqual((D,Pval), (0.53, 0.0003576), eps=1e-4)\n D, Pval = ks_test(self.x1[:20], self.x2)\n self.assertFloatEqual((D,Pval), (0.48, 0.001772), eps=1e-4)\n D, Pval = ks_test(self.x1, self.x2, alt=\"greater\")\n self.assertFloatEqual((D,Pval), (0.46, 2.542e-05), eps=1e-4)\n D, Pval = ks_test(self.x1, self.x2, alt=\"g\")\n self.assertFloatEqual((D,Pval), (0.46, 2.542e-05), eps=1e-4)\n D, Pval = ks_test(self.x1, self.x2, alt=\"less\")\n self.assertFloatEqual((D,Pval), (6.9388939039072284e-18, 1.), eps=1e-4)\n D, Pval = ks_test(self.x2, self.x1, alt=\"l\")\n self.assertFloatEqual((D,Pval), (0.46, 2.542e-05), eps=1e-4)","def ks_test(t):\n data = {\n name: (\n [\n _ks_Z(t[name].values, t[t.columns[j]].values)\n for j in range(i + 1)\n ]\n + ([np.nan] * (len(t.columns) - 2 - i))\n )\n for i, name in enumerate(t.columns[1:])\n }\n idx = pd.Index(t.columns[:-1], name=\"K-S test Z\")\n return pd.DataFrame(data, index=idx)","def test_getitem_other(self):\n random.seed(12345)\n\n nside_coverage = 32\n nside_map = 128\n\n full_map = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\n full_map[0: 5000] = random.random(size=5000)\n\n sparse_map = healsparse.HealSparseMap(healpix_map=full_map, nside_coverage=nside_coverage)\n\n indices = (1, 2, 3, 4)\n self.assertRaises(IndexError, sparse_map.__getitem__, indices)\n\n indices = 5.0\n self.assertRaises(IndexError, sparse_map.__getitem__, indices)","def findknn(xTr,xTe,k):\n\n # YOUR CODE HERE\n if k > len(xTr):\n k = len(xTr)\n \n D=l2distance(xTe, xTr)\n (m,n) = D.shape\n \n indices = []\n dists = []\n for i in range(m):\n smallest_indices = np.argsort(D[i])\n ind = smallest_indices[:k]\n dis = D[i,smallest_indices[:k]]\n indices.append(ind)\n dists.append(dis)\n \n indices = np.transpose(np.array(indices))\n dists = np.transpose(np.array(dists))\n return indices, dists","def main():\n if len(sys.argv) != 5:\n exit(\"Usage: python oneta.py train-corpus test-corpus kernel-size output\")\n\n w1Words = dict()\n w2Words = dict()\n W1 = 0\n W2 = 0\n\n D1 = int(sys.argv[3])\n\n sys.stderr.write(\"First scan of training data\\n\")\n \n J = 0\n # Read through the corpus to decided which words are in the dense set and which in the sparse set\n corpus = open(sys.argv[1],\"r\")\n for line in corpus:\n tokens = word_tokenize(line)\n for token in tokens:\n tk_decoded = token.decode(\"utf-8\")\n if J < D1 and tk_decoded not in w1Words:\n w1Words[tk_decoded] = W1\n W1 += 1\n elif J >= D1 and tk_decoded not in w2Words:\n w2Words[tk_decoded] = W2\n W2 += 1\n J += 1\n corpus.close()\n\n D2 = J - D1\n\n # Partition the corpus into a L-shaped matrix\n sys.stderr.write(\"Building matrices\")\n At = lil_matrix((D1,W1))\n B = lil_matrix((W1,D2))\n Ct = lil_matrix((D2,W2))\n\n corpus = open(sys.argv[1],\"r\")\n\n j = 0\n for line in corpus:\n sys.stderr.write(\".\")\n tokens = word_tokenize(line)\n docsq = 0.\n for token in tokens:\n tk_decoded = token.decode(\"utf-8\")\n if j < D1: # tk_decoded in w1words\n tkId = w1Words[tk_decoded]\n docsq += (At[j,tkId]+1)**2 - (At[j,tkId])**2\n At[j,tkId] += 1.\n elif tk_decoded in w1Words:\n tkId = w1Words[tk_decoded]\n docsq += (B[tkId,j-D1]+1)**2 - (B[tkId,j-D1])**2\n B[tkId,j-D1] += 1.\n else:\n tkId = w2Words[tk_decoded]\n docsq += (Ct[j-D1,tkId]+1)**2 - (Ct[j-D1,tkId])**2\n Ct[j-D1,tkId] += 1.\n if j < D1:\n At[j,:] /= math.sqrt(docsq)\n else:\n for w in range(0,W1):\n B[w,j-D1] /= math.sqrt(docsq)\n Ct[j-D1,:] /= math.sqrt(docsq)\n j += 1\n\n sys.stderr.write(\"\\nBuild Cn\\n\")\n Cn = zeros((D2,1))\n Ct = Ct.tocsr()\n for i in range(0,D2):\n v = ((Ct[i,:] * Ct[i,:].transpose())[0,0])\n if v == 0:\n Cn[i,0] = 1.\n else:\n Cn[i,0] = v\n\n # Building real matrices\n sys.stderr.write(\"Calculating ATA\\n\")\n ATA = (At * At.transpose()).todense() # D1 x D1\n At = At.tocsr()\n B = B.tocsc()\n\n sys.stderr.write(\"Solve inverse\\n\")\n ATAi = linalg.inv(ATA)\n\n # The real calculation is that if we have input vector [ d_1 d_2 ] ^ T \n # We yield [ (A^T * A)^-1 * A^T ( d1^T - B * (C^T * d2 / Cn) ) (C^T * d2 / Cn)\n sys.stderr.write(\"Calculating projected vectors\\n\")\n\n out = open(sys.argv[4],\"w\")\n testDocs = open(sys.argv[2],\"r\")\n for testDoc in testDocs:\n sys.stderr.write(\".\")\n corpus = open(sys.argv[1],\"r\")\n d1 = zeros((W1,1))\n d2 = zeros((W2,1))\n tokens = word_tokenize(testDoc)\n for token in tokens:\n tk_decoded = token.decode(\"utf-8\")\n if tk_decoded in w1Words:\n d1[w1Words[tk_decoded],0] += 1\n elif tk_decoded in w2Words:\n d2[w2Words[tk_decoded],0] += 1\n norm = sqrt(sum(d1**2) + sum(d2**2))\n d1 /= norm \n d2 /= norm\n v2 = (Ct * d2) / Cn\n v1 = ATAi * (At * (d1 - B * v2))\n for j in range(0,D1+D2):\n out.write(str(j) + \" \")\n out.write(\"||| \")\n for j in range(0,D1):\n out.write(str(v1[j,0]) + \" \")\n for j in range(0,D2):\n out.write(str(v2[j,0]) + \" \")\n out.write(\"\\n\")\n\n out.flush()\n out.close()\n sys.stderr.write(\"\\n\")","def test_integer_map_key_index():\n\tlib.backup_and_restore(\n\t\tlambda context: create_indexes(lib.create_integer_map_key_index),\n\t\tNone,\n\t\tlambda context: check_indexes(lib.check_map_key_index, 12345)\n\t)","def check_k_matrix_stability(self):\r\n K = self.make_k_matrix()\r\n vals, vects = scipy_sparse_eigens(K)\r\n principal_val = vals.max()\r\n print(\"ht3_solver:\\t'Stiffness' matrix principal eigenvalue was \"\r\n + str(principal_val))\r\n if principal_val > 1:\r\n print(\"##########################################################\")\r\n print(\"ht3_solver:\\tWARNING\")\r\n print(\"ht3_solver:\\tPrincipal eigenvalue is more than one.\")\r\n print(\"ht3_solver:\\tThe analysis will be unstable.\")\r\n print(\"ht3_solver:\\tIf this is OK, just go and modify the code \"\r\n + \"or something.\")\r\n print(\"##########################################################\")\r\n raise(AssertionError)","def KS(self, using, dx=0.0001):\n pits = np.array(self.PIT(using=using,dx=dx))\n ks_result = skgof.ks_test(pits, stats.uniform())\n return ks_result.statistic, ks_result.pvalue","def test_fit_predict(is_sparse):\n rng = np.random.RandomState(0)\n\n X = rng.rand(10, 2)\n\n if is_sparse:\n X[X < 0.8] = 0\n X = sp.csr_matrix(X)\n\n bisect_means = BisectingKMeans(n_clusters=3, random_state=0)\n bisect_means.fit(X)\n\n assert_array_equal(bisect_means.labels_, bisect_means.predict(X))","def test_continuous():\n # assert the distribution of the samples is close to the distribution of the data\n # using kstest:\n # - uniform (assert p-value > 0.05)\n # - gaussian (assert p-value > 0.05)\n # - inversely correlated (assert correlation < 0)","def check_seed():\n np.random.seed(1000)\n standard = [\n {0: -3.0, 1: -5.0, 'index': 0},\n {0: -6.0, 1: -8.0, 'index': 1},\n {0: 5.0, 1: -1.0, 'index': 2},\n {0: 1.0, 1: -7.0, 'index': 3},\n {0: -2.0, 1: -3.0, 'index': 4},\n {0: 7.0, 1: 3.0, 'index': 5},\n {0: -4.0, 1: -2.0, 'index': 6},\n {0: 2.0, 1: 6.0, 'index': 7}\n ]\n\n this_machine = create_points(8)\n\n flag = True\n for i in range(8) :\n flag &= this_machine[i][0] == standard[i][0] \n flag &= this_machine[i][1] == standard[i][1] \n flag &= this_machine[i][\"index\"] == i\n \n if not flag :\n print(\"\"\"\n The Python installation on this machine is odd: it appears to\n use a non-standard random number generator -- run \n this script on the machines in the Otter lab instead.\n If that fails too, send an email to ag0015@surrey.ac.uk.\n \"\"\")\n print (\"You got these test points:\", this_machine)\n print (\"You should have got:\", standard)\n exit(-1)\n else :\n print (\"Check passed\")","def assert_stored_ks(self):\n assert(self.ks is None or type(self.ks) in [list, np.ndarray])\n if self.ks is not None:\n assert(type(self.ks[0]) in inttypes)","def test_call_low_cluster_identity(self):\r\n\r\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\r\n # Should only get 6 clusters\r\n exp_otu_ids = [str(x) for x in range(6)]\r\n\r\n exp_clusters =\\\r\n [['uclust_test_seqs_0', 'uclust_test_seqs_6',\r\n 'uclust_test_seqs_9'], ['uclust_test_seqs_1'], ['uclust_test_seqs_2'],\r\n ['uclust_test_seqs_3',\r\n 'uclust_test_seqs_5',\r\n 'uclust_test_seqs_8'],\r\n ['uclust_test_seqs_4'], ['uclust_test_seqs_7']]\r\n\r\n app = UsearchOtuPicker(params={'save_intermediate_files': False,\r\n 'db_filepath': self.tmp_ref_database,\r\n 'output_dir': self.temp_dir,\r\n 'remove_usearch_logs': True,\r\n 'reference_chimera_detection': False,\r\n 'de_novo_chimera_detection': False,\r\n 'cluster_size_filtering': False,\r\n 'minlen': 12,\r\n 'w': 12,\r\n 'minsize': 1,\r\n 'percent_id': 0.80,\r\n 'percent_id_err': 0.97\r\n })\r\n\r\n obs = app(self.tmp_seq_filepath1)\r\n\r\n obs_otu_ids = sorted(obs.keys())\r\n obs_clusters = sorted(obs.values())\r\n # The relation between otu ids and clusters is abitrary, and\r\n # is not stable due to use of dicts when parsing clusters -- therefore\r\n # just checks that we have the expected group of each\r\n self.assertEqual(obs_otu_ids, exp_otu_ids)\r\n self.assertEqual(obs_clusters, exp_clusters)","def test_full_house_flush_ind(self):","def _test_once(self, data, alpha):\n target_index, value = self._target(data)\n\n g = value / data.std()\n g_test = self._get_g_test(data, alpha)\n return target_index if g > g_test else None","def test_missing_indices():\n\n data = pd.read_csv(\n \"https://raw.githubusercontent.com/facebook/prophet/main/examples/example_wp_log_peyton_manning.csv\"\n )\n data[\"ds\"] = pd.to_datetime(data[\"ds\"])\n data.set_index(\"ds\", inplace=True)\n data.index = data.index.to_period(\"D\")\n data.info()\n\n exp = TSForecastingExperiment()\n\n with pytest.raises(ValueError) as errmsg:\n exp.setup(data=data, fh=365, session_id=42)\n exceptionmsg = errmsg.value.args[0]\n\n assert \"Data has missing indices!\" in exceptionmsg","def check_and_get_unresected_point(resected_kpt_idx, match, resected_idx, unresected_idx):\n if resected_idx < unresected_idx:\n if resected_kpt_idx == match.queryIdx:\n unresected_kpt_idx = match.trainIdx\n success = True\n return unresected_kpt_idx, success\n else:\n return None, False\n elif unresected_idx < resected_idx:\n if resected_kpt_idx == match.trainIdx:\n unresected_kpt_idx = match.queryIdx\n success = True\n return unresected_kpt_idx, success\n else:\n return None, False","def test_no_spike_after_table(self):\n n = 5\n dt = 1.0\n t_max = 2*dt\n # make sure we have spikes at the end\n table = np.ones((1, n))\n\n G = TableSpikers(n)\n G.spike_table = table\n\n sim = simulation.Simulation(G, dt=dt)\n sim.run(t_max)\n \n self.assertFalse(np.any(G.spike))","def test_k_1(self):\n knn = KNeighborsClassifier(n_neighbors=1)\n knn.fit(X_train, y_train)\n prediction = knn.predict(X_test)\n\n knn2 = Knn(n_neighbors=1)\n knn2.fit(X_train, y_train)\n prediction2 = knn2.predict(X_test)\n\n assert np.alltrue(prediction == prediction2), \"Error testing knn with k=1\"","def test_kernel(binary_matrix, result):\n\n # get the kernel from the gaussian elimination.\n pivots = (binary_matrix.T != 0).argmax(axis=0)\n nonpivots = np.setdiff1d(range(len(binary_matrix[0])), pivots)\n\n kernel = []\n for col in nonpivots:\n col_vector = binary_matrix[:, col]\n null_vector = np.zeros((binary_matrix.shape[1]), dtype=int)\n null_vector[col] = 1\n for i in pivots:\n first_entry = np.where(binary_matrix[:, i] == 1)[0][0]\n if col_vector[first_entry] == 1:\n null_vector[i] = 1\n kernel.append(null_vector.tolist())\n\n # get the nullspace from the _kernel function.\n nullspace = _kernel(binary_matrix)\n\n for nullvec in kernel:\n assert nullvec in nullspace.tolist()\n\n assert (nullspace == result).all()","def test_dtype_preserved(is_sparse, global_dtype):\n rng = np.random.RandomState(0)\n X = rng.rand(10, 2).astype(global_dtype, copy=False)\n\n if is_sparse:\n X[X < 0.8] = 0\n X = sp.csr_matrix(X)\n\n km = BisectingKMeans(n_clusters=3, random_state=0)\n km.fit(X)\n\n assert km.cluster_centers_.dtype == global_dtype","def check_output_k(output_k):\n if isinstance(output_k, list):\n output_k = np.array(output_k)\n # Check indexing is sorted increasingly\n if not is_sorted_array(output_k, increasing=True):\n raise ValueError(\"Provide output_k sorted increasingly\")\n # Check output_k contains at least a 0\n if not np.any(output_k == 0):\n raise ValueError(\n \"output_k must start with a 0 value. 0 indicates the 'current' timestep to predict.\"\n )\n return output_k","def test_calc_kappa(test_coords):\n assert_almost_equal(calc_kappa(53.05187), 5762.687, decimal=3)","def test_assign_clusters_nonsparse(self, new_data, filename):\n\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\n engine = create_engine(sqlalchemy_conn_str)\n if self.split_type == 'random':\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_random',con=engine)\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_random',con=engine)\n elif self.split_type == 'date':\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_date',con=engine)\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_date',con=engine)\n \n averages_seg['exists'] = 1\n test_data_exists = pd.merge(new_data, averages_seg[['segment_id', 'day_of_week', 'time_idx', 'exists']], on=['segment_id', 'day_of_week', 'time_idx'])\n test_exists = test_data_exists[test_data_exists['exists']==1]\n test_notexists = test_data_exists[test_data_exists['exists']!=1]\n \n test_exists_tmp = test_exists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\n test_notexists_tmp = test_notexists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\n test_matrix_exists = pd.merge(test_exists_tmp, averages_seg, how='left', on=['segment_id', 'day_of_week', 'time_idx'])\n test_matrix_notexists = pd.merge(test_notexists_tmp, averages_rt, how='left', on=['road_type', 'day_of_week', 'time_idx'])\n test_matrix = pd.concat([test_matrix_exists, test_matrix_notexists])\n test_matrix = test_matrix.fillna(0)\n \n test_nonsparse_matrix = test_matrix[['segment_id','date','time','date_idx', 'time_idx', 'day_of_week', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2', 'level_binary', 'level_min', 'level_max', 'level_mean', 'level_count']]\n test_nonsparse_matrix = self.scale_matrix(test_nonsparse_matrix)\n\n print('clustering new data...')\n cluster_model = joblib.load(filename)\n cluster_predictions = cluster_model.predict(test_nonsparse_matrix.drop(columns = ['segment_id','date','time']))\n \n clusterdf = pd.DataFrame(cluster_predictions,columns = ['cluster_nonsparse']).reset_index()\n keydf = test_matrix[['segment_id','date','time']].reset_index()\n test_cluster_df_sparse = pd.merge(clusterdf, keydf, on=['index'])\n \n return test_cluster_df_sparse[['segment_id','date','time','cluster_nonsparse']]","def testContains(self):\n\n N = randint(20,100)\n for i in xrange(N):\n self.s.insert(i,True)\n N-=(i in self.s)\n\n self.assertEqual(N,0)","def test_float32_float64_equivalence(is_sparse):\n rng = np.random.RandomState(0)\n X = rng.rand(10, 2)\n\n if is_sparse:\n X[X < 0.8] = 0\n X = sp.csr_matrix(X)\n\n km64 = BisectingKMeans(n_clusters=3, random_state=0).fit(X)\n km32 = BisectingKMeans(n_clusters=3, random_state=0).fit(X.astype(np.float32))\n\n assert_allclose(km32.cluster_centers_, km64.cluster_centers_)\n assert_array_equal(km32.labels_, km64.labels_)","def cv_msk(x, k, permu=True):\n n = x if isinstance(x, int) else len(x)\n idx = np.array(np.arange(np.ceil(n / float(k)) * k), '<i4')\n if permu:\n idx = np.random.permutation(idx)\n idx = idx.reshape(k, -1) % n\n msk = np.zeros((k, n), 'bool')\n for _ in range(k):\n msk[_, idx[_, ]] = True\n return msk","def clustering_dbscan_o3d():\n pass","def kmeans_clustering(all_features, vocab_size, epsilon, max_iter):\n\n # Your code here. You should also change the return value.\n\n def _initiate_random_centroids(all_features, vocab_size):\n \"\"\"\n Initiate random centroids in the range of input\n\n :param all_features:\n :param vocab_size:\n :return:\n \"\"\"\n centroids = []\n # 1) Genereate points for initial centroids\n\n min_feat = np.ones(all_features[0].size)*np.inf\n max_feat = np.zeros(all_features[0].size)\n\n for a in all_features:\n for p in range(len(a)):\n if a[p] < min_feat[p]:\n min_feat[p] = a[p]\n else:\n if a[p] > max_feat[p]:\n max_feat[p] = a[p]\n\n\n for _ in range(vocab_size):\n random_vector = np.multiply(np.random.rand(1, all_features[0].size),\n max_feat-min_feat) + min_feat\n centroids.append(random_vector.flatten())\n\n return np.array(centroids)\n\n def _assign_vectors_to_nearest_centroid(all_features, centroid):\n \"\"\"\n Assign vectors to nearest centroids\n\n :param all_features:\n :param centroid:\n :return:\n \"\"\"\n #TODO: sprawdz co lepiej dziala\n new_centroid_coor = np.zeros([len(centroid), all_features[0].size])\n #new_centroid_coor = centroid\n new_centroid_counter = np.zeros(len(centroid))\n\n dist = pdist(centroid, all_features)\n #min_dist = dist.min(axis=0)\n min_dist_index = dist.argmin(axis=0)\n\n for x in range(len(min_dist_index)):\n id = min_dist_index[x]\n new_centroid_coor[id] = np.add(new_centroid_coor[id],\n all_features[x])\n new_centroid_counter[id] += 1\n\n new_centroid_coor_out = []\n for i in range(len(new_centroid_coor)):\n if new_centroid_counter[i] == 0:\n new_centroid_coor_out.append(centroid[i])\n else:\n new_centroid_coor_out.append(np.divide(new_centroid_coor[i],new_centroid_counter[i]))\n\n return np.array(new_centroid_coor_out), new_centroid_counter\n\n\n def _check_convergence_condition(old_centroids, new_centroids, epsilon):\n \"\"\"\n Check convergence confition\n\n :param old_centroids:\n :param new_centroids:\n :param epsilon: if every centroid is moved by dist < epsilon KMeans terminates\n :return:\n \"\"\"\n for i in range(len(old_centroids)):\n dist = euclidean(old_centroids[i], new_centroids[i])\n if dist > epsilon:\n return False\n\n return True\n\n def delete_small_clusters(new_centroids, centroid_counter, threshold):\n \"\"\"\n Potential extension of the algorithm -> if there is not any point in the cluster, delete this cluste\n\n :param new_centroids:\n :param centroid_counter:\n :param threshold:\n :return:\n \"\"\"\n\n out_centroids = []\n for n in range(len(new_centroids)):\n if centroid_counter[n] > threshold:\n out_centroids.append(new_centroids[n])\n out_centroids = np.array(out_centroids)\n return out_centroids\n\n #MAIN\n old_centroids = _initiate_random_centroids(all_features, vocab_size)\n\n for _ in range(max_iter):\n new_centroids, centroid_counter = _assign_vectors_to_nearest_centroid(all_features, old_centroids)\n if_convergenced = _check_convergence_condition(new_centroids, old_centroids, epsilon)\n\n if if_convergenced == True:\n # return centroids if algorithm is converged\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\n return new_centroids\n old_centroids = new_centroids\n\n # return centroids if reached max_iter\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\n return new_centroids","def test_index_0(self):\n self.insert()\n data = self.tbl[0]\n assert self.check(self.idata[:0], data)","def test_call_alt_threshold(self):\r\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\r\n\r\n exp_otu_ids = range(9)\r\n exp_clusters = [['uclust_test_seqs_0'],\r\n ['uclust_test_seqs_1'],\r\n ['uclust_test_seqs_2'],\r\n ['uclust_test_seqs_3'],\r\n ['uclust_test_seqs_4'],\r\n ['uclust_test_seqs_5'],\r\n ['uclust_test_seqs_6', 'uclust_test_seqs_8'],\r\n ['uclust_test_seqs_7'],\r\n ['uclust_test_seqs_9']]\r\n\r\n app = UclustOtuPicker(params={'Similarity': 0.90,\r\n 'suppress_sort': False,\r\n 'presort_by_abundance': False,\r\n 'save_uc_files': False})\r\n obs = app(self.tmp_seq_filepath1)\r\n obs_otu_ids = sorted(obs.keys())\r\n obs_clusters = sorted(obs.values())\r\n # The relation between otu ids and clusters is abitrary, and\r\n # is not stable due to use of dicts when parsing clusters -- therefore\r\n # just checks that we have the expected group of each\r\n self.assertEqual(obs_otu_ids, exp_otu_ids)\r\n self.assertEqual(obs_clusters, exp_clusters)","def _set_ks_dynamic(self, ks):\n assert(len(ks) == len(self.idxs))\n self.ks = ks\n if np.max(self.ks) > self._kret:\n self._kret = np.max(self.ks)","def test_call_low_cluster_identity(self):\r\n\r\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\r\n # Should only get 6 clusters\r\n exp_otu_ids = [str(x) for x in range(10)]\r\n\r\n exp_clusters = [['uclust_test_seqs_0'],\r\n ['uclust_test_seqs_1'],\r\n ['uclust_test_seqs_2'],\r\n ['uclust_test_seqs_3'],\r\n ['uclust_test_seqs_4'],\r\n ['uclust_test_seqs_5'],\r\n ['uclust_test_seqs_6'],\r\n ['uclust_test_seqs_7'],\r\n ['uclust_test_seqs_8'],\r\n ['uclust_test_seqs_9']]\r\n\r\n app = UsearchReferenceOtuPicker(\r\n params={'save_intermediate_files': False,\r\n 'db_filepath':\r\n self.tmp_ref_database,\r\n 'output_dir': self.temp_dir,\r\n 'remove_usearch_logs': True,\r\n 'reference_chimera_detection':\r\n False,\r\n 'de_novo_chimera_detection':\r\n False,\r\n 'cluster_size_filtering':\r\n False,\r\n 'minlen': 12,\r\n 'w': 12,\r\n 'minsize': 1,\r\n 'percent_id': 0.80,\r\n 'percent_id_err': 0.97\r\n })\r\n\r\n obs = app(self.tmp_seq_filepath1, self.tmp_otu_ref_database)\r\n\r\n obs_otu_ids = sorted(obs.keys())\r\n obs_clusters = sorted(obs.values())\r\n # The relation between otu ids and clusters is abitrary, and\r\n # is not stable due to use of dicts when parsing clusters -- therefore\r\n # just checks that we have the expected group of each\r\n self.assertEqual(obs_otu_ids, exp_otu_ids)\r\n self.assertEqual(obs_clusters, exp_clusters)","def KS(dataDict=None, dataLabel='data', mode='two.sided'):\n\n # test calling values\n modes = ['two.sided', 'less', 'greater']\n if mode not in modes:\n raise ValueError('RSTATS.KS: mode must be in: ', modes)\n if (dataDict is None or not isinstance(dataDict, dict) \n or len(dataDict.keys()) != 2):\n raise ValueError('RSTATS.KS: dataDict must be a dictionary with '\n + 'exactly 2 keys')\n\n labels = list(dataDict.keys())\n# NGroups = len(labels)\n cmdx = 'X=c(%s)' % ', '.join(str(x) for x in dataDict[labels[0]])\n cmdy = 'Y=c(%s)' % ', '.join(str(y) for y in dataDict[labels[1]])\n# package \"perm\" not available on mac os x, use coin instead\n# importr('perm')\n robjects.r(cmdx)\n robjects.r(cmdy)\n\n# (pvalue, nmc) = permutation(dataDict, dataDict.keys())\n\n u = robjects.r(\"ks.test(X, Y, alternative='%s')\" % mode)\n\n pvalue = float(u[1][0])\n statvalue = float(u[0][0]) # get diff estimate\n if dataLabel is not None:\n print ('\\nKolmogorov-Smirnov test. Dataset = %s' % (dataLabel))\n print(u' Test statistic: {:8.4f}'.format(statvalue))\n print(u' p={:8.6f}, [mode={:s}]'.format(float(pvalue), mode))\n return pvalue","def vectorized(self):\n return False","def test_correct_spiking(self):\n n = 10\n t_max = 25.0\n dt = 0.2\n p = 0.05\n\n # some reproducible arbitrariness\n np.random.seed(622312)\n n_steps = int_r(t_max/dt)\n table = np.random.rand(n_steps, n) < p\n\n G = TableSpikers(n)\n G.spike_table = copy.copy(table)\n\n class SimpleMonitor(object):\n def __init__(self, target):\n self.target = target;\n self.results = []\n self.order = 1\n\n def evolve(self, t, dt):\n idxs = self.target.spike.nonzero()[0]\n self.results.extend([(int_r(t/dt), i) for i in idxs])\n\n M = SimpleMonitor(G)\n sim = simulation.Simulation(G, M, dt=dt)\n sim.run(t_max)\n\n expected = zip(*table.nonzero())\n\n self.assertSequenceEqual(expected, M.results)","def test02(self):\n a = np.arange(1, 1e5) < 0\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()\n cwt = [i for i in b.wheretrue()]\n # print \"numpy ->\", a.nonzero()[0].tolist()\n # print \"where ->\", [i for i in b.wheretrue()]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def test_setitem_other(self):\n random.seed(12345)\n\n nside_coverage = 32\n nside_map = 128\n\n full_map = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\n full_map[0: 5000] = random.random(size=5000)\n\n sparse_map = healsparse.HealSparseMap(healpix_map=full_map, nside_coverage=nside_coverage)\n\n indices = (1, 2, 3, 4)\n self.assertRaises(IndexError, sparse_map.__setitem__, indices, 1.0)\n\n indices = 5.0\n self.assertRaises(IndexError, sparse_map.__setitem__, indices, 1.0)","def test_setitem_bool(self):\n random.seed(12345)\n nside_coverage = 32\n nside_map = 128\n pxnums = np.arange(0, 2000)\n pxvalues = np.ones(pxnums.size, dtype=bool)\n full_map = np.zeros(hpg.nside_to_npixel(nside_map), dtype=bool)\n full_map[pxnums] = pxvalues\n\n sparse_map = healsparse.HealSparseMap.make_empty(nside_coverage=nside_coverage,\n nside_sparse=nside_map, dtype=pxvalues.dtype)\n\n sparse_map[pxnums[0]] = pxvalues[0]\n testing.assert_equal(sparse_map[pxnums[0]], full_map[pxnums[0]])\n\n sparse_map[int(pxnums[1])] = bool(pxvalues[1])\n testing.assert_equal(sparse_map[pxnums[1]], full_map[pxnums[1]])\n\n sparse_map[pxnums] = pxvalues\n testing.assert_array_almost_equal(sparse_map[pxnums], full_map[pxnums])","def test_identity_function(data_and_labels):\n input_data = data_and_labels[0]\n\n output_data = unprotected_query(input_data)\n\n np.testing.assert_array_equal(input_data, output_data)","def testAlphaTwoSamplesMatchANormalDistribution(self):\n num_samples = 16384\n scale = 1.7\n rng = random.PRNGKey(0)\n samples = self._distribution.draw_samples(rng, 2 * jnp.ones(num_samples),\n scale * jnp.ones(num_samples))\n # Perform the Kolmogorov-Smirnov test against a normal distribution.\n ks_statistic = scipy.stats.kstest(samples, 'norm', (0., scale)).statistic\n self.assertLess(ks_statistic, 0.01)","def test_PerfectModel_verify_comparison_keyerrors(\n perfectModelEnsemble_initialized_control, comparison\n):\n with pytest.raises(KeyError) as excinfo:\n perfectModelEnsemble_initialized_control.verify(\n comparison=comparison,\n metric=\"mse\",\n dim=[],\n )\n assert \"Specify comparison from\" in str(excinfo.value)","def k_nearest_neighbors(x_test, df_training, k):\n\n return np.argpartition(distance_to_each_training_point(x_test,\n df_training), k-1)[:,0:k]","def test_kernel_matrix(kernel, sample):\n sample = [ele for ele in sample] # consumed several times\n\n potato = KernelMethod(kernel)\n mat = potato.matrix(sample)\n assert np.all(np.linalg.eigvals(mat) > 0) or np.isclose(\n [np.min(np.linalg.eigvals(mat))], [0]\n )","def ks_permutation(df, test, depend, N=100):\n df_miss = df.assign(test_is_null=df[test].isnull()) # Convert to True/False\n \n gpA = df.loc[df_miss['test_is_null'], depend]\n gpB = df.loc[~df_miss['test_is_null'], depend]\n obs_ks, p_val = ks_2samp(gpA, gpB) # Get the ks observed value\n \n kslist = []\n for _ in range(N):\n\n # shuffle the dependent column\n shuffled_dep = (\n df_miss[depend]\n .sample(replace=False, frac=1)\n .reset_index(drop=True)\n )\n\n # \n shuffled = (\n df_miss\n .assign(**{'Shuffled ' + depend: shuffled_dep})\n )\n\n ks, _ = ks_2samp(\n shuffled.loc[shuffled['test_is_null'], 'Shuffled ' + depend],\n shuffled.loc[~shuffled['test_is_null'], 'Shuffled ' + depend]\n )\n\n # add it to the list of results\n kslist.append(ks)\n \n # pd.Series(kslist).plot(kind='hist', density=True, alpha=0.8)\n # plt.scatter(obs_ks, 0, color='red', s=40);\n \n # return np.min([np.count_nonzero(kslist >= obs_ks) / len(kslist), np.count_nonzero(kslist <= obs_ks) / len(kslist)])\n return np.count_nonzero(np.array(kslist) >= obs_ks) / len(kslist) #, np.count_nonzero(kslist <= obs_ks) / len(kslist)])","def testAccidentalHitRemoval(self):\n np.random.seed(0)\n num_classes = 5\n batch_size = 3\n sampled = [1, 0, 2, 3]\n\n for num_true in range(1, 5):\n labels = np.random.randint(\n low=0, high=num_classes, size=batch_size * num_true)\n (weights, biases, hidden_acts, sampled_vals, _,\n _) = self._GenerateTestData(\n num_classes=num_classes,\n dim=10,\n batch_size=batch_size,\n num_true=num_true,\n labels=labels,\n sampled=sampled,\n subtract_log_q=False)\n logits_tensor, _ = _compute_sampled_logits(\n weights=constant_op.constant(weights),\n biases=constant_op.constant(biases),\n labels=constant_op.constant(\n labels, dtype=dtypes.int64, shape=(batch_size, num_true)),\n inputs=constant_op.constant(hidden_acts),\n num_sampled=len(sampled),\n num_classes=num_classes,\n num_true=num_true,\n sampled_values=sampled_vals,\n subtract_log_q=False,\n remove_accidental_hits=True,\n partition_strategy=\"div\",\n name=\"sampled_logits_accidental_hit_removal_num_true_%d\" % num_true)\n # Test that the exponentiated logits of accidental hits are near 0.\n # First we need to find the hits in this random test run:\n labels_reshape = labels.reshape((batch_size, num_true))\n got_logits = self.evaluate(logits_tensor)\n for row in range(batch_size):\n row_labels = labels_reshape[row, :]\n for col in range(len(sampled)):\n if sampled[col] in row_labels:\n # We need to add the num_true_test offset into logits_*\n self.assertNear(\n np.exp(got_logits[row, col + num_true]), 0., self._eps)","def test_hashed_feature_random_sign():\n\n group = Group({\"a\": Hashed(buckets=100, random_sign=True), })\n\n for i in range(100):\n for j in range(100):\n group.set(randstr(), weight=123)\n group.push()\n\n array = group.array()\n assert array.shape == (100, 100)\n\n pos, neg = 0, 0\n for row in array:\n for value in row:\n assert value == 0 or abs(value) == 123\n pos += int(value > 0)\n neg += int(value < 0)\n assert pos and neg and abs(pos - neg) < (pos + neg) * 0.1","def test_return_sparse():\n X = Vectorizer(strategy=\"bow\", return_sparse=True).fit_transform(X_text, y10)\n assert all(pd.api.types.is_sparse(X[c]) for c in X.columns)","def test_three_labels_at_k5_some_out_of_range(self):\n predictions = [[0.5, 0.1, 0.6, 0.3, 0.8, 0.0, 0.7, 0.2, 0.4, 0.9],\n [0.3, 0.0, 0.7, 0.2, 0.4, 0.9, 0.5, 0.8, 0.1, 0.6]]\n top_k_predictions = [\n [9, 4, 6, 2, 0],\n [5, 7, 2, 9, 6],\n ]\n sp_labels = sparse_tensor.SparseTensorValue(\n indices=[[0, 0], [0, 1], [0, 2], [0, 3], [1, 0], [1, 1], [1, 2], [1,\n 3]],\n # values -1 and 10 are outside the [0, n_classes) range and are ignored.\n values=np.array([2, 7, -1, 8, 1, 2, 5, 10], np.int64),\n dense_shape=[2, 4])\n\n # Class 2: 2 labels, 2 correct predictions.\n self._test_streaming_sparse_precision_at_k(\n predictions, sp_labels, k=5, expected=2.0 / 2, class_id=2)\n self._test_streaming_sparse_precision_at_top_k(\n top_k_predictions, sp_labels, expected=2.0 / 2, class_id=2)\n\n # Class 5: 1 label, 1 correct prediction.\n self._test_streaming_sparse_precision_at_k(\n predictions, sp_labels, k=5, expected=1.0 / 1, class_id=5)\n self._test_streaming_sparse_precision_at_top_k(\n top_k_predictions, sp_labels, expected=1.0 / 1, class_id=5)\n\n # Class 7: 1 label, 1 incorrect prediction.\n self._test_streaming_sparse_precision_at_k(\n predictions, sp_labels, k=5, expected=0.0 / 1, class_id=7)\n self._test_streaming_sparse_precision_at_top_k(\n top_k_predictions, sp_labels, expected=0.0 / 1, class_id=7)\n\n # All classes: 10 predictions, 3 correct.\n self._test_streaming_sparse_precision_at_k(\n predictions, sp_labels, k=5, expected=3.0 / 10)\n self._test_streaming_sparse_precision_at_top_k(\n top_k_predictions, sp_labels, expected=3.0 / 10)","def _kmedoids_run(X, n_clusters, dist_func, max_iter=1000, verbose=True):\n # Get initial centers\n n_samples, n_features = len(X), 2\n init_ids = _get_init_centers(n_clusters, X)\n if verbose:\n print('Initial centers are: {}'.format(init_ids))\n centers = init_ids\n members, costs, tot_cost, dist_mat = _get_cost(X, init_ids, dist_func)\n cc, swapped = 0, True\n while True:\n swapped = False\n for i in range(n_samples):\n if i not in centers:\n for j in range(len(centers)):\n centers_ = deepcopy(centers)\n centers_[j] = i\n members_, costs_, tot_cost_, dist_mat_ = _get_cost(X, centers_, dist_func)\n if tot_cost_ < tot_cost:\n members, costs, tot_cost, dist_mat = members_, costs_, tot_cost_, dist_mat_\n centers = centers_\n swapped = True\n if verbose:\n print('Change centers to {}'.format(centers))\n if cc > max_iter:\n if verbose:\n print('End Searching by reaching maximum iteration')\n break\n if not swapped:\n if verbose:\n print('End Searching by no swaps')\n break\n cc += 1\n return centers, members, costs, tot_cost, dist_mat","def ks_test(a,b):\n a,b = np.asarray(a),np.asarray(b)\n if len(a) != len(a):\n raise ValueError(\"a and b must have the same size\")\n \n return stats.ks_2samp(a,b)","def _test_obsdup(t):\n return t.shape[0] != len(set(t.ids(axis='observation')))","def test_katsuura(self):\n fun = get_problem('katsuura', self.dimension, -100, 100)\n self.assertAlmostEqual(fun(self.array10), 3837.4739882594373, delta=4000)","def test_daal_pca_invalid_k(self):\n with self.assertRaisesRegexp(Exception, \"k must be smaller than the number of observation columns\"):\n self.context.daaltk.models.dimreduction.pca.train(self.frame,\n [\"X1\", \"X2\", \"X3\", \"X4\", \"X5\",\n \"X6\", \"X7\", \"X8\", \"X9\", \"X10\"],\n k=0)","def test_on_map_of_0s(synthetic_checkerboard):\n img = synthetic_checkerboard['img']\n di = np.zeros_like(img)\n\n cpp_vorimg = tess.tessellate_labimg(img,di)\n\n py_vorimg = pytess.tessellate_labimg(img,di)\n assert np.alltrue(py_vorimg[:4,:4] == 1)\n printers.store_ndarray(\"py_voronoi_on_map_of_0s_output.txt\",py_vorimg)\n\n assert cpp_vorimg.size > 0\n assert cpp_vorimg.shape == synthetic_checkerboard['img'].shape\n assert np.alltrue(synthetic_checkerboard['img'][1:3,1:3] == 1)\n\n printers.store_ndarray(\"cpp_voronoi_input.txt\",img)\n printers.store_ndarray(\"cpp_voronoi_on_map_of_0s_output.txt\",cpp_vorimg)\n\n assert np.alltrue(cpp_vorimg[:4,:4] == 1)\n assert np.alltrue(cpp_vorimg == py_vorimg)","def test_getitem_array(self):\n random.seed(12345)\n\n nside_coverage = 32\n nside_map = 128\n\n full_map = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\n full_map[0: 5000] = random.random(size=5000)\n\n sparse_map = healsparse.HealSparseMap(healpix_map=full_map, nside_coverage=nside_coverage)\n\n indices = np.array([1, 2, 100, 500, 10000])\n testing.assert_array_almost_equal(sparse_map[indices], full_map[indices])\n testing.assert_almost_equal(sparse_map[indices[0]], full_map[indices[0]])\n\n indices = np.array([1., 2, 100, 500, 10000])\n self.assertRaises(IndexError, sparse_map.__getitem__, indices)\n self.assertRaises(IndexError, sparse_map.__getitem__, indices[0])","def test_index_geq_3(self):\n self.insert()\n data = self.tbl[6:]\n assert self.check(self.idata[2:], data)","def test_fit_ks(distribution):\n print(\"TESTING: K-S fit for %s distribution\" % distribution.upper())\n print(\" fitting to others\")\n for sample_dist in dist.get():\n print(\" %s\" % sample_dist.upper())\n params = dist.DISTRIBUTIONS[sample_dist][dist.KEY_TEST_PARAMS]\n test_sample = dist.samples(sample_dist, params)\n fit_results = fit.fit_ks(distribution, test_sample)\n print(\" input parameters: %s\" % dist.get_params(params, sample_dist))\n print(\" fit parameters: %s\" % dist.get_params(fit_results['params'], distribution))\n print(\" log-likelihood: %r\" % fit_results['log-likelihood'])\n print(\" K-S statistics: %r\" % fit_results['D'])","def test_extreme_neighborhoods(self):\n\n ## Radius = 0 ==> all points are noise\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.0,\n min_core_neighbors=3,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 0)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"noise\"), self.n)\n\n ## Min_neighbors > 30 ==> all points are noise\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.0,\n min_core_neighbors=31,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 0)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"noise\"), self.n)\n\n ## Radius very large ==> all points are core points\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=100.0,\n min_core_neighbors=3,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 1)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"core\"), self.n)\n\n ## Min_neighbors = 0 ==> all points are core points\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.5,\n min_core_neighbors=0,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 1)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"core\"), self.n)","def test00(self):\n a = np.arange(1, 11) > 0\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()\n cwt = [i for i in b.wheretrue()]\n # print \"numpy ->\", a.nonzero()[0].tolist()\n # print \"where ->\", [i for i in b.wheretrue()]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def test_sparse_distance_matrix(coordinates, max_dist, p):\n original_tree = scipyKDTree(coordinates)\n redis_tree = redisKDTree(coordinates)\n\n original_output = original_tree.sparse_distance_matrix(original_tree, max_dist, p)\n redis_output = redis_tree.sparse_distance_matrix(redis_tree, max_dist, p)\n\n assert dict_close(redis_output, original_output)","def test_knu(self):\n x = self.x\n result = bessel_sk.lnknu(x, self.maxorder)\n k_exp = [14.2670922632, 28.082603821, 172.7219309,\n 1825.996042640, 20431.0266426932]\n for i, l in enumerate(self.orders):\n assert_almost_equal(result[0,l]/k_exp[i], 1)","def storage_init(index):\n i, t = index[0], 0\n return (\n storage_state[i, t]\n == storage_start_state[i]\n + storage_para[i].eta_ch * storage_ch[i, t]\n - 1 / storage_para[i].eta_disch * storage_disch[i, t]\n )","def test_ks_ms(distribution):\n print(\"TESTING: K-S model selection for %s distribution\" % distribution.upper())\n params = dist.DISTRIBUTIONS[distribution][dist.KEY_TEST_PARAMS]\n print(\" creating sample\")\n test_sample = dist.samples(distribution, params)\n print(\" calculating K-S statistics for all distributions\")\n print(\" input parameters: %s\" % dist.get_params(params, distribution))\n fit_results = {}\n best_ksd = 1.0\n best_model = dist.get()[0]\n for d in dist.get():\n print(\" %s:\" % d.upper())\n fit_results[d] = fit.fit_ks(d, test_sample)\n if fit_results[d]['D'] < best_ksd:\n best_ksd = fit_results[d]['D']\n best_model = d\n print(\" %s\" % dist.get_params(fit_results[d]['params'], d))\n print(\" D = %r\" % fit_results[d]['D'])\n params = fit_results[d]['params']\n p = 0\n for r in range(100):\n synthetic_sample = dist.samples(d, params, len(test_sample))\n ksd = me.ks_statistics(dist.get_sample_cdf(synthetic_sample), dist.cdf(d, params, np.max(synthetic_sample)))\n if ksd > fit_results[d]['D']:\n p += 1\n print(\" p = %r\" % (float(p)/100.0))\n print(\" Best fitting model: %s\" % best_model.upper())\n print_pmfs(test_sample, fit_results, 'TEST-KS.CSV')"],"string":"[\n \"def test_ks_test(mode):\\n indices = np.random.randint(0, 1000, 1000)\\n out = compute_indices_ks_test(indices, 1000, mode=mode)\\n assert all([o > 0.0 for o in out])\",\n \"def test_ks_test_empty_indices():\\n out = compute_indices_ks_test([], 1000, mode=\\\"D+\\\")\\n assert all(o is None for o in out)\",\n \"def _assert_ks_postformat(self):\\n if type(self.idxs) in [list, np.ndarray]:\\n if self.ks is None:\\n if self.staticneighs:\\n pass\\n else:\\n self.ks = range(len(self.idxs))\\n if self.staticneighs:\\n pass\\n else:\\n# print self.ks, self.idxs, self.set_neighs, self.set_sp_rel_pos\\n assert(len(self.ks) == len(self.idxs))\\n ## Defining functions\\n if self.sp_relative_pos is not None and self.staticneighs:\\n self.get_sp_rel_pos = self._static_get_rel_pos\\n elif not self.staticneighs:\\n if type(self.sp_relative_pos) == list:\\n self.get_sp_rel_pos = self._dynamic_rel_pos_list\\n else:\\n self.get_sp_rel_pos = self._dynamic_rel_pos_array\\n if self.sp_relative_pos is None:\\n self.set_sp_rel_pos = self._null_set_rel_pos\\n self.get_sp_rel_pos = self._null_get_rel_pos\\n ## Ensure correct k_ret\\n if np.max(self.ks) > self._kret:\\n self._kret = np.max(self.ks)\",\n \"def test_k_rank_approximate(corpus):\\n return\",\n \"def test_k_index():\\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\\n 400.]) * units.hPa\\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\\n -23.5]) * units.degC\\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\\n -57.5]) * units.degC\\n ki = k_index(pressure, temperature, dewpoint)\\n assert_almost_equal(ki, 33.5 * units.degC, 2)\",\n \"def check_k_anonymity(data: np.ndarray, k: int, qi_indices=None):\\n print(Counter(str(e) for e in data[:, qi_indices]))\\n\\n occurrences = list(Counter(str(e) for e in data[:, qi_indices]).values())\\n for j in range(len(occurrences)):\\n if occurrences[j] < k:\\n return False\\n return True\",\n \"def test_single_run(self):\\n\\n traces = np.load('data/traces.npy')\\n keys = np.load('data/key.npy')\\n plain = np.load('data/plain.npy')\\n correct_indices = [4254, 4257, 1400, 4429, 4919, 1399, 4918, 1398, 4917, 1397]\\n\\n indices = SOSTD.list_of_best_indices(traces, keys, plain, 10, 0)\\n self.assertTrue(np.array_equal(indices, correct_indices))\",\n \"def test_sparse():\\n\\n rng = np.random.RandomState(0)\\n\\n X = rng.rand(20, 2)\\n X[X < 0.8] = 0\\n X_csr = sp.csr_matrix(X)\\n\\n bisect_means = BisectingKMeans(n_clusters=3, random_state=0)\\n\\n bisect_means.fit(X_csr)\\n sparse_centers = bisect_means.cluster_centers_\\n\\n bisect_means.fit(X)\\n normal_centers = bisect_means.cluster_centers_\\n\\n # Check if results is the same for dense and sparse data\\n assert_allclose(normal_centers, sparse_centers, atol=1e-8)\",\n \"def test_k_index_xarray(index_xarray_data):\\n result = k_index(index_xarray_data.isobaric, index_xarray_data.temperature,\\n index_xarray_data.dewpoint)\\n assert_array_almost_equal(result,\\n np.array([[[312., 311., 310.], [309., 308., 307.]]]) * units.K)\",\n \"def main_eaftest(point_ind, permutations=10240, alpha=0.05):\\n \\n # ------ Attainment indicator values information ------\\n \\n npoints = len(point_ind)\\n nvars = len(point_ind[0]) # Número de execuções total\\n nruns = nvars // 2 # Número de execuções de 1 algo\\n \\n print \\\"- Attainment indicator values information:\\\"\\n print \\\" * Number of points:\\\", npoints\\n print \\\" * Joint executions:\\\", nvars, \\\"(%d + %d)\\\" % (nruns, nruns)\\n print\\n \\n assert nvars % 2 == 0, \\\"Number of total joint executions must be even.\\\"\\n assert nvars <= 64, \\\"Not implemented with more than 64 joint executions.\\\"\\n \\n # ------ Test Statistic ------\\n\\n print \\\"- Computing the test statistic...\\\" \\n stat2 = libaft.ksstat(point_ind, order=2)\\n print \\\" * Test statistic = %d/%d\\\" % (stat2, nruns)\\n print \\\" = %f\\\" % (stat2 / float(nruns)), '\\\\n'\\n \\n # ------ Estimate null distribution ------\\n\\n print \\\"- Using %d random permutations to estimate null distribution.\\\" % permutations\\n print \\\" Please be patient...\\\"\\n maxdist = np.zeros(permutations, dtype=np.int32) # Max distance array\\n rtime = time.time()\\n \\n masks = bintools.make_masks(permutations, nvars, seed=64)\\n for i, maxd in enumerate(KERNEL.runkernel(point_ind, masks)):\\n maxdist[i] = maxd\\n if (i+1) % (permutations//20) == 0:\\n print \\\" %6d permutations, %7.3f sec\\\" % (i+1, time.time()-rtime)\\n print \\\" * Time elapsed: %7.3f\\\" % (time.time()-rtime)\\n \\n # Compute null distribution from max distance array\\n tail = np.bincount(maxdist, minlength=nruns+1)\\n print \\\" * Non-normalized null distribution:\\\"\\n print tail\\n print\\n \\n # ------ Accept/reject null hypothesis ------\\n \\n # NB: -1 resulta das diferentes convenções para a definição de valor crítico\\n crit = criticalvalue(tail, alpha * permutations) - 1\\n pval = pvalue(tail, stat2) / float(permutations)\\n \\n print \\\"- Null hypothesis decision:\\\" \\n print \\\" * Critical value = %d/%d\\\" % (crit, nruns)\\n print \\\" = %f\\\" % (crit / float(nruns))\\n print \\\" * p-value = %f\\\" % pval\\n if pval <= alpha:\\n print \\\" <= alpha (%s)\\\\n\\\" % alpha\\n print \\\" * Decision: REJECT the null hypothesis\\\"\\n else:\\n print \\\" > alpha (%s)\\\\n\\\" % alpha\\n print \\\" * Decision: do NOT REJECT the null hypothesis\\\"\\n print\",\n \"def test_single_run_sosd(self):\\n\\n traces = np.load('data/traces.npy')[:1000]\\n keys = np.load('data/key.npy')[:1000]\\n plain = np.load('data/plain.npy')[:1000]\\n correct_indices = [4371, 2401, 2402, 4878, 4370, 4877, 4882, 4369, 4881, 2723]\\n\\n indices = SOSTD.list_of_best_indices(traces, keys, plain, 10, 0, False)\\n self.assertTrue(np.array_equal(indices, correct_indices))\",\n \"def test_key_predicate(datum):\\n return 0 < datum\",\n \"def test_eigenvalues_of_too_few_points_results_in_0():\\n a = np.array([5])\\n pc = create_point_cloud(a, a, a)\\n\\n compute_features(pc, [[0]], pc, [\\\"eigenv_1\\\", \\\"eigenv_2\\\", \\\"eigenv_3\\\"], InfiniteCylinder(5))\\n\\n eigen_val_123 = np.array([pc[keys.point]['eigenv_{}'.format(i)]['data'] for i in [1, 2, 3]])\\n assert not np.any(np.isnan(eigen_val_123))\\n assert not np.any(np.isinf(eigen_val_123))\",\n \"def ks_test(timeseries):\\r\\n\\r\\n hour_ago = time() - 3600\\r\\n ten_minutes_ago = time() - 600\\r\\n reference = scipy.array([x[1] for x in timeseries if x[0] >= hour_ago and x[0] < ten_minutes_ago])\\r\\n probe = scipy.array([x[1] for x in timeseries if x[0] >= ten_minutes_ago])\\r\\n\\r\\n if reference.size < 20 or probe.size < 20:\\r\\n return False\\r\\n\\r\\n ks_d,ks_p_value = scipy.stats.ks_2samp(reference, probe)\\r\\n\\r\\n if ks_p_value < 0.05 and ks_d > 0.5:\\r\\n adf = sm.tsa.stattools.adfuller(reference, 10)\\r\\n if adf[1] < 0.05:\\r\\n return True\\r\\n\\r\\n return False\",\n \"def skip_test(n):\\n return k > 0 and magic * n * k**0.5 >= t4_ref\",\n \"def ks_test_function(dim, thresh):\\n def ks_test(table1, table2):\\n from scipy.stats import ks_2samp\\n sample1 = table1.get_cols(dim)[0]\\n sample2 = table2.get_cols(dim)[0]\\n if thresh != None:\\n sample1[sample1<thresh] = 0\\n sample2[sample2<thresh] = 0\\n ks, p_ks = ks_2samp(sample1, sample2)\\n return ks\\n return ks_test\",\n \"def test_k(self):\\n\\n # We have a new K. It should have nothing in it.\\n loc_, sloc_, test_loc, test_sloc = self.k__.get_totals()\\n self.assertEqual(loc_, 0)\\n self.assertEqual(sloc_, 0)\\n self.assertEqual(test_loc, 0)\\n self.assertEqual(test_sloc, 0)\\n\\n self.check_counts('zz', 0, 0, 0, 0) # not in map\\n self.check_counts('py', 0, 0, 0, 0) # not in map\\n\\n self.k__.add_counts('py', 7, 3)\\n self.check_counts('py', 7, 3, 0, 0)\\n self.k__.add_counts('py', 5, 2)\\n self.check_counts('py', 12, 5, 0, 0)\\n\\n self.k__.add_test_counts('py', 8, 4)\\n self.check_counts('py', 12, 5, 8, 4)\\n self.k__.add_test_counts('py', 9, 3)\\n self.check_counts('py', 12, 5, 17, 7)\\n\\n expected = \\\"py:%d/%d T%.1f%%\\\" % (12 + 17, 5 + 7, 700.0 / 12)\\n # DEBUG\\n # print(\\\"Expected: %s\\\" % expected)\\n # END\\n self.assertEqual(self.k__.pretty_counts('py'), expected)\",\n \"def test_optimalk_cluster_array_values_error():\\n from sklearn.datasets.samples_generator import make_blobs\\n from gap_statistic import OptimalK\\n\\n # Create optimalK instance\\n optimalK = OptimalK(parallel_backend=None, n_jobs=-1)\\n\\n # Create data\\n X, y = make_blobs(n_samples=int(1e3), n_features=2, centers=3)\\n\\n with pytest.raises(ValueError) as excinfo:\\n optimalK(X, cluster_array=[0, -1, 1, 2, 3])\\n assert 'cluster_array contains values less than 1' in str(excinfo.value)\",\n \"def test_sparsity_topk_mask_dykstra(self, l=1e-2):\\n n = int(1e3)\\n seed = np.random.RandomState(0)\\n y = jnp.array(seed.randn(n))\\n k = 10\\n out_top_k_dykstra = sparse_soft_topk_mask_dykstra(y, k, l=l)\\n self.assertAlmostEqual(\\n y.argsort()[::-1][:k].sort().sum(),\\n out_top_k_dykstra.argsort()[::-1][:k].sort().sum(),\\n )\\n self.assertAlmostEqual(len(jnp.where(out_top_k_dykstra > 0)[0]), k)\",\n \"def test_fast_denoiser(self):\\r\\n\\r\\n actual_centroids, actual_otu_map = fast_denoiser(\\r\\n [self.sff_path2], self.seq_path, self.tmp_out_dir,\\r\\n num_cpus=1, primer=\\\"YATGCTGCCTCCCGTAGGAGT\\\", verbose=False)\\r\\n\\r\\n actual = list(actual_centroids)\\r\\n self.assertEqual(actual, expected_centroids)\\r\\n # centroids are sorted, so first one should be unique\\r\\n #(all others have cluster size 1, so relative ordering is not guaranteed\\r\\n self.assertEqual(actual[0], expected_centroids[0])\\r\\n self.assertEqual(actual_otu_map, expected_otu_map)\",\n \"def test_determine_k(self):\\n test_dir_name = os.path.dirname(__file__)\\n feat_array_fn = os.path.join(\\n test_dir_name, \\\"data\\\", \\\"four_clusters.csv\\\")\\n df = pd.read_csv(feat_array_fn)\\n feat_array = df[[\\\"x\\\", \\\"y\\\"]].values\\n\\n clusterer = Clusterer(feat_array_fn, \\\"/dev/null\\\", [])\\n best_k = clusterer._determine_k(feat_array, 9)\\n\\n self.assertEqual(best_k, 4)\\n\\n feat_array_fn = os.path.join(\\n test_dir_name, \\\"data\\\", \\\"iris.csv\\\")\\n df = pd.read_csv(feat_array_fn)\\n feat_array = df[[\\n \\\"Sepal.Length\\\", \\\"Sepal.Width\\\", \\\"Petal.Length\\\",\\n \\\"Petal.Width\\\"]].values\\n\\n clusterer = Clusterer(feat_array_fn, \\\"/dev/null\\\", [])\\n best_k = clusterer._determine_k(feat_array, 9)\\n\\n self.assertEqual(best_k, 2)\",\n \"def chi2sf_inplace(x, k):\",\n \"def test_jw_sparse_index(self):\\n expected = [1, 2]\\n calculated_indices = jw_number_indices(1, 2)\\n self.assertEqual(expected, calculated_indices)\\n\\n expected = [3]\\n calculated_indices = jw_number_indices(2, 2)\\n self.assertEqual(expected, calculated_indices)\",\n \"def test_optimalk_cluster_array_empty_error():\\n from sklearn.datasets.samples_generator import make_blobs\\n from gap_statistic import OptimalK\\n\\n # Create optimalK instance\\n optimalK = OptimalK(parallel_backend=None, n_jobs=-1)\\n\\n # Create data\\n X, y = make_blobs(n_samples=int(1e3), n_features=2, centers=3)\\n\\n with pytest.raises(ValueError) as excinfo:\\n optimalK(X, cluster_array=[])\\n assert 'The supplied cluster_array has no values.' in str(excinfo.value)\",\n \"def do_knn(x_data):\\n return True\",\n \"def test_index_stability(self, example_staypoints):\\n sp = example_staypoints\\n sp2, locs = sp.as_staypoints.generate_locations(\\n method=\\\"dbscan\\\", epsilon=10, num_samples=2, distance_metric=\\\"haversine\\\", agg_level=\\\"user\\\"\\n )\\n assert sp.index.equals(sp2.index)\",\n \"def test_index_start(self):\\n sp_file = os.path.join(\\\"tests\\\", \\\"data\\\", \\\"geolife\\\", \\\"geolife_staypoints.csv\\\")\\n sp = ti.read_staypoints_csv(sp_file, tz=\\\"utc\\\", index_col=\\\"id\\\", crs=\\\"epsg:4326\\\")\\n\\n # reproject to WGS_1984_UTM_Zone_49N\\n sp = sp.to_crs(\\\"epsg:32649\\\")\\n\\n distance_metric_ls = [\\\"haversine\\\", \\\"euclidean\\\"]\\n agg_level_ls = [\\\"dataset\\\", \\\"user\\\"]\\n for distance_metric in distance_metric_ls:\\n for agg_level in agg_level_ls:\\n _, locations = sp.as_staypoints.generate_locations(\\n method=\\\"dbscan\\\", epsilon=10, num_samples=1, distance_metric=distance_metric, agg_level=agg_level\\n )\\n assert (locations.index == np.arange(len(locations))).any()\",\n \"def SSC_test():\\n \\n # generating data\\n\\n D = 40 # Dimension of ambient space\\n k = 4 # Number of subspaces\\n d = 1\\n N = 90 # Number of points in subspaces\\n # Generating N points in d dim. subspaces\\n Xi = [np.random.randn(D, d).dot(np.random.randn(d, N))\\n for _ in range(k)]\\n X = np.concatenate(Xi, axis=1)\\n\\n # Generating the ground-truth for evaluating clustering results\\n lbls = [i * np.ones([1, N]) for i in range(k)]\\n s = np.concatenate(lbls, axis=1)\\n r = 0 # Enter the projection dimension e.g. r = d*n, enter r = 0 to not project\\n Cst = 0 # Enter 1 to use the additional affine constraint sum(c) == 1\\n OptM = 'L1Noise' # OptM can be {'L1Perfect','L1Noise','Lasso','L1ED'}\\n lmbda = 0.001 # Regularization parameter in 'Lasso' or the noise level for 'L1Noise'\\n # Number of top coefficients to build the similarity graph, enter K=0 for using the whole coefficients\\n K = 0 #max(d1, d2)\\n if Cst == 1:\\n K = d + 1 # For affine subspaces, the number of coefficients to pick is dimension + 1\\n\\n Xp = DataProjection(X, r, 'NormalProj')\\n \\n # testing clustering\\n \\n '''\\n # using wrapper function\\n Grps, sc = sparseSubspaceClustering(\\n Xp.T, n, ground_truth=s, affine=Cst, OptM=OptM, lam=lmbda)\\n Grps = BestMap(sc, Grps)\\n Missrate = float(np.sum(sc != Grps)) / sc.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\\n '''\\n \\n '''\\n # calling internal tools\\n CMat = SparseCoefRecovery(Xp, Cst, OptM, lmbda)\\n # Make small values 0\\n eps = np.finfo(float).eps\\n CMat[np.abs(CMat) < eps] = 0\\n\\n CMatC, sc, OutlierIndx, Fail = OutlierDetection(CMat, s)\\n\\n if Fail == False:\\n CKSym = BuildAdjacency(CMatC, K)\\n Grps = SpectralClustering(CKSym, n)\\n Grps = BestMap(sc, Grps)\\n Missrate = float(np.sum(sc != Grps)) / sc.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\\n else:\\n print(\\\"Something failed\\\")\\n '''\\n \\n labels, _, __ = KSubspaces(Xp.T, k, d)\\n labels = BestMap(s, labels)\\n Missrate = float(np.sum(s != labels)) / s.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\",\n \"def test_batch_missing_data():\\n\\n\\n def fx(x, dt):\\n F = np.array([[1, dt, 0, 0],\\n [0, 1, 0, 0],\\n [0, 0, 1, dt],\\n [0, 0, 0, 1]], dtype=float)\\n\\n return np.dot(F, x)\\n\\n def hx(x):\\n return np.array([x[0], x[2]])\\n\\n\\n dt = 0.1\\n points = MerweScaledSigmaPoints(4, .1, 2., -1)\\n kf = UKF(dim_x=4, dim_z=2, dt=dt, fx=fx, hx=hx, points=points)\\n\\n\\n kf.x = np.array([-1., 1., -1., 1])\\n kf.P*=0.0001\\n\\n zs = []\\n for i in range(20):\\n z = np.array([i+randn()*0.1, i+randn()*0.1])\\n zs.append(z)\\n\\n zs[2] = None\\n Rs = [1]*len(zs)\\n Rs[2] = None\\n Ms, Ps = kf.batch_filter(zs)\",\n \"def test_call_alt_threshold(self):\\r\\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\\r\\n\\r\\n exp = {0: ['cdhit_test_seqs_0'],\\r\\n 1: ['cdhit_test_seqs_1'],\\r\\n 2: ['cdhit_test_seqs_2'],\\r\\n 3: ['cdhit_test_seqs_3'],\\r\\n 4: ['cdhit_test_seqs_4'],\\r\\n 5: ['cdhit_test_seqs_5'],\\r\\n 6: ['cdhit_test_seqs_6', 'cdhit_test_seqs_8'],\\r\\n 7: ['cdhit_test_seqs_7'],\\r\\n 8: ['cdhit_test_seqs_9']}\\r\\n\\r\\n app = CdHitOtuPicker(params={'Similarity': 0.90})\\r\\n obs = app(self.tmp_seq_filepath1)\\r\\n self.assertEqual(obs, exp)\",\n \"def test_jaccard_index_all_zeros():\\n vector1 = np.array([0, 0, 0, 0])\\n vector2 = np.array([1, 1, 1, 1])\\n score11 = jaccard_index.py_func(vector1, vector1)\\n score12 = jaccard_index.py_func(vector1, vector2)\\n score22 = jaccard_index.py_func(vector2, vector2)\\n\\n assert score11 == score12 == 0.0, \\\"Expected different score.\\\"\\n assert score22 == 1.0, \\\"Expected different score.\\\"\",\n \"def test_jaccard_index_all_zeros_compiled():\\n vector1 = np.array([0, 0, 0, 0])\\n vector2 = np.array([1, 1, 1, 1])\\n score11 = jaccard_index(vector1, vector1)\\n score12 = jaccard_index(vector1, vector2)\\n score22 = jaccard_index(vector2, vector2)\\n\\n assert score11 == score12 == 0.0, \\\"Expected different score.\\\"\\n assert score22 == 1.0, \\\"Expected different score.\\\"\",\n \"def Q8_test():\\n dispo = [False, True, True, False]\\n tab_dist = [[0, 4.123105625617661, 4.242640687119285, 4.47213595499958], [4.123105625617661, 0, 4.123105625617661, 7.810249675906654], [4.242640687119285, 4.123105625617661, 0, 5.0990195135927845], [4.47213595499958, 7.810249675906654, 5.0990195135927845, 0]]\\n return 1 == indice(0, tab_dist, dispo)\",\n \"def test_sparsity_topk_mag_dykstra(self, l=1e-3):\\n n = int(1e3)\\n seed = np.random.RandomState(0)\\n y = jnp.array(seed.randn(n))\\n k = 10\\n out_top_k_dykstra = sparse_soft_topk_mag_dykstra(y, k, l=l)\\n self.assertAlmostEqual(\\n len(jnp.where(jnp.absolute(out_top_k_dykstra) > 0)[0]), k\\n )\",\n \"def sparse(n, k):\\n z = np.zeros(n)\\n for i in np.random.choice( np.arange(n), k, replace=None ): # supports of nonzero entries\\n z[i] = np.random.randn()\\n return z\",\n \"def test_ks2x(self):\\n D, Pval = ks_test(self.x1, self.x2)\\n assert_allclose((D, Pval), (0.46, 3.801e-05), rtol=1e-4)\\n D, Pval = ks_test(self.x1, self.x2, exact=False)\\n assert_allclose((D, Pval), (0.46, 5.084e-05), rtol=1e-4)\\n D, Pval = ks_test(self.x1, self.x2[:20])\\n assert_allclose((D, Pval), (0.53, 0.0003576), rtol=1e-4)\\n D, Pval = ks_test(self.x2[:20], self.x1)\\n assert_allclose((D, Pval), (0.53, 0.0003576), rtol=1e-4)\\n D, Pval = ks_test(self.x1[:20], self.x2)\\n assert_allclose((D, Pval), (0.48, 0.001772), rtol=1e-3)\\n D, Pval = ks_test(self.x1, self.x2, alt=\\\"greater\\\")\\n assert_allclose((D, Pval), (0.46, 2.542e-05), rtol=1e-4)\\n D, Pval = ks_test(self.x1, self.x2, alt=\\\"g\\\")\\n assert_allclose((D, Pval), (0.46, 2.542e-05), rtol=1e-4)\\n D, Pval = ks_test(self.x1, self.x2, alt=\\\"less\\\")\\n assert_allclose((D, Pval), (6.9388939039072284e-18, 1.0), rtol=1e-4)\\n D, Pval = ks_test(self.x2, self.x1, alt=\\\"l\\\")\\n assert_allclose((D, Pval), (0.46, 2.542e-05), rtol=1e-4)\",\n \"def test_ks2x(self):\\n D, Pval = ks_test(self.x1, self.x2)\\n self.assertFloatEqual((D, Pval), (0.46, 3.801e-05), eps=1e-4)\\n D, Pval = ks_test(self.x1, self.x2, exact=False)\\n self.assertFloatEqual((D, Pval), (0.46, 5.084e-05), eps=1e-4)\\n D, Pval = ks_test(self.x1, self.x2[:20])\\n self.assertFloatEqual((D,Pval), (0.53, 0.0003576), eps=1e-4)\\n D, Pval = ks_test(self.x2[:20], self.x1)\\n self.assertFloatEqual((D,Pval), (0.53, 0.0003576), eps=1e-4)\\n D, Pval = ks_test(self.x1[:20], self.x2)\\n self.assertFloatEqual((D,Pval), (0.48, 0.001772), eps=1e-4)\\n D, Pval = ks_test(self.x1, self.x2, alt=\\\"greater\\\")\\n self.assertFloatEqual((D,Pval), (0.46, 2.542e-05), eps=1e-4)\\n D, Pval = ks_test(self.x1, self.x2, alt=\\\"g\\\")\\n self.assertFloatEqual((D,Pval), (0.46, 2.542e-05), eps=1e-4)\\n D, Pval = ks_test(self.x1, self.x2, alt=\\\"less\\\")\\n self.assertFloatEqual((D,Pval), (6.9388939039072284e-18, 1.), eps=1e-4)\\n D, Pval = ks_test(self.x2, self.x1, alt=\\\"l\\\")\\n self.assertFloatEqual((D,Pval), (0.46, 2.542e-05), eps=1e-4)\",\n \"def ks_test(t):\\n data = {\\n name: (\\n [\\n _ks_Z(t[name].values, t[t.columns[j]].values)\\n for j in range(i + 1)\\n ]\\n + ([np.nan] * (len(t.columns) - 2 - i))\\n )\\n for i, name in enumerate(t.columns[1:])\\n }\\n idx = pd.Index(t.columns[:-1], name=\\\"K-S test Z\\\")\\n return pd.DataFrame(data, index=idx)\",\n \"def test_getitem_other(self):\\n random.seed(12345)\\n\\n nside_coverage = 32\\n nside_map = 128\\n\\n full_map = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\\n full_map[0: 5000] = random.random(size=5000)\\n\\n sparse_map = healsparse.HealSparseMap(healpix_map=full_map, nside_coverage=nside_coverage)\\n\\n indices = (1, 2, 3, 4)\\n self.assertRaises(IndexError, sparse_map.__getitem__, indices)\\n\\n indices = 5.0\\n self.assertRaises(IndexError, sparse_map.__getitem__, indices)\",\n \"def findknn(xTr,xTe,k):\\n\\n # YOUR CODE HERE\\n if k > len(xTr):\\n k = len(xTr)\\n \\n D=l2distance(xTe, xTr)\\n (m,n) = D.shape\\n \\n indices = []\\n dists = []\\n for i in range(m):\\n smallest_indices = np.argsort(D[i])\\n ind = smallest_indices[:k]\\n dis = D[i,smallest_indices[:k]]\\n indices.append(ind)\\n dists.append(dis)\\n \\n indices = np.transpose(np.array(indices))\\n dists = np.transpose(np.array(dists))\\n return indices, dists\",\n \"def main():\\n if len(sys.argv) != 5:\\n exit(\\\"Usage: python oneta.py train-corpus test-corpus kernel-size output\\\")\\n\\n w1Words = dict()\\n w2Words = dict()\\n W1 = 0\\n W2 = 0\\n\\n D1 = int(sys.argv[3])\\n\\n sys.stderr.write(\\\"First scan of training data\\\\n\\\")\\n \\n J = 0\\n # Read through the corpus to decided which words are in the dense set and which in the sparse set\\n corpus = open(sys.argv[1],\\\"r\\\")\\n for line in corpus:\\n tokens = word_tokenize(line)\\n for token in tokens:\\n tk_decoded = token.decode(\\\"utf-8\\\")\\n if J < D1 and tk_decoded not in w1Words:\\n w1Words[tk_decoded] = W1\\n W1 += 1\\n elif J >= D1 and tk_decoded not in w2Words:\\n w2Words[tk_decoded] = W2\\n W2 += 1\\n J += 1\\n corpus.close()\\n\\n D2 = J - D1\\n\\n # Partition the corpus into a L-shaped matrix\\n sys.stderr.write(\\\"Building matrices\\\")\\n At = lil_matrix((D1,W1))\\n B = lil_matrix((W1,D2))\\n Ct = lil_matrix((D2,W2))\\n\\n corpus = open(sys.argv[1],\\\"r\\\")\\n\\n j = 0\\n for line in corpus:\\n sys.stderr.write(\\\".\\\")\\n tokens = word_tokenize(line)\\n docsq = 0.\\n for token in tokens:\\n tk_decoded = token.decode(\\\"utf-8\\\")\\n if j < D1: # tk_decoded in w1words\\n tkId = w1Words[tk_decoded]\\n docsq += (At[j,tkId]+1)**2 - (At[j,tkId])**2\\n At[j,tkId] += 1.\\n elif tk_decoded in w1Words:\\n tkId = w1Words[tk_decoded]\\n docsq += (B[tkId,j-D1]+1)**2 - (B[tkId,j-D1])**2\\n B[tkId,j-D1] += 1.\\n else:\\n tkId = w2Words[tk_decoded]\\n docsq += (Ct[j-D1,tkId]+1)**2 - (Ct[j-D1,tkId])**2\\n Ct[j-D1,tkId] += 1.\\n if j < D1:\\n At[j,:] /= math.sqrt(docsq)\\n else:\\n for w in range(0,W1):\\n B[w,j-D1] /= math.sqrt(docsq)\\n Ct[j-D1,:] /= math.sqrt(docsq)\\n j += 1\\n\\n sys.stderr.write(\\\"\\\\nBuild Cn\\\\n\\\")\\n Cn = zeros((D2,1))\\n Ct = Ct.tocsr()\\n for i in range(0,D2):\\n v = ((Ct[i,:] * Ct[i,:].transpose())[0,0])\\n if v == 0:\\n Cn[i,0] = 1.\\n else:\\n Cn[i,0] = v\\n\\n # Building real matrices\\n sys.stderr.write(\\\"Calculating ATA\\\\n\\\")\\n ATA = (At * At.transpose()).todense() # D1 x D1\\n At = At.tocsr()\\n B = B.tocsc()\\n\\n sys.stderr.write(\\\"Solve inverse\\\\n\\\")\\n ATAi = linalg.inv(ATA)\\n\\n # The real calculation is that if we have input vector [ d_1 d_2 ] ^ T \\n # We yield [ (A^T * A)^-1 * A^T ( d1^T - B * (C^T * d2 / Cn) ) (C^T * d2 / Cn)\\n sys.stderr.write(\\\"Calculating projected vectors\\\\n\\\")\\n\\n out = open(sys.argv[4],\\\"w\\\")\\n testDocs = open(sys.argv[2],\\\"r\\\")\\n for testDoc in testDocs:\\n sys.stderr.write(\\\".\\\")\\n corpus = open(sys.argv[1],\\\"r\\\")\\n d1 = zeros((W1,1))\\n d2 = zeros((W2,1))\\n tokens = word_tokenize(testDoc)\\n for token in tokens:\\n tk_decoded = token.decode(\\\"utf-8\\\")\\n if tk_decoded in w1Words:\\n d1[w1Words[tk_decoded],0] += 1\\n elif tk_decoded in w2Words:\\n d2[w2Words[tk_decoded],0] += 1\\n norm = sqrt(sum(d1**2) + sum(d2**2))\\n d1 /= norm \\n d2 /= norm\\n v2 = (Ct * d2) / Cn\\n v1 = ATAi * (At * (d1 - B * v2))\\n for j in range(0,D1+D2):\\n out.write(str(j) + \\\" \\\")\\n out.write(\\\"||| \\\")\\n for j in range(0,D1):\\n out.write(str(v1[j,0]) + \\\" \\\")\\n for j in range(0,D2):\\n out.write(str(v2[j,0]) + \\\" \\\")\\n out.write(\\\"\\\\n\\\")\\n\\n out.flush()\\n out.close()\\n sys.stderr.write(\\\"\\\\n\\\")\",\n \"def test_integer_map_key_index():\\n\\tlib.backup_and_restore(\\n\\t\\tlambda context: create_indexes(lib.create_integer_map_key_index),\\n\\t\\tNone,\\n\\t\\tlambda context: check_indexes(lib.check_map_key_index, 12345)\\n\\t)\",\n \"def check_k_matrix_stability(self):\\r\\n K = self.make_k_matrix()\\r\\n vals, vects = scipy_sparse_eigens(K)\\r\\n principal_val = vals.max()\\r\\n print(\\\"ht3_solver:\\\\t'Stiffness' matrix principal eigenvalue was \\\"\\r\\n + str(principal_val))\\r\\n if principal_val > 1:\\r\\n print(\\\"##########################################################\\\")\\r\\n print(\\\"ht3_solver:\\\\tWARNING\\\")\\r\\n print(\\\"ht3_solver:\\\\tPrincipal eigenvalue is more than one.\\\")\\r\\n print(\\\"ht3_solver:\\\\tThe analysis will be unstable.\\\")\\r\\n print(\\\"ht3_solver:\\\\tIf this is OK, just go and modify the code \\\"\\r\\n + \\\"or something.\\\")\\r\\n print(\\\"##########################################################\\\")\\r\\n raise(AssertionError)\",\n \"def KS(self, using, dx=0.0001):\\n pits = np.array(self.PIT(using=using,dx=dx))\\n ks_result = skgof.ks_test(pits, stats.uniform())\\n return ks_result.statistic, ks_result.pvalue\",\n \"def test_fit_predict(is_sparse):\\n rng = np.random.RandomState(0)\\n\\n X = rng.rand(10, 2)\\n\\n if is_sparse:\\n X[X < 0.8] = 0\\n X = sp.csr_matrix(X)\\n\\n bisect_means = BisectingKMeans(n_clusters=3, random_state=0)\\n bisect_means.fit(X)\\n\\n assert_array_equal(bisect_means.labels_, bisect_means.predict(X))\",\n \"def test_continuous():\\n # assert the distribution of the samples is close to the distribution of the data\\n # using kstest:\\n # - uniform (assert p-value > 0.05)\\n # - gaussian (assert p-value > 0.05)\\n # - inversely correlated (assert correlation < 0)\",\n \"def check_seed():\\n np.random.seed(1000)\\n standard = [\\n {0: -3.0, 1: -5.0, 'index': 0},\\n {0: -6.0, 1: -8.0, 'index': 1},\\n {0: 5.0, 1: -1.0, 'index': 2},\\n {0: 1.0, 1: -7.0, 'index': 3},\\n {0: -2.0, 1: -3.0, 'index': 4},\\n {0: 7.0, 1: 3.0, 'index': 5},\\n {0: -4.0, 1: -2.0, 'index': 6},\\n {0: 2.0, 1: 6.0, 'index': 7}\\n ]\\n\\n this_machine = create_points(8)\\n\\n flag = True\\n for i in range(8) :\\n flag &= this_machine[i][0] == standard[i][0] \\n flag &= this_machine[i][1] == standard[i][1] \\n flag &= this_machine[i][\\\"index\\\"] == i\\n \\n if not flag :\\n print(\\\"\\\"\\\"\\n The Python installation on this machine is odd: it appears to\\n use a non-standard random number generator -- run \\n this script on the machines in the Otter lab instead.\\n If that fails too, send an email to ag0015@surrey.ac.uk.\\n \\\"\\\"\\\")\\n print (\\\"You got these test points:\\\", this_machine)\\n print (\\\"You should have got:\\\", standard)\\n exit(-1)\\n else :\\n print (\\\"Check passed\\\")\",\n \"def assert_stored_ks(self):\\n assert(self.ks is None or type(self.ks) in [list, np.ndarray])\\n if self.ks is not None:\\n assert(type(self.ks[0]) in inttypes)\",\n \"def test_call_low_cluster_identity(self):\\r\\n\\r\\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\\r\\n # Should only get 6 clusters\\r\\n exp_otu_ids = [str(x) for x in range(6)]\\r\\n\\r\\n exp_clusters =\\\\\\r\\n [['uclust_test_seqs_0', 'uclust_test_seqs_6',\\r\\n 'uclust_test_seqs_9'], ['uclust_test_seqs_1'], ['uclust_test_seqs_2'],\\r\\n ['uclust_test_seqs_3',\\r\\n 'uclust_test_seqs_5',\\r\\n 'uclust_test_seqs_8'],\\r\\n ['uclust_test_seqs_4'], ['uclust_test_seqs_7']]\\r\\n\\r\\n app = UsearchOtuPicker(params={'save_intermediate_files': False,\\r\\n 'db_filepath': self.tmp_ref_database,\\r\\n 'output_dir': self.temp_dir,\\r\\n 'remove_usearch_logs': True,\\r\\n 'reference_chimera_detection': False,\\r\\n 'de_novo_chimera_detection': False,\\r\\n 'cluster_size_filtering': False,\\r\\n 'minlen': 12,\\r\\n 'w': 12,\\r\\n 'minsize': 1,\\r\\n 'percent_id': 0.80,\\r\\n 'percent_id_err': 0.97\\r\\n })\\r\\n\\r\\n obs = app(self.tmp_seq_filepath1)\\r\\n\\r\\n obs_otu_ids = sorted(obs.keys())\\r\\n obs_clusters = sorted(obs.values())\\r\\n # The relation between otu ids and clusters is abitrary, and\\r\\n # is not stable due to use of dicts when parsing clusters -- therefore\\r\\n # just checks that we have the expected group of each\\r\\n self.assertEqual(obs_otu_ids, exp_otu_ids)\\r\\n self.assertEqual(obs_clusters, exp_clusters)\",\n \"def test_full_house_flush_ind(self):\",\n \"def _test_once(self, data, alpha):\\n target_index, value = self._target(data)\\n\\n g = value / data.std()\\n g_test = self._get_g_test(data, alpha)\\n return target_index if g > g_test else None\",\n \"def test_missing_indices():\\n\\n data = pd.read_csv(\\n \\\"https://raw.githubusercontent.com/facebook/prophet/main/examples/example_wp_log_peyton_manning.csv\\\"\\n )\\n data[\\\"ds\\\"] = pd.to_datetime(data[\\\"ds\\\"])\\n data.set_index(\\\"ds\\\", inplace=True)\\n data.index = data.index.to_period(\\\"D\\\")\\n data.info()\\n\\n exp = TSForecastingExperiment()\\n\\n with pytest.raises(ValueError) as errmsg:\\n exp.setup(data=data, fh=365, session_id=42)\\n exceptionmsg = errmsg.value.args[0]\\n\\n assert \\\"Data has missing indices!\\\" in exceptionmsg\",\n \"def check_and_get_unresected_point(resected_kpt_idx, match, resected_idx, unresected_idx):\\n if resected_idx < unresected_idx:\\n if resected_kpt_idx == match.queryIdx:\\n unresected_kpt_idx = match.trainIdx\\n success = True\\n return unresected_kpt_idx, success\\n else:\\n return None, False\\n elif unresected_idx < resected_idx:\\n if resected_kpt_idx == match.trainIdx:\\n unresected_kpt_idx = match.queryIdx\\n success = True\\n return unresected_kpt_idx, success\\n else:\\n return None, False\",\n \"def test_no_spike_after_table(self):\\n n = 5\\n dt = 1.0\\n t_max = 2*dt\\n # make sure we have spikes at the end\\n table = np.ones((1, n))\\n\\n G = TableSpikers(n)\\n G.spike_table = table\\n\\n sim = simulation.Simulation(G, dt=dt)\\n sim.run(t_max)\\n \\n self.assertFalse(np.any(G.spike))\",\n \"def test_k_1(self):\\n knn = KNeighborsClassifier(n_neighbors=1)\\n knn.fit(X_train, y_train)\\n prediction = knn.predict(X_test)\\n\\n knn2 = Knn(n_neighbors=1)\\n knn2.fit(X_train, y_train)\\n prediction2 = knn2.predict(X_test)\\n\\n assert np.alltrue(prediction == prediction2), \\\"Error testing knn with k=1\\\"\",\n \"def test_kernel(binary_matrix, result):\\n\\n # get the kernel from the gaussian elimination.\\n pivots = (binary_matrix.T != 0).argmax(axis=0)\\n nonpivots = np.setdiff1d(range(len(binary_matrix[0])), pivots)\\n\\n kernel = []\\n for col in nonpivots:\\n col_vector = binary_matrix[:, col]\\n null_vector = np.zeros((binary_matrix.shape[1]), dtype=int)\\n null_vector[col] = 1\\n for i in pivots:\\n first_entry = np.where(binary_matrix[:, i] == 1)[0][0]\\n if col_vector[first_entry] == 1:\\n null_vector[i] = 1\\n kernel.append(null_vector.tolist())\\n\\n # get the nullspace from the _kernel function.\\n nullspace = _kernel(binary_matrix)\\n\\n for nullvec in kernel:\\n assert nullvec in nullspace.tolist()\\n\\n assert (nullspace == result).all()\",\n \"def test_dtype_preserved(is_sparse, global_dtype):\\n rng = np.random.RandomState(0)\\n X = rng.rand(10, 2).astype(global_dtype, copy=False)\\n\\n if is_sparse:\\n X[X < 0.8] = 0\\n X = sp.csr_matrix(X)\\n\\n km = BisectingKMeans(n_clusters=3, random_state=0)\\n km.fit(X)\\n\\n assert km.cluster_centers_.dtype == global_dtype\",\n \"def check_output_k(output_k):\\n if isinstance(output_k, list):\\n output_k = np.array(output_k)\\n # Check indexing is sorted increasingly\\n if not is_sorted_array(output_k, increasing=True):\\n raise ValueError(\\\"Provide output_k sorted increasingly\\\")\\n # Check output_k contains at least a 0\\n if not np.any(output_k == 0):\\n raise ValueError(\\n \\\"output_k must start with a 0 value. 0 indicates the 'current' timestep to predict.\\\"\\n )\\n return output_k\",\n \"def test_calc_kappa(test_coords):\\n assert_almost_equal(calc_kappa(53.05187), 5762.687, decimal=3)\",\n \"def test_assign_clusters_nonsparse(self, new_data, filename):\\n\\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\\n engine = create_engine(sqlalchemy_conn_str)\\n if self.split_type == 'random':\\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_random',con=engine)\\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_random',con=engine)\\n elif self.split_type == 'date':\\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_date',con=engine)\\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_date',con=engine)\\n \\n averages_seg['exists'] = 1\\n test_data_exists = pd.merge(new_data, averages_seg[['segment_id', 'day_of_week', 'time_idx', 'exists']], on=['segment_id', 'day_of_week', 'time_idx'])\\n test_exists = test_data_exists[test_data_exists['exists']==1]\\n test_notexists = test_data_exists[test_data_exists['exists']!=1]\\n \\n test_exists_tmp = test_exists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\\n test_notexists_tmp = test_notexists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\\n test_matrix_exists = pd.merge(test_exists_tmp, averages_seg, how='left', on=['segment_id', 'day_of_week', 'time_idx'])\\n test_matrix_notexists = pd.merge(test_notexists_tmp, averages_rt, how='left', on=['road_type', 'day_of_week', 'time_idx'])\\n test_matrix = pd.concat([test_matrix_exists, test_matrix_notexists])\\n test_matrix = test_matrix.fillna(0)\\n \\n test_nonsparse_matrix = test_matrix[['segment_id','date','time','date_idx', 'time_idx', 'day_of_week', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2', 'level_binary', 'level_min', 'level_max', 'level_mean', 'level_count']]\\n test_nonsparse_matrix = self.scale_matrix(test_nonsparse_matrix)\\n\\n print('clustering new data...')\\n cluster_model = joblib.load(filename)\\n cluster_predictions = cluster_model.predict(test_nonsparse_matrix.drop(columns = ['segment_id','date','time']))\\n \\n clusterdf = pd.DataFrame(cluster_predictions,columns = ['cluster_nonsparse']).reset_index()\\n keydf = test_matrix[['segment_id','date','time']].reset_index()\\n test_cluster_df_sparse = pd.merge(clusterdf, keydf, on=['index'])\\n \\n return test_cluster_df_sparse[['segment_id','date','time','cluster_nonsparse']]\",\n \"def testContains(self):\\n\\n N = randint(20,100)\\n for i in xrange(N):\\n self.s.insert(i,True)\\n N-=(i in self.s)\\n\\n self.assertEqual(N,0)\",\n \"def test_float32_float64_equivalence(is_sparse):\\n rng = np.random.RandomState(0)\\n X = rng.rand(10, 2)\\n\\n if is_sparse:\\n X[X < 0.8] = 0\\n X = sp.csr_matrix(X)\\n\\n km64 = BisectingKMeans(n_clusters=3, random_state=0).fit(X)\\n km32 = BisectingKMeans(n_clusters=3, random_state=0).fit(X.astype(np.float32))\\n\\n assert_allclose(km32.cluster_centers_, km64.cluster_centers_)\\n assert_array_equal(km32.labels_, km64.labels_)\",\n \"def cv_msk(x, k, permu=True):\\n n = x if isinstance(x, int) else len(x)\\n idx = np.array(np.arange(np.ceil(n / float(k)) * k), '<i4')\\n if permu:\\n idx = np.random.permutation(idx)\\n idx = idx.reshape(k, -1) % n\\n msk = np.zeros((k, n), 'bool')\\n for _ in range(k):\\n msk[_, idx[_, ]] = True\\n return msk\",\n \"def clustering_dbscan_o3d():\\n pass\",\n \"def kmeans_clustering(all_features, vocab_size, epsilon, max_iter):\\n\\n # Your code here. You should also change the return value.\\n\\n def _initiate_random_centroids(all_features, vocab_size):\\n \\\"\\\"\\\"\\n Initiate random centroids in the range of input\\n\\n :param all_features:\\n :param vocab_size:\\n :return:\\n \\\"\\\"\\\"\\n centroids = []\\n # 1) Genereate points for initial centroids\\n\\n min_feat = np.ones(all_features[0].size)*np.inf\\n max_feat = np.zeros(all_features[0].size)\\n\\n for a in all_features:\\n for p in range(len(a)):\\n if a[p] < min_feat[p]:\\n min_feat[p] = a[p]\\n else:\\n if a[p] > max_feat[p]:\\n max_feat[p] = a[p]\\n\\n\\n for _ in range(vocab_size):\\n random_vector = np.multiply(np.random.rand(1, all_features[0].size),\\n max_feat-min_feat) + min_feat\\n centroids.append(random_vector.flatten())\\n\\n return np.array(centroids)\\n\\n def _assign_vectors_to_nearest_centroid(all_features, centroid):\\n \\\"\\\"\\\"\\n Assign vectors to nearest centroids\\n\\n :param all_features:\\n :param centroid:\\n :return:\\n \\\"\\\"\\\"\\n #TODO: sprawdz co lepiej dziala\\n new_centroid_coor = np.zeros([len(centroid), all_features[0].size])\\n #new_centroid_coor = centroid\\n new_centroid_counter = np.zeros(len(centroid))\\n\\n dist = pdist(centroid, all_features)\\n #min_dist = dist.min(axis=0)\\n min_dist_index = dist.argmin(axis=0)\\n\\n for x in range(len(min_dist_index)):\\n id = min_dist_index[x]\\n new_centroid_coor[id] = np.add(new_centroid_coor[id],\\n all_features[x])\\n new_centroid_counter[id] += 1\\n\\n new_centroid_coor_out = []\\n for i in range(len(new_centroid_coor)):\\n if new_centroid_counter[i] == 0:\\n new_centroid_coor_out.append(centroid[i])\\n else:\\n new_centroid_coor_out.append(np.divide(new_centroid_coor[i],new_centroid_counter[i]))\\n\\n return np.array(new_centroid_coor_out), new_centroid_counter\\n\\n\\n def _check_convergence_condition(old_centroids, new_centroids, epsilon):\\n \\\"\\\"\\\"\\n Check convergence confition\\n\\n :param old_centroids:\\n :param new_centroids:\\n :param epsilon: if every centroid is moved by dist < epsilon KMeans terminates\\n :return:\\n \\\"\\\"\\\"\\n for i in range(len(old_centroids)):\\n dist = euclidean(old_centroids[i], new_centroids[i])\\n if dist > epsilon:\\n return False\\n\\n return True\\n\\n def delete_small_clusters(new_centroids, centroid_counter, threshold):\\n \\\"\\\"\\\"\\n Potential extension of the algorithm -> if there is not any point in the cluster, delete this cluste\\n\\n :param new_centroids:\\n :param centroid_counter:\\n :param threshold:\\n :return:\\n \\\"\\\"\\\"\\n\\n out_centroids = []\\n for n in range(len(new_centroids)):\\n if centroid_counter[n] > threshold:\\n out_centroids.append(new_centroids[n])\\n out_centroids = np.array(out_centroids)\\n return out_centroids\\n\\n #MAIN\\n old_centroids = _initiate_random_centroids(all_features, vocab_size)\\n\\n for _ in range(max_iter):\\n new_centroids, centroid_counter = _assign_vectors_to_nearest_centroid(all_features, old_centroids)\\n if_convergenced = _check_convergence_condition(new_centroids, old_centroids, epsilon)\\n\\n if if_convergenced == True:\\n # return centroids if algorithm is converged\\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\\n return new_centroids\\n old_centroids = new_centroids\\n\\n # return centroids if reached max_iter\\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\\n return new_centroids\",\n \"def test_index_0(self):\\n self.insert()\\n data = self.tbl[0]\\n assert self.check(self.idata[:0], data)\",\n \"def test_call_alt_threshold(self):\\r\\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\\r\\n\\r\\n exp_otu_ids = range(9)\\r\\n exp_clusters = [['uclust_test_seqs_0'],\\r\\n ['uclust_test_seqs_1'],\\r\\n ['uclust_test_seqs_2'],\\r\\n ['uclust_test_seqs_3'],\\r\\n ['uclust_test_seqs_4'],\\r\\n ['uclust_test_seqs_5'],\\r\\n ['uclust_test_seqs_6', 'uclust_test_seqs_8'],\\r\\n ['uclust_test_seqs_7'],\\r\\n ['uclust_test_seqs_9']]\\r\\n\\r\\n app = UclustOtuPicker(params={'Similarity': 0.90,\\r\\n 'suppress_sort': False,\\r\\n 'presort_by_abundance': False,\\r\\n 'save_uc_files': False})\\r\\n obs = app(self.tmp_seq_filepath1)\\r\\n obs_otu_ids = sorted(obs.keys())\\r\\n obs_clusters = sorted(obs.values())\\r\\n # The relation between otu ids and clusters is abitrary, and\\r\\n # is not stable due to use of dicts when parsing clusters -- therefore\\r\\n # just checks that we have the expected group of each\\r\\n self.assertEqual(obs_otu_ids, exp_otu_ids)\\r\\n self.assertEqual(obs_clusters, exp_clusters)\",\n \"def _set_ks_dynamic(self, ks):\\n assert(len(ks) == len(self.idxs))\\n self.ks = ks\\n if np.max(self.ks) > self._kret:\\n self._kret = np.max(self.ks)\",\n \"def test_call_low_cluster_identity(self):\\r\\n\\r\\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\\r\\n # Should only get 6 clusters\\r\\n exp_otu_ids = [str(x) for x in range(10)]\\r\\n\\r\\n exp_clusters = [['uclust_test_seqs_0'],\\r\\n ['uclust_test_seqs_1'],\\r\\n ['uclust_test_seqs_2'],\\r\\n ['uclust_test_seqs_3'],\\r\\n ['uclust_test_seqs_4'],\\r\\n ['uclust_test_seqs_5'],\\r\\n ['uclust_test_seqs_6'],\\r\\n ['uclust_test_seqs_7'],\\r\\n ['uclust_test_seqs_8'],\\r\\n ['uclust_test_seqs_9']]\\r\\n\\r\\n app = UsearchReferenceOtuPicker(\\r\\n params={'save_intermediate_files': False,\\r\\n 'db_filepath':\\r\\n self.tmp_ref_database,\\r\\n 'output_dir': self.temp_dir,\\r\\n 'remove_usearch_logs': True,\\r\\n 'reference_chimera_detection':\\r\\n False,\\r\\n 'de_novo_chimera_detection':\\r\\n False,\\r\\n 'cluster_size_filtering':\\r\\n False,\\r\\n 'minlen': 12,\\r\\n 'w': 12,\\r\\n 'minsize': 1,\\r\\n 'percent_id': 0.80,\\r\\n 'percent_id_err': 0.97\\r\\n })\\r\\n\\r\\n obs = app(self.tmp_seq_filepath1, self.tmp_otu_ref_database)\\r\\n\\r\\n obs_otu_ids = sorted(obs.keys())\\r\\n obs_clusters = sorted(obs.values())\\r\\n # The relation between otu ids and clusters is abitrary, and\\r\\n # is not stable due to use of dicts when parsing clusters -- therefore\\r\\n # just checks that we have the expected group of each\\r\\n self.assertEqual(obs_otu_ids, exp_otu_ids)\\r\\n self.assertEqual(obs_clusters, exp_clusters)\",\n \"def KS(dataDict=None, dataLabel='data', mode='two.sided'):\\n\\n # test calling values\\n modes = ['two.sided', 'less', 'greater']\\n if mode not in modes:\\n raise ValueError('RSTATS.KS: mode must be in: ', modes)\\n if (dataDict is None or not isinstance(dataDict, dict) \\n or len(dataDict.keys()) != 2):\\n raise ValueError('RSTATS.KS: dataDict must be a dictionary with '\\n + 'exactly 2 keys')\\n\\n labels = list(dataDict.keys())\\n# NGroups = len(labels)\\n cmdx = 'X=c(%s)' % ', '.join(str(x) for x in dataDict[labels[0]])\\n cmdy = 'Y=c(%s)' % ', '.join(str(y) for y in dataDict[labels[1]])\\n# package \\\"perm\\\" not available on mac os x, use coin instead\\n# importr('perm')\\n robjects.r(cmdx)\\n robjects.r(cmdy)\\n\\n# (pvalue, nmc) = permutation(dataDict, dataDict.keys())\\n\\n u = robjects.r(\\\"ks.test(X, Y, alternative='%s')\\\" % mode)\\n\\n pvalue = float(u[1][0])\\n statvalue = float(u[0][0]) # get diff estimate\\n if dataLabel is not None:\\n print ('\\\\nKolmogorov-Smirnov test. Dataset = %s' % (dataLabel))\\n print(u' Test statistic: {:8.4f}'.format(statvalue))\\n print(u' p={:8.6f}, [mode={:s}]'.format(float(pvalue), mode))\\n return pvalue\",\n \"def vectorized(self):\\n return False\",\n \"def test_correct_spiking(self):\\n n = 10\\n t_max = 25.0\\n dt = 0.2\\n p = 0.05\\n\\n # some reproducible arbitrariness\\n np.random.seed(622312)\\n n_steps = int_r(t_max/dt)\\n table = np.random.rand(n_steps, n) < p\\n\\n G = TableSpikers(n)\\n G.spike_table = copy.copy(table)\\n\\n class SimpleMonitor(object):\\n def __init__(self, target):\\n self.target = target;\\n self.results = []\\n self.order = 1\\n\\n def evolve(self, t, dt):\\n idxs = self.target.spike.nonzero()[0]\\n self.results.extend([(int_r(t/dt), i) for i in idxs])\\n\\n M = SimpleMonitor(G)\\n sim = simulation.Simulation(G, M, dt=dt)\\n sim.run(t_max)\\n\\n expected = zip(*table.nonzero())\\n\\n self.assertSequenceEqual(expected, M.results)\",\n \"def test02(self):\\n a = np.arange(1, 1e5) < 0\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()\\n cwt = [i for i in b.wheretrue()]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()\\n # print \\\"where ->\\\", [i for i in b.wheretrue()]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def test_setitem_other(self):\\n random.seed(12345)\\n\\n nside_coverage = 32\\n nside_map = 128\\n\\n full_map = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\\n full_map[0: 5000] = random.random(size=5000)\\n\\n sparse_map = healsparse.HealSparseMap(healpix_map=full_map, nside_coverage=nside_coverage)\\n\\n indices = (1, 2, 3, 4)\\n self.assertRaises(IndexError, sparse_map.__setitem__, indices, 1.0)\\n\\n indices = 5.0\\n self.assertRaises(IndexError, sparse_map.__setitem__, indices, 1.0)\",\n \"def test_setitem_bool(self):\\n random.seed(12345)\\n nside_coverage = 32\\n nside_map = 128\\n pxnums = np.arange(0, 2000)\\n pxvalues = np.ones(pxnums.size, dtype=bool)\\n full_map = np.zeros(hpg.nside_to_npixel(nside_map), dtype=bool)\\n full_map[pxnums] = pxvalues\\n\\n sparse_map = healsparse.HealSparseMap.make_empty(nside_coverage=nside_coverage,\\n nside_sparse=nside_map, dtype=pxvalues.dtype)\\n\\n sparse_map[pxnums[0]] = pxvalues[0]\\n testing.assert_equal(sparse_map[pxnums[0]], full_map[pxnums[0]])\\n\\n sparse_map[int(pxnums[1])] = bool(pxvalues[1])\\n testing.assert_equal(sparse_map[pxnums[1]], full_map[pxnums[1]])\\n\\n sparse_map[pxnums] = pxvalues\\n testing.assert_array_almost_equal(sparse_map[pxnums], full_map[pxnums])\",\n \"def test_identity_function(data_and_labels):\\n input_data = data_and_labels[0]\\n\\n output_data = unprotected_query(input_data)\\n\\n np.testing.assert_array_equal(input_data, output_data)\",\n \"def testAlphaTwoSamplesMatchANormalDistribution(self):\\n num_samples = 16384\\n scale = 1.7\\n rng = random.PRNGKey(0)\\n samples = self._distribution.draw_samples(rng, 2 * jnp.ones(num_samples),\\n scale * jnp.ones(num_samples))\\n # Perform the Kolmogorov-Smirnov test against a normal distribution.\\n ks_statistic = scipy.stats.kstest(samples, 'norm', (0., scale)).statistic\\n self.assertLess(ks_statistic, 0.01)\",\n \"def test_PerfectModel_verify_comparison_keyerrors(\\n perfectModelEnsemble_initialized_control, comparison\\n):\\n with pytest.raises(KeyError) as excinfo:\\n perfectModelEnsemble_initialized_control.verify(\\n comparison=comparison,\\n metric=\\\"mse\\\",\\n dim=[],\\n )\\n assert \\\"Specify comparison from\\\" in str(excinfo.value)\",\n \"def k_nearest_neighbors(x_test, df_training, k):\\n\\n return np.argpartition(distance_to_each_training_point(x_test,\\n df_training), k-1)[:,0:k]\",\n \"def test_kernel_matrix(kernel, sample):\\n sample = [ele for ele in sample] # consumed several times\\n\\n potato = KernelMethod(kernel)\\n mat = potato.matrix(sample)\\n assert np.all(np.linalg.eigvals(mat) > 0) or np.isclose(\\n [np.min(np.linalg.eigvals(mat))], [0]\\n )\",\n \"def ks_permutation(df, test, depend, N=100):\\n df_miss = df.assign(test_is_null=df[test].isnull()) # Convert to True/False\\n \\n gpA = df.loc[df_miss['test_is_null'], depend]\\n gpB = df.loc[~df_miss['test_is_null'], depend]\\n obs_ks, p_val = ks_2samp(gpA, gpB) # Get the ks observed value\\n \\n kslist = []\\n for _ in range(N):\\n\\n # shuffle the dependent column\\n shuffled_dep = (\\n df_miss[depend]\\n .sample(replace=False, frac=1)\\n .reset_index(drop=True)\\n )\\n\\n # \\n shuffled = (\\n df_miss\\n .assign(**{'Shuffled ' + depend: shuffled_dep})\\n )\\n\\n ks, _ = ks_2samp(\\n shuffled.loc[shuffled['test_is_null'], 'Shuffled ' + depend],\\n shuffled.loc[~shuffled['test_is_null'], 'Shuffled ' + depend]\\n )\\n\\n # add it to the list of results\\n kslist.append(ks)\\n \\n # pd.Series(kslist).plot(kind='hist', density=True, alpha=0.8)\\n # plt.scatter(obs_ks, 0, color='red', s=40);\\n \\n # return np.min([np.count_nonzero(kslist >= obs_ks) / len(kslist), np.count_nonzero(kslist <= obs_ks) / len(kslist)])\\n return np.count_nonzero(np.array(kslist) >= obs_ks) / len(kslist) #, np.count_nonzero(kslist <= obs_ks) / len(kslist)])\",\n \"def testAccidentalHitRemoval(self):\\n np.random.seed(0)\\n num_classes = 5\\n batch_size = 3\\n sampled = [1, 0, 2, 3]\\n\\n for num_true in range(1, 5):\\n labels = np.random.randint(\\n low=0, high=num_classes, size=batch_size * num_true)\\n (weights, biases, hidden_acts, sampled_vals, _,\\n _) = self._GenerateTestData(\\n num_classes=num_classes,\\n dim=10,\\n batch_size=batch_size,\\n num_true=num_true,\\n labels=labels,\\n sampled=sampled,\\n subtract_log_q=False)\\n logits_tensor, _ = _compute_sampled_logits(\\n weights=constant_op.constant(weights),\\n biases=constant_op.constant(biases),\\n labels=constant_op.constant(\\n labels, dtype=dtypes.int64, shape=(batch_size, num_true)),\\n inputs=constant_op.constant(hidden_acts),\\n num_sampled=len(sampled),\\n num_classes=num_classes,\\n num_true=num_true,\\n sampled_values=sampled_vals,\\n subtract_log_q=False,\\n remove_accidental_hits=True,\\n partition_strategy=\\\"div\\\",\\n name=\\\"sampled_logits_accidental_hit_removal_num_true_%d\\\" % num_true)\\n # Test that the exponentiated logits of accidental hits are near 0.\\n # First we need to find the hits in this random test run:\\n labels_reshape = labels.reshape((batch_size, num_true))\\n got_logits = self.evaluate(logits_tensor)\\n for row in range(batch_size):\\n row_labels = labels_reshape[row, :]\\n for col in range(len(sampled)):\\n if sampled[col] in row_labels:\\n # We need to add the num_true_test offset into logits_*\\n self.assertNear(\\n np.exp(got_logits[row, col + num_true]), 0., self._eps)\",\n \"def test_hashed_feature_random_sign():\\n\\n group = Group({\\\"a\\\": Hashed(buckets=100, random_sign=True), })\\n\\n for i in range(100):\\n for j in range(100):\\n group.set(randstr(), weight=123)\\n group.push()\\n\\n array = group.array()\\n assert array.shape == (100, 100)\\n\\n pos, neg = 0, 0\\n for row in array:\\n for value in row:\\n assert value == 0 or abs(value) == 123\\n pos += int(value > 0)\\n neg += int(value < 0)\\n assert pos and neg and abs(pos - neg) < (pos + neg) * 0.1\",\n \"def test_return_sparse():\\n X = Vectorizer(strategy=\\\"bow\\\", return_sparse=True).fit_transform(X_text, y10)\\n assert all(pd.api.types.is_sparse(X[c]) for c in X.columns)\",\n \"def test_three_labels_at_k5_some_out_of_range(self):\\n predictions = [[0.5, 0.1, 0.6, 0.3, 0.8, 0.0, 0.7, 0.2, 0.4, 0.9],\\n [0.3, 0.0, 0.7, 0.2, 0.4, 0.9, 0.5, 0.8, 0.1, 0.6]]\\n top_k_predictions = [\\n [9, 4, 6, 2, 0],\\n [5, 7, 2, 9, 6],\\n ]\\n sp_labels = sparse_tensor.SparseTensorValue(\\n indices=[[0, 0], [0, 1], [0, 2], [0, 3], [1, 0], [1, 1], [1, 2], [1,\\n 3]],\\n # values -1 and 10 are outside the [0, n_classes) range and are ignored.\\n values=np.array([2, 7, -1, 8, 1, 2, 5, 10], np.int64),\\n dense_shape=[2, 4])\\n\\n # Class 2: 2 labels, 2 correct predictions.\\n self._test_streaming_sparse_precision_at_k(\\n predictions, sp_labels, k=5, expected=2.0 / 2, class_id=2)\\n self._test_streaming_sparse_precision_at_top_k(\\n top_k_predictions, sp_labels, expected=2.0 / 2, class_id=2)\\n\\n # Class 5: 1 label, 1 correct prediction.\\n self._test_streaming_sparse_precision_at_k(\\n predictions, sp_labels, k=5, expected=1.0 / 1, class_id=5)\\n self._test_streaming_sparse_precision_at_top_k(\\n top_k_predictions, sp_labels, expected=1.0 / 1, class_id=5)\\n\\n # Class 7: 1 label, 1 incorrect prediction.\\n self._test_streaming_sparse_precision_at_k(\\n predictions, sp_labels, k=5, expected=0.0 / 1, class_id=7)\\n self._test_streaming_sparse_precision_at_top_k(\\n top_k_predictions, sp_labels, expected=0.0 / 1, class_id=7)\\n\\n # All classes: 10 predictions, 3 correct.\\n self._test_streaming_sparse_precision_at_k(\\n predictions, sp_labels, k=5, expected=3.0 / 10)\\n self._test_streaming_sparse_precision_at_top_k(\\n top_k_predictions, sp_labels, expected=3.0 / 10)\",\n \"def _kmedoids_run(X, n_clusters, dist_func, max_iter=1000, verbose=True):\\n # Get initial centers\\n n_samples, n_features = len(X), 2\\n init_ids = _get_init_centers(n_clusters, X)\\n if verbose:\\n print('Initial centers are: {}'.format(init_ids))\\n centers = init_ids\\n members, costs, tot_cost, dist_mat = _get_cost(X, init_ids, dist_func)\\n cc, swapped = 0, True\\n while True:\\n swapped = False\\n for i in range(n_samples):\\n if i not in centers:\\n for j in range(len(centers)):\\n centers_ = deepcopy(centers)\\n centers_[j] = i\\n members_, costs_, tot_cost_, dist_mat_ = _get_cost(X, centers_, dist_func)\\n if tot_cost_ < tot_cost:\\n members, costs, tot_cost, dist_mat = members_, costs_, tot_cost_, dist_mat_\\n centers = centers_\\n swapped = True\\n if verbose:\\n print('Change centers to {}'.format(centers))\\n if cc > max_iter:\\n if verbose:\\n print('End Searching by reaching maximum iteration')\\n break\\n if not swapped:\\n if verbose:\\n print('End Searching by no swaps')\\n break\\n cc += 1\\n return centers, members, costs, tot_cost, dist_mat\",\n \"def ks_test(a,b):\\n a,b = np.asarray(a),np.asarray(b)\\n if len(a) != len(a):\\n raise ValueError(\\\"a and b must have the same size\\\")\\n \\n return stats.ks_2samp(a,b)\",\n \"def _test_obsdup(t):\\n return t.shape[0] != len(set(t.ids(axis='observation')))\",\n \"def test_katsuura(self):\\n fun = get_problem('katsuura', self.dimension, -100, 100)\\n self.assertAlmostEqual(fun(self.array10), 3837.4739882594373, delta=4000)\",\n \"def test_daal_pca_invalid_k(self):\\n with self.assertRaisesRegexp(Exception, \\\"k must be smaller than the number of observation columns\\\"):\\n self.context.daaltk.models.dimreduction.pca.train(self.frame,\\n [\\\"X1\\\", \\\"X2\\\", \\\"X3\\\", \\\"X4\\\", \\\"X5\\\",\\n \\\"X6\\\", \\\"X7\\\", \\\"X8\\\", \\\"X9\\\", \\\"X10\\\"],\\n k=0)\",\n \"def test_on_map_of_0s(synthetic_checkerboard):\\n img = synthetic_checkerboard['img']\\n di = np.zeros_like(img)\\n\\n cpp_vorimg = tess.tessellate_labimg(img,di)\\n\\n py_vorimg = pytess.tessellate_labimg(img,di)\\n assert np.alltrue(py_vorimg[:4,:4] == 1)\\n printers.store_ndarray(\\\"py_voronoi_on_map_of_0s_output.txt\\\",py_vorimg)\\n\\n assert cpp_vorimg.size > 0\\n assert cpp_vorimg.shape == synthetic_checkerboard['img'].shape\\n assert np.alltrue(synthetic_checkerboard['img'][1:3,1:3] == 1)\\n\\n printers.store_ndarray(\\\"cpp_voronoi_input.txt\\\",img)\\n printers.store_ndarray(\\\"cpp_voronoi_on_map_of_0s_output.txt\\\",cpp_vorimg)\\n\\n assert np.alltrue(cpp_vorimg[:4,:4] == 1)\\n assert np.alltrue(cpp_vorimg == py_vorimg)\",\n \"def test_getitem_array(self):\\n random.seed(12345)\\n\\n nside_coverage = 32\\n nside_map = 128\\n\\n full_map = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\\n full_map[0: 5000] = random.random(size=5000)\\n\\n sparse_map = healsparse.HealSparseMap(healpix_map=full_map, nside_coverage=nside_coverage)\\n\\n indices = np.array([1, 2, 100, 500, 10000])\\n testing.assert_array_almost_equal(sparse_map[indices], full_map[indices])\\n testing.assert_almost_equal(sparse_map[indices[0]], full_map[indices[0]])\\n\\n indices = np.array([1., 2, 100, 500, 10000])\\n self.assertRaises(IndexError, sparse_map.__getitem__, indices)\\n self.assertRaises(IndexError, sparse_map.__getitem__, indices[0])\",\n \"def test_index_geq_3(self):\\n self.insert()\\n data = self.tbl[6:]\\n assert self.check(self.idata[2:], data)\",\n \"def test_fit_ks(distribution):\\n print(\\\"TESTING: K-S fit for %s distribution\\\" % distribution.upper())\\n print(\\\" fitting to others\\\")\\n for sample_dist in dist.get():\\n print(\\\" %s\\\" % sample_dist.upper())\\n params = dist.DISTRIBUTIONS[sample_dist][dist.KEY_TEST_PARAMS]\\n test_sample = dist.samples(sample_dist, params)\\n fit_results = fit.fit_ks(distribution, test_sample)\\n print(\\\" input parameters: %s\\\" % dist.get_params(params, sample_dist))\\n print(\\\" fit parameters: %s\\\" % dist.get_params(fit_results['params'], distribution))\\n print(\\\" log-likelihood: %r\\\" % fit_results['log-likelihood'])\\n print(\\\" K-S statistics: %r\\\" % fit_results['D'])\",\n \"def test_extreme_neighborhoods(self):\\n\\n ## Radius = 0 ==> all points are noise\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.0,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 0)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"noise\\\"), self.n)\\n\\n ## Min_neighbors > 30 ==> all points are noise\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.0,\\n min_core_neighbors=31,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 0)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"noise\\\"), self.n)\\n\\n ## Radius very large ==> all points are core points\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=100.0,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 1)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"core\\\"), self.n)\\n\\n ## Min_neighbors = 0 ==> all points are core points\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.5,\\n min_core_neighbors=0,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 1)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"core\\\"), self.n)\",\n \"def test00(self):\\n a = np.arange(1, 11) > 0\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()\\n cwt = [i for i in b.wheretrue()]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()\\n # print \\\"where ->\\\", [i for i in b.wheretrue()]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def test_sparse_distance_matrix(coordinates, max_dist, p):\\n original_tree = scipyKDTree(coordinates)\\n redis_tree = redisKDTree(coordinates)\\n\\n original_output = original_tree.sparse_distance_matrix(original_tree, max_dist, p)\\n redis_output = redis_tree.sparse_distance_matrix(redis_tree, max_dist, p)\\n\\n assert dict_close(redis_output, original_output)\",\n \"def test_knu(self):\\n x = self.x\\n result = bessel_sk.lnknu(x, self.maxorder)\\n k_exp = [14.2670922632, 28.082603821, 172.7219309,\\n 1825.996042640, 20431.0266426932]\\n for i, l in enumerate(self.orders):\\n assert_almost_equal(result[0,l]/k_exp[i], 1)\",\n \"def storage_init(index):\\n i, t = index[0], 0\\n return (\\n storage_state[i, t]\\n == storage_start_state[i]\\n + storage_para[i].eta_ch * storage_ch[i, t]\\n - 1 / storage_para[i].eta_disch * storage_disch[i, t]\\n )\",\n \"def test_ks_ms(distribution):\\n print(\\\"TESTING: K-S model selection for %s distribution\\\" % distribution.upper())\\n params = dist.DISTRIBUTIONS[distribution][dist.KEY_TEST_PARAMS]\\n print(\\\" creating sample\\\")\\n test_sample = dist.samples(distribution, params)\\n print(\\\" calculating K-S statistics for all distributions\\\")\\n print(\\\" input parameters: %s\\\" % dist.get_params(params, distribution))\\n fit_results = {}\\n best_ksd = 1.0\\n best_model = dist.get()[0]\\n for d in dist.get():\\n print(\\\" %s:\\\" % d.upper())\\n fit_results[d] = fit.fit_ks(d, test_sample)\\n if fit_results[d]['D'] < best_ksd:\\n best_ksd = fit_results[d]['D']\\n best_model = d\\n print(\\\" %s\\\" % dist.get_params(fit_results[d]['params'], d))\\n print(\\\" D = %r\\\" % fit_results[d]['D'])\\n params = fit_results[d]['params']\\n p = 0\\n for r in range(100):\\n synthetic_sample = dist.samples(d, params, len(test_sample))\\n ksd = me.ks_statistics(dist.get_sample_cdf(synthetic_sample), dist.cdf(d, params, np.max(synthetic_sample)))\\n if ksd > fit_results[d]['D']:\\n p += 1\\n print(\\\" p = %r\\\" % (float(p)/100.0))\\n print(\\\" Best fitting model: %s\\\" % best_model.upper())\\n print_pmfs(test_sample, fit_results, 'TEST-KS.CSV')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8165338","0.746027","0.6211018","0.61494595","0.5980731","0.58581066","0.58403915","0.58055747","0.5776113","0.57654226","0.5763633","0.57397044","0.5628826","0.55964756","0.55854005","0.55454636","0.5536922","0.5515122","0.5509714","0.5504265","0.54790556","0.54733723","0.547315","0.5455367","0.54419076","0.54381555","0.534297","0.5335604","0.5334497","0.5320086","0.531226","0.53095263","0.53026766","0.52716666","0.5266544","0.52489024","0.5239299","0.52280134","0.5212457","0.5193732","0.51902854","0.5175551","0.5164209","0.51558495","0.5149334","0.51475626","0.51447916","0.51428336","0.51333004","0.5129793","0.5128806","0.5128669","0.5124218","0.5118625","0.5115315","0.5103521","0.5103245","0.51032054","0.5098298","0.50927293","0.5091181","0.509032","0.50894374","0.50881076","0.5083092","0.5079368","0.50738645","0.5061513","0.5057109","0.50548726","0.50544083","0.5052103","0.5051661","0.5051051","0.5050724","0.504852","0.5048212","0.50446767","0.50404817","0.5040096","0.50379705","0.5033496","0.5033301","0.5031252","0.50269306","0.50218457","0.50210905","0.50147706","0.5007536","0.50073695","0.50034976","0.50033903","0.4993601","0.49923378","0.49908024","0.4985362","0.498122","0.49800566","0.49762446","0.49726152"],"string":"[\n \"0.8165338\",\n \"0.746027\",\n \"0.6211018\",\n \"0.61494595\",\n \"0.5980731\",\n \"0.58581066\",\n \"0.58403915\",\n \"0.58055747\",\n \"0.5776113\",\n \"0.57654226\",\n \"0.5763633\",\n \"0.57397044\",\n \"0.5628826\",\n \"0.55964756\",\n \"0.55854005\",\n \"0.55454636\",\n \"0.5536922\",\n \"0.5515122\",\n \"0.5509714\",\n \"0.5504265\",\n \"0.54790556\",\n \"0.54733723\",\n \"0.547315\",\n \"0.5455367\",\n \"0.54419076\",\n \"0.54381555\",\n \"0.534297\",\n \"0.5335604\",\n \"0.5334497\",\n \"0.5320086\",\n \"0.531226\",\n \"0.53095263\",\n \"0.53026766\",\n \"0.52716666\",\n \"0.5266544\",\n \"0.52489024\",\n \"0.5239299\",\n \"0.52280134\",\n \"0.5212457\",\n \"0.5193732\",\n \"0.51902854\",\n \"0.5175551\",\n \"0.5164209\",\n \"0.51558495\",\n \"0.5149334\",\n \"0.51475626\",\n \"0.51447916\",\n \"0.51428336\",\n \"0.51333004\",\n \"0.5129793\",\n \"0.5128806\",\n \"0.5128669\",\n \"0.5124218\",\n \"0.5118625\",\n \"0.5115315\",\n \"0.5103521\",\n \"0.5103245\",\n \"0.51032054\",\n \"0.5098298\",\n \"0.50927293\",\n \"0.5091181\",\n \"0.509032\",\n \"0.50894374\",\n \"0.50881076\",\n \"0.5083092\",\n \"0.5079368\",\n \"0.50738645\",\n \"0.5061513\",\n \"0.5057109\",\n \"0.50548726\",\n \"0.50544083\",\n \"0.5052103\",\n \"0.5051661\",\n \"0.5051051\",\n \"0.5050724\",\n \"0.504852\",\n \"0.5048212\",\n \"0.50446767\",\n \"0.50404817\",\n \"0.5040096\",\n \"0.50379705\",\n \"0.5033496\",\n \"0.5033301\",\n \"0.5031252\",\n \"0.50269306\",\n \"0.50218457\",\n \"0.50210905\",\n \"0.50147706\",\n \"0.5007536\",\n \"0.50073695\",\n \"0.50034976\",\n \"0.50033903\",\n \"0.4993601\",\n \"0.49923378\",\n \"0.49908024\",\n \"0.4985362\",\n \"0.498122\",\n \"0.49800566\",\n \"0.49762446\",\n \"0.49726152\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7853589"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":83165,"cells":{"query":{"kind":"string","value":"Test KS test for insertion indices with empty input array"},"document":{"kind":"string","value":"def test_ks_test_empty_indices():\n out = compute_indices_ks_test([], 1000, mode=\"D+\")\n assert all(o is None for o in out)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_ks_test(mode):\n indices = np.random.randint(0, 1000, 1000)\n out = compute_indices_ks_test(indices, 1000, mode=mode)\n assert all([o > 0.0 for o in out])","def test_ks_test_undefined_mode():\n indices = np.random.randint(0, 1000, 1000)\n with pytest.raises(RuntimeError):\n compute_indices_ks_test(indices, 1000, mode=\"two-sided\")","def test_optimalk_cluster_array_empty_error():\n from sklearn.datasets.samples_generator import make_blobs\n from gap_statistic import OptimalK\n\n # Create optimalK instance\n optimalK = OptimalK(parallel_backend=None, n_jobs=-1)\n\n # Create data\n X, y = make_blobs(n_samples=int(1e3), n_features=2, centers=3)\n\n with pytest.raises(ValueError) as excinfo:\n optimalK(X, cluster_array=[])\n assert 'The supplied cluster_array has no values.' in str(excinfo.value)","def _assert_ks_postformat(self):\n if type(self.idxs) in [list, np.ndarray]:\n if self.ks is None:\n if self.staticneighs:\n pass\n else:\n self.ks = range(len(self.idxs))\n if self.staticneighs:\n pass\n else:\n# print self.ks, self.idxs, self.set_neighs, self.set_sp_rel_pos\n assert(len(self.ks) == len(self.idxs))\n ## Defining functions\n if self.sp_relative_pos is not None and self.staticneighs:\n self.get_sp_rel_pos = self._static_get_rel_pos\n elif not self.staticneighs:\n if type(self.sp_relative_pos) == list:\n self.get_sp_rel_pos = self._dynamic_rel_pos_list\n else:\n self.get_sp_rel_pos = self._dynamic_rel_pos_array\n if self.sp_relative_pos is None:\n self.set_sp_rel_pos = self._null_set_rel_pos\n self.get_sp_rel_pos = self._null_get_rel_pos\n ## Ensure correct k_ret\n if np.max(self.ks) > self._kret:\n self._kret = np.max(self.ks)","def test_optimalk_cluster_array_values_error():\n from sklearn.datasets.samples_generator import make_blobs\n from gap_statistic import OptimalK\n\n # Create optimalK instance\n optimalK = OptimalK(parallel_backend=None, n_jobs=-1)\n\n # Create data\n X, y = make_blobs(n_samples=int(1e3), n_features=2, centers=3)\n\n with pytest.raises(ValueError) as excinfo:\n optimalK(X, cluster_array=[0, -1, 1, 2, 3])\n assert 'cluster_array contains values less than 1' in str(excinfo.value)","def test_k_index_xarray(index_xarray_data):\n result = k_index(index_xarray_data.isobaric, index_xarray_data.temperature,\n index_xarray_data.dewpoint)\n assert_array_almost_equal(result,\n np.array([[[312., 311., 310.], [309., 308., 307.]]]) * units.K)","def test_jaccard_index_all_zeros_compiled():\n vector1 = np.array([0, 0, 0, 0])\n vector2 = np.array([1, 1, 1, 1])\n score11 = jaccard_index(vector1, vector1)\n score12 = jaccard_index(vector1, vector2)\n score22 = jaccard_index(vector2, vector2)\n\n assert score11 == score12 == 0.0, \"Expected different score.\"\n assert score22 == 1.0, \"Expected different score.\"","def check_k_anonymity(data: np.ndarray, k: int, qi_indices=None):\n print(Counter(str(e) for e in data[:, qi_indices]))\n\n occurrences = list(Counter(str(e) for e in data[:, qi_indices]).values())\n for j in range(len(occurrences)):\n if occurrences[j] < k:\n return False\n return True","def test_jaccard_index_all_zeros():\n vector1 = np.array([0, 0, 0, 0])\n vector2 = np.array([1, 1, 1, 1])\n score11 = jaccard_index.py_func(vector1, vector1)\n score12 = jaccard_index.py_func(vector1, vector2)\n score22 = jaccard_index.py_func(vector2, vector2)\n\n assert score11 == score12 == 0.0, \"Expected different score.\"\n assert score22 == 1.0, \"Expected different score.\"","def test_sparse():\n\n rng = np.random.RandomState(0)\n\n X = rng.rand(20, 2)\n X[X < 0.8] = 0\n X_csr = sp.csr_matrix(X)\n\n bisect_means = BisectingKMeans(n_clusters=3, random_state=0)\n\n bisect_means.fit(X_csr)\n sparse_centers = bisect_means.cluster_centers_\n\n bisect_means.fit(X)\n normal_centers = bisect_means.cluster_centers_\n\n # Check if results is the same for dense and sparse data\n assert_allclose(normal_centers, sparse_centers, atol=1e-8)","def test_search_array_not_found(self):\r\n self.assertEqual(search_array([6, 4, 9, 10], 15), -1)","def test_index_0(self):\n self.insert()\n data = self.tbl[0]\n assert self.check(self.idata[:0], data)","def test_single_run(self):\n\n traces = np.load('data/traces.npy')\n keys = np.load('data/key.npy')\n plain = np.load('data/plain.npy')\n correct_indices = [4254, 4257, 1400, 4429, 4919, 1399, 4918, 1398, 4917, 1397]\n\n indices = SOSTD.list_of_best_indices(traces, keys, plain, 10, 0)\n self.assertTrue(np.array_equal(indices, correct_indices))","def _check_no_empty_cluster(labels, n_clusters):\n\n for k in range(n_clusters):\n if np.sum(labels == k) == 0:\n raise EmptyClusterError","def test_nonzero(self):\n self.assertFalse(djset())\n self.assertTrue(djset([1, 2, 3]))\n self.assertTrue(djset([1, 2, 3], [4, 5, 6]))\n self.assertTrue(djset([1, 2, 3], [4, 5, 6], [5, 6]))","def test_empty_input(self):\n discs = calc_disc(np.column_stack((np.ones(0), np.ones(0), np.ones(0))))\n np.testing.assert_almost_equal(discs, np.array([]))","def test_eigenvalues_of_too_few_points_results_in_0():\n a = np.array([5])\n pc = create_point_cloud(a, a, a)\n\n compute_features(pc, [[0]], pc, [\"eigenv_1\", \"eigenv_2\", \"eigenv_3\"], InfiniteCylinder(5))\n\n eigen_val_123 = np.array([pc[keys.point]['eigenv_{}'.format(i)]['data'] for i in [1, 2, 3]])\n assert not np.any(np.isnan(eigen_val_123))\n assert not np.any(np.isinf(eigen_val_123))","def test_spike(self):\n\n arr = [10, 12, 999.99, 13, 15, 40, 9, 9]\n\n # First and last elements should always be good data, unless someone\n # has set a threshold to zero.\n expected = [1, 4, 4, 4, 1, 3, 1, 1]\n\n inputs = [\n arr,\n np.asarray(arr, dtype=np.floating),\n dask_arr(np.asarray(arr, dtype=np.floating))\n ]\n for i in inputs:\n npt.assert_array_equal(\n qartod.spike_test(\n inp=i,\n suspect_threshold=self.suspect_threshold,\n fail_threshold=self.fail_threshold\n ),\n expected\n )","def test_get_indices_no_items_to_search(self):\r\n item_to_find = []\r\n self.assertEqual(_get_indices(self.dist_matrix_header, item_to_find),\r\n [])\r\n item_to_find = ''\r\n self.assertEqual(_get_indices(self.dist_matrix_header, item_to_find),\r\n [])\r\n item_to_find = None\r\n self.assertEqual(_get_indices(self.dist_matrix_header, item_to_find),\r\n [])","def sparse(n, k):\n z = np.zeros(n)\n for i in np.random.choice( np.arange(n), k, replace=None ): # supports of nonzero entries\n z[i] = np.random.randn()\n return z","def testContains(self):\n\n N = randint(20,100)\n for i in xrange(N):\n self.s.insert(i,True)\n N-=(i in self.s)\n\n self.assertEqual(N,0)","def check_output_k(output_k):\n if isinstance(output_k, list):\n output_k = np.array(output_k)\n # Check indexing is sorted increasingly\n if not is_sorted_array(output_k, increasing=True):\n raise ValueError(\"Provide output_k sorted increasingly\")\n # Check output_k contains at least a 0\n if not np.any(output_k == 0):\n raise ValueError(\n \"output_k must start with a 0 value. 0 indicates the 'current' timestep to predict.\"\n )\n return output_k","def count_nonzero(tensor):\n raise NotImplementedError","def test_jw_sparse_index(self):\n expected = [1, 2]\n calculated_indices = jw_number_indices(1, 2)\n self.assertEqual(expected, calculated_indices)\n\n expected = [3]\n calculated_indices = jw_number_indices(2, 2)\n self.assertEqual(expected, calculated_indices)","def test_batch_missing_data():\n\n\n def fx(x, dt):\n F = np.array([[1, dt, 0, 0],\n [0, 1, 0, 0],\n [0, 0, 1, dt],\n [0, 0, 0, 1]], dtype=float)\n\n return np.dot(F, x)\n\n def hx(x):\n return np.array([x[0], x[2]])\n\n\n dt = 0.1\n points = MerweScaledSigmaPoints(4, .1, 2., -1)\n kf = UKF(dim_x=4, dim_z=2, dt=dt, fx=fx, hx=hx, points=points)\n\n\n kf.x = np.array([-1., 1., -1., 1])\n kf.P*=0.0001\n\n zs = []\n for i in range(20):\n z = np.array([i+randn()*0.1, i+randn()*0.1])\n zs.append(z)\n\n zs[2] = None\n Rs = [1]*len(zs)\n Rs[2] = None\n Ms, Ps = kf.batch_filter(zs)","def test_nan_keyword(self):\n # If array has any nan's then the output will return all zeros\n array = self.array1.copy()\n array[0,0] = numpy.nan\n byt = bytscl(array, nan=True)\n total = numpy.sum(byt)\n self.assertTrue(total != 0)","def get_first_valid_idx(input_k):\n past_idxs = input_k[input_k < 0]\n if past_idxs.size == 0: # empty\n past_idxs = 0\n else:\n past_idxs = abs(min(past_idxs))\n return past_idxs","def test_optimalk_cluster_array_vs_data_sizes_error():\n import numpy as np\n from sklearn.datasets.samples_generator import make_blobs\n from gap_statistic import OptimalK\n\n # Create optimalK instance\n optimalK = OptimalK(parallel_backend=None, n_jobs=-1)\n\n # Create data\n X, y = make_blobs(n_samples=5, n_features=2, centers=3)\n\n with pytest.raises(ValueError) as excinfo:\n optimalK(X, cluster_array=np.arange(1, 10))\n assert 'The number of suggested clusters to try' in str(excinfo.value)","def kronecker_imp(t):\n return np.where(t == 0, 1, 0)","def test_key_predicate(datum):\n return 0 < datum","def test_single_run_sosd(self):\n\n traces = np.load('data/traces.npy')[:1000]\n keys = np.load('data/key.npy')[:1000]\n plain = np.load('data/plain.npy')[:1000]\n correct_indices = [4371, 2401, 2402, 4878, 4370, 4877, 4882, 4369, 4881, 2723]\n\n indices = SOSTD.list_of_best_indices(traces, keys, plain, 10, 0, False)\n self.assertTrue(np.array_equal(indices, correct_indices))","def main_eaftest(point_ind, permutations=10240, alpha=0.05):\n \n # ------ Attainment indicator values information ------\n \n npoints = len(point_ind)\n nvars = len(point_ind[0]) # Número de execuções total\n nruns = nvars // 2 # Número de execuções de 1 algo\n \n print \"- Attainment indicator values information:\"\n print \" * Number of points:\", npoints\n print \" * Joint executions:\", nvars, \"(%d + %d)\" % (nruns, nruns)\n print\n \n assert nvars % 2 == 0, \"Number of total joint executions must be even.\"\n assert nvars <= 64, \"Not implemented with more than 64 joint executions.\"\n \n # ------ Test Statistic ------\n\n print \"- Computing the test statistic...\" \n stat2 = libaft.ksstat(point_ind, order=2)\n print \" * Test statistic = %d/%d\" % (stat2, nruns)\n print \" = %f\" % (stat2 / float(nruns)), '\\n'\n \n # ------ Estimate null distribution ------\n\n print \"- Using %d random permutations to estimate null distribution.\" % permutations\n print \" Please be patient...\"\n maxdist = np.zeros(permutations, dtype=np.int32) # Max distance array\n rtime = time.time()\n \n masks = bintools.make_masks(permutations, nvars, seed=64)\n for i, maxd in enumerate(KERNEL.runkernel(point_ind, masks)):\n maxdist[i] = maxd\n if (i+1) % (permutations//20) == 0:\n print \" %6d permutations, %7.3f sec\" % (i+1, time.time()-rtime)\n print \" * Time elapsed: %7.3f\" % (time.time()-rtime)\n \n # Compute null distribution from max distance array\n tail = np.bincount(maxdist, minlength=nruns+1)\n print \" * Non-normalized null distribution:\"\n print tail\n print\n \n # ------ Accept/reject null hypothesis ------\n \n # NB: -1 resulta das diferentes convenções para a definição de valor crítico\n crit = criticalvalue(tail, alpha * permutations) - 1\n pval = pvalue(tail, stat2) / float(permutations)\n \n print \"- Null hypothesis decision:\" \n print \" * Critical value = %d/%d\" % (crit, nruns)\n print \" = %f\" % (crit / float(nruns))\n print \" * p-value = %f\" % pval\n if pval <= alpha:\n print \" <= alpha (%s)\\n\" % alpha\n print \" * Decision: REJECT the null hypothesis\"\n else:\n print \" > alpha (%s)\\n\" % alpha\n print \" * Decision: do NOT REJECT the null hypothesis\"\n print","def test_getitem_array(self):\n random.seed(12345)\n\n nside_coverage = 32\n nside_map = 128\n\n full_map = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\n full_map[0: 5000] = random.random(size=5000)\n\n sparse_map = healsparse.HealSparseMap(healpix_map=full_map, nside_coverage=nside_coverage)\n\n indices = np.array([1, 2, 100, 500, 10000])\n testing.assert_array_almost_equal(sparse_map[indices], full_map[indices])\n testing.assert_almost_equal(sparse_map[indices[0]], full_map[indices[0]])\n\n indices = np.array([1., 2, 100, 500, 10000])\n self.assertRaises(IndexError, sparse_map.__getitem__, indices)\n self.assertRaises(IndexError, sparse_map.__getitem__, indices[0])","def assert_stored_ks(self):\n assert(self.ks is None or type(self.ks) in [list, np.ndarray])\n if self.ks is not None:\n assert(type(self.ks[0]) in inttypes)","def testAccidentalHitRemoval(self):\n np.random.seed(0)\n num_classes = 5\n batch_size = 3\n sampled = [1, 0, 2, 3]\n\n for num_true in range(1, 5):\n labels = np.random.randint(\n low=0, high=num_classes, size=batch_size * num_true)\n (weights, biases, hidden_acts, sampled_vals, _,\n _) = self._GenerateTestData(\n num_classes=num_classes,\n dim=10,\n batch_size=batch_size,\n num_true=num_true,\n labels=labels,\n sampled=sampled,\n subtract_log_q=False)\n logits_tensor, _ = _compute_sampled_logits(\n weights=constant_op.constant(weights),\n biases=constant_op.constant(biases),\n labels=constant_op.constant(\n labels, dtype=dtypes.int64, shape=(batch_size, num_true)),\n inputs=constant_op.constant(hidden_acts),\n num_sampled=len(sampled),\n num_classes=num_classes,\n num_true=num_true,\n sampled_values=sampled_vals,\n subtract_log_q=False,\n remove_accidental_hits=True,\n partition_strategy=\"div\",\n name=\"sampled_logits_accidental_hit_removal_num_true_%d\" % num_true)\n # Test that the exponentiated logits of accidental hits are near 0.\n # First we need to find the hits in this random test run:\n labels_reshape = labels.reshape((batch_size, num_true))\n got_logits = self.evaluate(logits_tensor)\n for row in range(batch_size):\n row_labels = labels_reshape[row, :]\n for col in range(len(sampled)):\n if sampled[col] in row_labels:\n # We need to add the num_true_test offset into logits_*\n self.assertNear(\n np.exp(got_logits[row, col + num_true]), 0., self._eps)","def test_k(self):\n\n # We have a new K. It should have nothing in it.\n loc_, sloc_, test_loc, test_sloc = self.k__.get_totals()\n self.assertEqual(loc_, 0)\n self.assertEqual(sloc_, 0)\n self.assertEqual(test_loc, 0)\n self.assertEqual(test_sloc, 0)\n\n self.check_counts('zz', 0, 0, 0, 0) # not in map\n self.check_counts('py', 0, 0, 0, 0) # not in map\n\n self.k__.add_counts('py', 7, 3)\n self.check_counts('py', 7, 3, 0, 0)\n self.k__.add_counts('py', 5, 2)\n self.check_counts('py', 12, 5, 0, 0)\n\n self.k__.add_test_counts('py', 8, 4)\n self.check_counts('py', 12, 5, 8, 4)\n self.k__.add_test_counts('py', 9, 3)\n self.check_counts('py', 12, 5, 17, 7)\n\n expected = \"py:%d/%d T%.1f%%\" % (12 + 17, 5 + 7, 700.0 / 12)\n # DEBUG\n # print(\"Expected: %s\" % expected)\n # END\n self.assertEqual(self.k__.pretty_counts('py'), expected)","def test_empty_input(self):\n discs = calc_disc_c(np.ones(0), np.ones(0), np.ones(0), 0.3)\n np.testing.assert_almost_equal(discs, np.array([]))","def test_no_spike_after_table(self):\n n = 5\n dt = 1.0\n t_max = 2*dt\n # make sure we have spikes at the end\n table = np.ones((1, n))\n\n G = TableSpikers(n)\n G.spike_table = table\n\n sim = simulation.Simulation(G, dt=dt)\n sim.run(t_max)\n \n self.assertFalse(np.any(G.spike))","def check_none_zero_values(self):\n hits = -1\n if (len(self.data.shape) == 3):\n hits = 0\n frames = self.data.shape[0]\n pixels = self.data.shape[1]\n bins = self.data.shape[2]\n for i in range(frames):\n for j in range(pixels):\n for k in range(bins):\n value = self.data[i][j][k]\n if value > 0:\n hits += 1\n print(\"self.data[{}][{}][{}]; Sum so far = {}\".format(i, j, k, hits))\n return hits","def test_k_rank_approximate(corpus):\n return","def test_k_index():\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\n 400.]) * units.hPa\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\n -23.5]) * units.degC\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\n -57.5]) * units.degC\n ki = k_index(pressure, temperature, dewpoint)\n assert_almost_equal(ki, 33.5 * units.degC, 2)","def count_nonzero(a):\n return (np.count_nonzero(a))","def ks_test(timeseries):\r\n\r\n hour_ago = time() - 3600\r\n ten_minutes_ago = time() - 600\r\n reference = scipy.array([x[1] for x in timeseries if x[0] >= hour_ago and x[0] < ten_minutes_ago])\r\n probe = scipy.array([x[1] for x in timeseries if x[0] >= ten_minutes_ago])\r\n\r\n if reference.size < 20 or probe.size < 20:\r\n return False\r\n\r\n ks_d,ks_p_value = scipy.stats.ks_2samp(reference, probe)\r\n\r\n if ks_p_value < 0.05 and ks_d > 0.5:\r\n adf = sm.tsa.stattools.adfuller(reference, 10)\r\n if adf[1] < 0.05:\r\n return True\r\n\r\n return False","def _test_obsdup(t):\n return t.shape[0] != len(set(t.ids(axis='observation')))","def test_empty(self):\n a = np.ones((3, 4, 5))\n ai = np.ones((3, 0, 5), dtype=np.intp)\n\n actual = take_along_axis(a, ai, axis=1)\n assert_equal(actual.shape, ai.shape)","def is_empty(self):\n return self.idx == 0","def test_00_create_sparse_1d_array(self):\n ncells = 100\n sparsity = 3.0 # 1 / density\n _, err = _iquery(\"create array SPARSE <v:int64>[i=0:{0}:0:5]\".format(\n ncells - 1))\n assert not err, err\n self._array_cleanups.append('SPARSE')\n _, err = _iquery(\"\"\"\n insert(\n redimension(\n apply(\n build(<i:int64>[fud=0:{0}], {1}*fud),\n (v, 1)),\n SPARSE),\n SPARSE)\"\"\".format(int(ncells / sparsity) - 1,\n int(sparsity)))\n assert not err, err\n check_v_sum('SPARSE')\n nchunks = chunk_count(vaid_of('SPARSE'))\n prt(\"SPARSE has\", nchunks, \"chunks\")","def test_sparsity_topk_mask_dykstra(self, l=1e-2):\n n = int(1e3)\n seed = np.random.RandomState(0)\n y = jnp.array(seed.randn(n))\n k = 10\n out_top_k_dykstra = sparse_soft_topk_mask_dykstra(y, k, l=l)\n self.assertAlmostEqual(\n y.argsort()[::-1][:k].sort().sum(),\n out_top_k_dykstra.argsort()[::-1][:k].sort().sum(),\n )\n self.assertAlmostEqual(len(jnp.where(out_top_k_dykstra > 0)[0]), k)","def test_insert_on_empty(empty_trie):\n empty_trie.insert('hello')\n assert 'h' in empty_trie.root.keys()\n assert empty_trie.size == 1","def test_spike_masked(self):\n\n arr = [10, 12, 999.99, 13, 15, 40, 9, 9, None, 10, 10, 999.99, 10, None]\n\n # First and last elements should always be good data, unless someone\n # has set a threshold to zero.\n expected = [1, 4, 4, 4, 1, 3, 1, 1, 9, 9, 4, 4, 4, 9]\n\n inputs = [\n arr,\n np.asarray(arr, dtype=np.floating),\n dask_arr(np.asarray(arr, dtype=np.floating))\n ]\n for i in inputs:\n npt.assert_array_equal(\n qartod.spike_test(\n inp=i,\n suspect_threshold=self.suspect_threshold,\n fail_threshold=self.fail_threshold\n ),\n expected\n )","def test_identity_function(data_and_labels):\n input_data = data_and_labels[0]\n\n output_data = unprotected_query(input_data)\n\n np.testing.assert_array_equal(input_data, output_data)","def _check_no_nonzero_features(self,\n features: np.ndarray,\n dropped_idx: np.ndarray,\n axis: Optional[int] = None):\n if axis is not None:\n # Dropped node.\n features_of_dropped_nodes = np.take(features, dropped_idx, axis=axis)\n self.assertEqual(0, np.nonzero(features_of_dropped_nodes)[0].shape[0])\n self.assertEqual(0, np.nonzero(features_of_dropped_nodes)[1].shape[0])\n else:\n # Dropped edge.\n features_of_dropped_edge = features[dropped_idx[0], dropped_idx[1]]\n self.assertEqual(0, np.nonzero(features_of_dropped_edge)[0].shape[0])","def test_shannon(self):\n c = array([5])\n self.assertFloatEqual(shannon(c), 0)\n c = array([5,5])\n self.assertFloatEqual(shannon(c), 1)\n c = array([1,1,1,1,0])\n self.assertEqual(shannon(c), 2)","def test_missing_indices():\n\n data = pd.read_csv(\n \"https://raw.githubusercontent.com/facebook/prophet/main/examples/example_wp_log_peyton_manning.csv\"\n )\n data[\"ds\"] = pd.to_datetime(data[\"ds\"])\n data.set_index(\"ds\", inplace=True)\n data.index = data.index.to_period(\"D\")\n data.info()\n\n exp = TSForecastingExperiment()\n\n with pytest.raises(ValueError) as errmsg:\n exp.setup(data=data, fh=365, session_id=42)\n exceptionmsg = errmsg.value.args[0]\n\n assert \"Data has missing indices!\" in exceptionmsg","def test_empty_input(self):\n discs = calc_disc_b(np.ones(0), np.ones(0), np.ones(0), 0.3)\n np.testing.assert_almost_equal(discs, np.array([]))","def KS_algorithm(dataset_x, dataset_y, train_size = 0.7, return_dataset = True):\n #Decide number of total samples\n n = dataset_x.shape[0]\n \n #Turn into train_size to float\n try: \n train_size = float(train_size)\n except Expection as e:\n print(e)\n \n #Jusge if the train_size is by ratio or quantity\n if 0 < train_size < 1: \n num_of_samples = round(n*train_size)\n elif 1 < train_size < 2: \n return \"Train size must be between 1 to 0 or 2 to number of total samples\" \n elif train_size == n or train_size == 1:\n return [x for x in range(n)]\n elif 2 <= train_size < n:\n num_of_samples = round(train_size)\n elif train_size > n:\n return \"Num_of_samples must be less than or equal to original number of samples\"\n \n #Create original sample index\n samples = [x for x in range(n)]\n \n #Create distance matrix\n print('Building distance matrix')\n dist_matrix = create_dist_matrix(dataset_x)\n\n #Pick first two furthest away data points\n print('Picking two furthest away samples')\n max_array = np.argmax(dist_matrix == np.max(dist_matrix), axis = 1)\n ind1 = max_array[max_array != 0][0]\n ind2 = max_array[ind1]\n\n #Initiate chosen sample list, append first two samples and remove from remaining sample list\n chosen_samples = [ind1, ind2]\n samples.remove(ind1)\n samples.remove(ind2) \n remaining_samples = num_of_samples - 2\n\n #Continue picking samples if not yet reaching target number of samples\n while remaining_samples > 0:\n sub_array = np.min(dist_matrix[:,chosen_samples], axis=1)\n chosen = np.argmax(sub_array)\n chosen_samples.append(chosen)\n samples.remove(chosen)\n remaining_samples -= 1\n \n #See if this function should return train and test set or simply index of chosen samples\n if return_dataset == True:\n not_chosen_samples = [x for x in range(n) if x not in chosen_samples]\n return dataset_x.iloc[chosen_samples,:], dataset_x.iloc[not_chosen_samples,:], dataset_y.iloc[chosen_samples,:], dataset_y.iloc[not_chosen_samples,:] \n else:\n return chosen_samples","def do_knn(x_data):\n return True","def test_fill_nnz(seed, shape):\n # Generate 4 matrices of 100x100 pixls with random density between 0 and 10%\n mats = gen_mats(seed, shape)\n nnz_union = pap.get_nnz_union(mats)\n # Check if all matrices have been filled to the sparsity of nnz_union\n for mat in mats:\n filled = pap.fill_nnz(mat, nnz_union)\n assert filled.nnz == nnz_union.shape[0]","def zero_examples(self):\n for ex in self.each_non_trivial_example():\n u = ex.start\n v = ex.end\n attempt = self.cached_test_function(\n self.buffer[:u] + hbytes(v - u) + self.buffer[v:]\n )\n\n if attempt is Overrun:\n continue\n\n in_replacement = attempt.examples[ex.index]\n used = in_replacement.length\n\n if (\n not self.__predicate(attempt)\n and in_replacement.end < len(attempt.buffer)\n and used < ex.length\n ):\n self.incorporate_new_buffer(\n self.buffer[:u] + hbytes(used) + self.buffer[v:]\n )","def test_index_start(self):\n sp_file = os.path.join(\"tests\", \"data\", \"geolife\", \"geolife_staypoints.csv\")\n sp = ti.read_staypoints_csv(sp_file, tz=\"utc\", index_col=\"id\", crs=\"epsg:4326\")\n\n # reproject to WGS_1984_UTM_Zone_49N\n sp = sp.to_crs(\"epsg:32649\")\n\n distance_metric_ls = [\"haversine\", \"euclidean\"]\n agg_level_ls = [\"dataset\", \"user\"]\n for distance_metric in distance_metric_ls:\n for agg_level in agg_level_ls:\n _, locations = sp.as_staypoints.generate_locations(\n method=\"dbscan\", epsilon=10, num_samples=1, distance_metric=distance_metric, agg_level=agg_level\n )\n assert (locations.index == np.arange(len(locations))).any()","def testAlphaZeroSamplesMatchACauchyDistribution(self):\n num_samples = 16384\n scale = 1.7\n rng = random.PRNGKey(0)\n samples = self._distribution.draw_samples(rng, jnp.zeros(num_samples),\n scale * jnp.ones(num_samples))\n # Perform the Kolmogorov-Smirnov test against a Cauchy distribution.\n ks_statistic = scipy.stats.kstest(samples, 'cauchy',\n (0, scale * jnp.sqrt(2))).statistic\n self.assertLess(ks_statistic, 0.02)","def is_empty(self):\n return ch.prod(ch.tensor(self.x.shape)).item() == 0","def ks_test_function(dim, thresh):\n def ks_test(table1, table2):\n from scipy.stats import ks_2samp\n sample1 = table1.get_cols(dim)[0]\n sample2 = table2.get_cols(dim)[0]\n if thresh != None:\n sample1[sample1<thresh] = 0\n sample2[sample2<thresh] = 0\n ks, p_ks = ks_2samp(sample1, sample2)\n return ks\n return ks_test","def test_ones(self):\n scores = np.column_stack((np.ones(10), np.ones(10), np.ones(10)))\n discs = calc_disc(scores)\n np.testing.assert_array_equal(discs, np.zeros(10))","def test_32_test_not_init_array(self):\n example = Example(groups=7, origins=5,\n init_arrays=False, threading=False)\n with pytest.raises(AttributeError):\n print(example.not_initialized_ij)","def test_32_test_not_init_array(self):\n example = Example(groups=7, origins=5,\n init_arrays=False, threading=False)\n with pytest.raises(AttributeError):\n print(example.not_initialized_ij)","def test_removing_index(self):","def _test_obssize(t):\n return t.shape[0] != len(t.ids(axis='observation'))","def testUnknownIndices(self):\n params = constant_op.constant(((0, 1, 2),))\n indices = array_ops.placeholder(dtypes.int32)\n gather_nd_t = array_ops.gather_nd(params, indices, batch_dims=1)\n shape = gather_nd_t.get_shape()\n self.assertIsNone(shape.ndims)\n self.assertIsNone(tensor_shape.dimension_value(shape[0]))","def test_negative_stop(self):\n self.assertArrayEqual(self.dset[2:-2], self.arr[2:-2])","def test_swap_k_zero_size(self):\n \n nums = []\n k = 0\n\n a1.swap_k(nums, k)\n\n self.assertEqual(nums, [])","def vectorized(self):\n return False","def test_scalar_index(self):\n dset = self.f.create_dataset('x', shape=(), dtype='f')\n out = dset[...]\n self.assertIsInstance(out, np.ndarray)\n self.assertEqual(out.shape, ())","def check_input_k(input_k, ar_iterations):\n if isinstance(input_k, list):\n input_k = np.array(input_k)\n # Check indexing is sorted increasingly\n if not is_sorted_array(input_k, increasing=True):\n raise ValueError(\"Provide input_k sorted increasingly\")\n # Checks for forecasting mode\n if ar_iterations > 0:\n if np.any(input_k == 0):\n raise ValueError(\n \"input_k contains values equal to 0. Past timesteps must be specified with negative values\"\n )\n if np.all(input_k > 0):\n raise ValueError(\"input_k requires negative values in 'forecasting' mode\")\n return input_k","def sample_noreplace(arr, n, k): \n # code from https://www.iditect.com/how-to/58566613.html\n idx = np.random.randint(len(arr) - np.arange(k), size=[n, k])\n for i in range(k-1, 0, -1):\n idx[:,i:] += idx[:,i:] >= idx[:,i-1,None]\n return np.array(arr)[idx]","def test_spike_realdata(self):\n suspect_threshold = 0.5\n fail_threshold = 1\n\n arr = [-0.189, -0.0792, -0.0122, 0.0457, 0.0671, 0.0213, -0.0488, -0.1463, -0.2438, -0.3261, -0.3871, -0.4054,\n -0.3932, -0.3383, -0.2804, -0.2347, -0.2134, -0.2347, -0.2926, -0.3597, -0.442, -0.509, 0, -0.5944,\n -0.57, -0.4267, -0.2926, -0.1585, -0.0945, -0.0762]\n\n expected = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1]\n\n inputs = [\n arr,\n np.asarray(arr, dtype=np.floating),\n dask_arr(np.asarray(arr, dtype=np.floating))\n ]\n for i in inputs:\n npt.assert_array_equal(\n qartod.spike_test(\n inp=i,\n suspect_threshold=suspect_threshold,\n fail_threshold=fail_threshold\n ),\n expected\n )","def test00(self):\n a = np.arange(1, 11) > 0\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()\n cwt = [i for i in b.wheretrue()]\n # print \"numpy ->\", a.nonzero()[0].tolist()\n # print \"where ->\", [i for i in b.wheretrue()]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def test_is_filled(self):\n n = 10\n matrix = g.np.random.uniform(size=(n + 1,) * 3) > 0.5\n not_matrix = g.np.logical_not(matrix)\n pitch = 1. / n\n origin = g.np.random.uniform(size=(3,))\n vox = g.trimesh.voxel.VoxelGrid(matrix)\n vox = vox.apply_scale(pitch).apply_translation(origin)\n not_vox = g.trimesh.voxel.VoxelGrid(not_matrix)\n not_vox = not_vox.apply_scale(pitch).apply_translation(origin)\n for a, b in ((vox, not_vox), (not_vox, vox)):\n points = a.points\n # slight jitter - shouldn't change indices\n points += (\n g.np.random.uniform(size=points.shape) - 1) * 0.4 * pitch\n g.np.random.shuffle(points)\n\n # all points are filled, and no empty points are filled\n assert g.np.all(a.is_filled(points))\n assert not g.np.any(b.is_filled(points))\n\n # test different number of dimensions\n points = g.np.stack([points, points[-1::-1]], axis=1)\n assert g.np.all(a.is_filled(points))\n assert not g.np.any(b.is_filled(points))","def _zero(array):\n a = array.ravel()\n for i in numba.prange(len(a)):\n a[i] = 0\n return True","def isEmpty(self):\n return self._N == 0","def _test_sampsize(t):\n return t.shape[1] != len(t.ids(axis='sample'))","def test_double_insert_on_empty(empty_trie):\n empty_trie.insert('hello')\n empty_trie.insert('hello')\n assert empty_trie.size == 1","def spca(a, s, k, d):\n\n p = a.shape[0]\n X = np.zeros((p, k))\n\n for l in range(k):\n # 1\n [w, V] = linalg.eigh(a)\n idx = w.argsort()\n w = w[idx]\n V = V[:, idx]\n\n # 2\n xprime, value = spannogram(V[:, -d:], w[-d:], s=s)\n X[:, l] = xprime[:, 0]\n\n # 3\n idx = np.abs(xprime).argsort(axis=0)\n for i in idx[-s:]:\n a[i, :] = 0\n a[:, i] = 0\n\n return X","def _test_once(self, data, alpha):\n target_index, value = self._target(data)\n\n g = value / data.std()\n g_test = self._get_g_test(data, alpha)\n return target_index if g > g_test else None","def test02(self):\n a = np.arange(1, 1e5) < 0\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()\n cwt = [i for i in b.wheretrue()]\n # print \"numpy ->\", a.nonzero()[0].tolist()\n # print \"where ->\", [i for i in b.wheretrue()]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def test_hashed_feature_random_sign():\n\n group = Group({\"a\": Hashed(buckets=100, random_sign=True), })\n\n for i in range(100):\n for j in range(100):\n group.set(randstr(), weight=123)\n group.push()\n\n array = group.array()\n assert array.shape == (100, 100)\n\n pos, neg = 0, 0\n for row in array:\n for value in row:\n assert value == 0 or abs(value) == 123\n pos += int(value > 0)\n neg += int(value < 0)\n assert pos and neg and abs(pos - neg) < (pos + neg) * 0.1","def isEmpty(self): # total O(1)\n return self._size == 0 #O(1)","def nnz(self):","def test_occupied1(self):\n array = np.array(['A'])\n self.assertFalse(self.tt.occupied(array, 0, 0))","def test_getitem_other(self):\n random.seed(12345)\n\n nside_coverage = 32\n nside_map = 128\n\n full_map = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\n full_map[0: 5000] = random.random(size=5000)\n\n sparse_map = healsparse.HealSparseMap(healpix_map=full_map, nside_coverage=nside_coverage)\n\n indices = (1, 2, 3, 4)\n self.assertRaises(IndexError, sparse_map.__getitem__, indices)\n\n indices = 5.0\n self.assertRaises(IndexError, sparse_map.__getitem__, indices)","def test_index_geq_3(self):\n self.insert()\n data = self.tbl[6:]\n assert self.check(self.idata[2:], data)","def test_setitem_other(self):\n random.seed(12345)\n\n nside_coverage = 32\n nside_map = 128\n\n full_map = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\n full_map[0: 5000] = random.random(size=5000)\n\n sparse_map = healsparse.HealSparseMap(healpix_map=full_map, nside_coverage=nside_coverage)\n\n indices = (1, 2, 3, 4)\n self.assertRaises(IndexError, sparse_map.__setitem__, indices, 1.0)\n\n indices = 5.0\n self.assertRaises(IndexError, sparse_map.__setitem__, indices, 1.0)","def test_insert(empty_bucket): # pylint: disable=redefined-outer-name\n for idx in range(2):\n element_number = idx + 1\n empty_bucket.insert(f\"key {element_number}\", f\"value {element_number}\")\n\n elements = list(iter(empty_bucket))\n for idx, (key, value) in enumerate(reversed(elements)):\n element_number = idx + 1\n assert key == f\"key {element_number}\"\n assert value == f\"value {element_number}\"","def test_empty_generation(self, example_staypoints):\n # the pfs would not generate staypoints with the default parameters\n sp = example_staypoints\n # select subset of sp such that no locations can be generated\n sp = sp.iloc[:3]\n\n warn_string = \"No locations can be generated, returning empty locs.\"\n with pytest.warns(UserWarning, match=warn_string):\n sp, locs = sp.as_staypoints.generate_locations(\n method=\"dbscan\", epsilon=10, num_samples=2, distance_metric=\"haversine\", agg_level=\"user\"\n )\n assert len(locs) == 0","def test_index_stability(self, example_staypoints):\n sp = example_staypoints\n sp2, locs = sp.as_staypoints.generate_locations(\n method=\"dbscan\", epsilon=10, num_samples=2, distance_metric=\"haversine\", agg_level=\"user\"\n )\n assert sp.index.equals(sp2.index)","def test01(self):\n a = np.arange(1, 11) < 0\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()\n cwt = [i for i in b.wheretrue()]\n # print \"numpy ->\", a.nonzero()[0].tolist()\n # print \"where ->\", [i for i in b.wheretrue()]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def test_fit_predict(is_sparse):\n rng = np.random.RandomState(0)\n\n X = rng.rand(10, 2)\n\n if is_sparse:\n X[X < 0.8] = 0\n X = sp.csr_matrix(X)\n\n bisect_means = BisectingKMeans(n_clusters=3, random_state=0)\n bisect_means.fit(X)\n\n assert_array_equal(bisect_means.labels_, bisect_means.predict(X))","def min_necessary_ks(Nx, Ny):\n ks = []\n arrs = []\n for kx in range(Nx):\n for ky in range(Ny):\n arr = np.outer(np.exp(2j * np.pi * kx * np.arange(Nx) / Nx),\n np.exp(2j * np.pi * ky * np.arange(Ny) / Ny))\n for arr0 in arrs:\n if np.allclose(arr0, arr) or np.allclose(arr0, arr.conjugate()):\n break\n else:\n ks.append((kx, ky))\n arrs.append(arr)\n return ks","def test_rastrigin(self):\n rastrigin = get_problem('rastrigin', dimension=self.dimension)\n self.assertEqual(rastrigin(self.array), 0.0)","def assert_uncoalesced(self, x):\n assert not x.is_coalesced()\n existing_indices = set()\n for i in range(x._nnz()):\n index = str(x._indices()[:, i])\n if index in existing_indices:\n return True\n else:\n existing_indices.add(index)"],"string":"[\n \"def test_ks_test(mode):\\n indices = np.random.randint(0, 1000, 1000)\\n out = compute_indices_ks_test(indices, 1000, mode=mode)\\n assert all([o > 0.0 for o in out])\",\n \"def test_ks_test_undefined_mode():\\n indices = np.random.randint(0, 1000, 1000)\\n with pytest.raises(RuntimeError):\\n compute_indices_ks_test(indices, 1000, mode=\\\"two-sided\\\")\",\n \"def test_optimalk_cluster_array_empty_error():\\n from sklearn.datasets.samples_generator import make_blobs\\n from gap_statistic import OptimalK\\n\\n # Create optimalK instance\\n optimalK = OptimalK(parallel_backend=None, n_jobs=-1)\\n\\n # Create data\\n X, y = make_blobs(n_samples=int(1e3), n_features=2, centers=3)\\n\\n with pytest.raises(ValueError) as excinfo:\\n optimalK(X, cluster_array=[])\\n assert 'The supplied cluster_array has no values.' in str(excinfo.value)\",\n \"def _assert_ks_postformat(self):\\n if type(self.idxs) in [list, np.ndarray]:\\n if self.ks is None:\\n if self.staticneighs:\\n pass\\n else:\\n self.ks = range(len(self.idxs))\\n if self.staticneighs:\\n pass\\n else:\\n# print self.ks, self.idxs, self.set_neighs, self.set_sp_rel_pos\\n assert(len(self.ks) == len(self.idxs))\\n ## Defining functions\\n if self.sp_relative_pos is not None and self.staticneighs:\\n self.get_sp_rel_pos = self._static_get_rel_pos\\n elif not self.staticneighs:\\n if type(self.sp_relative_pos) == list:\\n self.get_sp_rel_pos = self._dynamic_rel_pos_list\\n else:\\n self.get_sp_rel_pos = self._dynamic_rel_pos_array\\n if self.sp_relative_pos is None:\\n self.set_sp_rel_pos = self._null_set_rel_pos\\n self.get_sp_rel_pos = self._null_get_rel_pos\\n ## Ensure correct k_ret\\n if np.max(self.ks) > self._kret:\\n self._kret = np.max(self.ks)\",\n \"def test_optimalk_cluster_array_values_error():\\n from sklearn.datasets.samples_generator import make_blobs\\n from gap_statistic import OptimalK\\n\\n # Create optimalK instance\\n optimalK = OptimalK(parallel_backend=None, n_jobs=-1)\\n\\n # Create data\\n X, y = make_blobs(n_samples=int(1e3), n_features=2, centers=3)\\n\\n with pytest.raises(ValueError) as excinfo:\\n optimalK(X, cluster_array=[0, -1, 1, 2, 3])\\n assert 'cluster_array contains values less than 1' in str(excinfo.value)\",\n \"def test_k_index_xarray(index_xarray_data):\\n result = k_index(index_xarray_data.isobaric, index_xarray_data.temperature,\\n index_xarray_data.dewpoint)\\n assert_array_almost_equal(result,\\n np.array([[[312., 311., 310.], [309., 308., 307.]]]) * units.K)\",\n \"def test_jaccard_index_all_zeros_compiled():\\n vector1 = np.array([0, 0, 0, 0])\\n vector2 = np.array([1, 1, 1, 1])\\n score11 = jaccard_index(vector1, vector1)\\n score12 = jaccard_index(vector1, vector2)\\n score22 = jaccard_index(vector2, vector2)\\n\\n assert score11 == score12 == 0.0, \\\"Expected different score.\\\"\\n assert score22 == 1.0, \\\"Expected different score.\\\"\",\n \"def check_k_anonymity(data: np.ndarray, k: int, qi_indices=None):\\n print(Counter(str(e) for e in data[:, qi_indices]))\\n\\n occurrences = list(Counter(str(e) for e in data[:, qi_indices]).values())\\n for j in range(len(occurrences)):\\n if occurrences[j] < k:\\n return False\\n return True\",\n \"def test_jaccard_index_all_zeros():\\n vector1 = np.array([0, 0, 0, 0])\\n vector2 = np.array([1, 1, 1, 1])\\n score11 = jaccard_index.py_func(vector1, vector1)\\n score12 = jaccard_index.py_func(vector1, vector2)\\n score22 = jaccard_index.py_func(vector2, vector2)\\n\\n assert score11 == score12 == 0.0, \\\"Expected different score.\\\"\\n assert score22 == 1.0, \\\"Expected different score.\\\"\",\n \"def test_sparse():\\n\\n rng = np.random.RandomState(0)\\n\\n X = rng.rand(20, 2)\\n X[X < 0.8] = 0\\n X_csr = sp.csr_matrix(X)\\n\\n bisect_means = BisectingKMeans(n_clusters=3, random_state=0)\\n\\n bisect_means.fit(X_csr)\\n sparse_centers = bisect_means.cluster_centers_\\n\\n bisect_means.fit(X)\\n normal_centers = bisect_means.cluster_centers_\\n\\n # Check if results is the same for dense and sparse data\\n assert_allclose(normal_centers, sparse_centers, atol=1e-8)\",\n \"def test_search_array_not_found(self):\\r\\n self.assertEqual(search_array([6, 4, 9, 10], 15), -1)\",\n \"def test_index_0(self):\\n self.insert()\\n data = self.tbl[0]\\n assert self.check(self.idata[:0], data)\",\n \"def test_single_run(self):\\n\\n traces = np.load('data/traces.npy')\\n keys = np.load('data/key.npy')\\n plain = np.load('data/plain.npy')\\n correct_indices = [4254, 4257, 1400, 4429, 4919, 1399, 4918, 1398, 4917, 1397]\\n\\n indices = SOSTD.list_of_best_indices(traces, keys, plain, 10, 0)\\n self.assertTrue(np.array_equal(indices, correct_indices))\",\n \"def _check_no_empty_cluster(labels, n_clusters):\\n\\n for k in range(n_clusters):\\n if np.sum(labels == k) == 0:\\n raise EmptyClusterError\",\n \"def test_nonzero(self):\\n self.assertFalse(djset())\\n self.assertTrue(djset([1, 2, 3]))\\n self.assertTrue(djset([1, 2, 3], [4, 5, 6]))\\n self.assertTrue(djset([1, 2, 3], [4, 5, 6], [5, 6]))\",\n \"def test_empty_input(self):\\n discs = calc_disc(np.column_stack((np.ones(0), np.ones(0), np.ones(0))))\\n np.testing.assert_almost_equal(discs, np.array([]))\",\n \"def test_eigenvalues_of_too_few_points_results_in_0():\\n a = np.array([5])\\n pc = create_point_cloud(a, a, a)\\n\\n compute_features(pc, [[0]], pc, [\\\"eigenv_1\\\", \\\"eigenv_2\\\", \\\"eigenv_3\\\"], InfiniteCylinder(5))\\n\\n eigen_val_123 = np.array([pc[keys.point]['eigenv_{}'.format(i)]['data'] for i in [1, 2, 3]])\\n assert not np.any(np.isnan(eigen_val_123))\\n assert not np.any(np.isinf(eigen_val_123))\",\n \"def test_spike(self):\\n\\n arr = [10, 12, 999.99, 13, 15, 40, 9, 9]\\n\\n # First and last elements should always be good data, unless someone\\n # has set a threshold to zero.\\n expected = [1, 4, 4, 4, 1, 3, 1, 1]\\n\\n inputs = [\\n arr,\\n np.asarray(arr, dtype=np.floating),\\n dask_arr(np.asarray(arr, dtype=np.floating))\\n ]\\n for i in inputs:\\n npt.assert_array_equal(\\n qartod.spike_test(\\n inp=i,\\n suspect_threshold=self.suspect_threshold,\\n fail_threshold=self.fail_threshold\\n ),\\n expected\\n )\",\n \"def test_get_indices_no_items_to_search(self):\\r\\n item_to_find = []\\r\\n self.assertEqual(_get_indices(self.dist_matrix_header, item_to_find),\\r\\n [])\\r\\n item_to_find = ''\\r\\n self.assertEqual(_get_indices(self.dist_matrix_header, item_to_find),\\r\\n [])\\r\\n item_to_find = None\\r\\n self.assertEqual(_get_indices(self.dist_matrix_header, item_to_find),\\r\\n [])\",\n \"def sparse(n, k):\\n z = np.zeros(n)\\n for i in np.random.choice( np.arange(n), k, replace=None ): # supports of nonzero entries\\n z[i] = np.random.randn()\\n return z\",\n \"def testContains(self):\\n\\n N = randint(20,100)\\n for i in xrange(N):\\n self.s.insert(i,True)\\n N-=(i in self.s)\\n\\n self.assertEqual(N,0)\",\n \"def check_output_k(output_k):\\n if isinstance(output_k, list):\\n output_k = np.array(output_k)\\n # Check indexing is sorted increasingly\\n if not is_sorted_array(output_k, increasing=True):\\n raise ValueError(\\\"Provide output_k sorted increasingly\\\")\\n # Check output_k contains at least a 0\\n if not np.any(output_k == 0):\\n raise ValueError(\\n \\\"output_k must start with a 0 value. 0 indicates the 'current' timestep to predict.\\\"\\n )\\n return output_k\",\n \"def count_nonzero(tensor):\\n raise NotImplementedError\",\n \"def test_jw_sparse_index(self):\\n expected = [1, 2]\\n calculated_indices = jw_number_indices(1, 2)\\n self.assertEqual(expected, calculated_indices)\\n\\n expected = [3]\\n calculated_indices = jw_number_indices(2, 2)\\n self.assertEqual(expected, calculated_indices)\",\n \"def test_batch_missing_data():\\n\\n\\n def fx(x, dt):\\n F = np.array([[1, dt, 0, 0],\\n [0, 1, 0, 0],\\n [0, 0, 1, dt],\\n [0, 0, 0, 1]], dtype=float)\\n\\n return np.dot(F, x)\\n\\n def hx(x):\\n return np.array([x[0], x[2]])\\n\\n\\n dt = 0.1\\n points = MerweScaledSigmaPoints(4, .1, 2., -1)\\n kf = UKF(dim_x=4, dim_z=2, dt=dt, fx=fx, hx=hx, points=points)\\n\\n\\n kf.x = np.array([-1., 1., -1., 1])\\n kf.P*=0.0001\\n\\n zs = []\\n for i in range(20):\\n z = np.array([i+randn()*0.1, i+randn()*0.1])\\n zs.append(z)\\n\\n zs[2] = None\\n Rs = [1]*len(zs)\\n Rs[2] = None\\n Ms, Ps = kf.batch_filter(zs)\",\n \"def test_nan_keyword(self):\\n # If array has any nan's then the output will return all zeros\\n array = self.array1.copy()\\n array[0,0] = numpy.nan\\n byt = bytscl(array, nan=True)\\n total = numpy.sum(byt)\\n self.assertTrue(total != 0)\",\n \"def get_first_valid_idx(input_k):\\n past_idxs = input_k[input_k < 0]\\n if past_idxs.size == 0: # empty\\n past_idxs = 0\\n else:\\n past_idxs = abs(min(past_idxs))\\n return past_idxs\",\n \"def test_optimalk_cluster_array_vs_data_sizes_error():\\n import numpy as np\\n from sklearn.datasets.samples_generator import make_blobs\\n from gap_statistic import OptimalK\\n\\n # Create optimalK instance\\n optimalK = OptimalK(parallel_backend=None, n_jobs=-1)\\n\\n # Create data\\n X, y = make_blobs(n_samples=5, n_features=2, centers=3)\\n\\n with pytest.raises(ValueError) as excinfo:\\n optimalK(X, cluster_array=np.arange(1, 10))\\n assert 'The number of suggested clusters to try' in str(excinfo.value)\",\n \"def kronecker_imp(t):\\n return np.where(t == 0, 1, 0)\",\n \"def test_key_predicate(datum):\\n return 0 < datum\",\n \"def test_single_run_sosd(self):\\n\\n traces = np.load('data/traces.npy')[:1000]\\n keys = np.load('data/key.npy')[:1000]\\n plain = np.load('data/plain.npy')[:1000]\\n correct_indices = [4371, 2401, 2402, 4878, 4370, 4877, 4882, 4369, 4881, 2723]\\n\\n indices = SOSTD.list_of_best_indices(traces, keys, plain, 10, 0, False)\\n self.assertTrue(np.array_equal(indices, correct_indices))\",\n \"def main_eaftest(point_ind, permutations=10240, alpha=0.05):\\n \\n # ------ Attainment indicator values information ------\\n \\n npoints = len(point_ind)\\n nvars = len(point_ind[0]) # Número de execuções total\\n nruns = nvars // 2 # Número de execuções de 1 algo\\n \\n print \\\"- Attainment indicator values information:\\\"\\n print \\\" * Number of points:\\\", npoints\\n print \\\" * Joint executions:\\\", nvars, \\\"(%d + %d)\\\" % (nruns, nruns)\\n print\\n \\n assert nvars % 2 == 0, \\\"Number of total joint executions must be even.\\\"\\n assert nvars <= 64, \\\"Not implemented with more than 64 joint executions.\\\"\\n \\n # ------ Test Statistic ------\\n\\n print \\\"- Computing the test statistic...\\\" \\n stat2 = libaft.ksstat(point_ind, order=2)\\n print \\\" * Test statistic = %d/%d\\\" % (stat2, nruns)\\n print \\\" = %f\\\" % (stat2 / float(nruns)), '\\\\n'\\n \\n # ------ Estimate null distribution ------\\n\\n print \\\"- Using %d random permutations to estimate null distribution.\\\" % permutations\\n print \\\" Please be patient...\\\"\\n maxdist = np.zeros(permutations, dtype=np.int32) # Max distance array\\n rtime = time.time()\\n \\n masks = bintools.make_masks(permutations, nvars, seed=64)\\n for i, maxd in enumerate(KERNEL.runkernel(point_ind, masks)):\\n maxdist[i] = maxd\\n if (i+1) % (permutations//20) == 0:\\n print \\\" %6d permutations, %7.3f sec\\\" % (i+1, time.time()-rtime)\\n print \\\" * Time elapsed: %7.3f\\\" % (time.time()-rtime)\\n \\n # Compute null distribution from max distance array\\n tail = np.bincount(maxdist, minlength=nruns+1)\\n print \\\" * Non-normalized null distribution:\\\"\\n print tail\\n print\\n \\n # ------ Accept/reject null hypothesis ------\\n \\n # NB: -1 resulta das diferentes convenções para a definição de valor crítico\\n crit = criticalvalue(tail, alpha * permutations) - 1\\n pval = pvalue(tail, stat2) / float(permutations)\\n \\n print \\\"- Null hypothesis decision:\\\" \\n print \\\" * Critical value = %d/%d\\\" % (crit, nruns)\\n print \\\" = %f\\\" % (crit / float(nruns))\\n print \\\" * p-value = %f\\\" % pval\\n if pval <= alpha:\\n print \\\" <= alpha (%s)\\\\n\\\" % alpha\\n print \\\" * Decision: REJECT the null hypothesis\\\"\\n else:\\n print \\\" > alpha (%s)\\\\n\\\" % alpha\\n print \\\" * Decision: do NOT REJECT the null hypothesis\\\"\\n print\",\n \"def test_getitem_array(self):\\n random.seed(12345)\\n\\n nside_coverage = 32\\n nside_map = 128\\n\\n full_map = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\\n full_map[0: 5000] = random.random(size=5000)\\n\\n sparse_map = healsparse.HealSparseMap(healpix_map=full_map, nside_coverage=nside_coverage)\\n\\n indices = np.array([1, 2, 100, 500, 10000])\\n testing.assert_array_almost_equal(sparse_map[indices], full_map[indices])\\n testing.assert_almost_equal(sparse_map[indices[0]], full_map[indices[0]])\\n\\n indices = np.array([1., 2, 100, 500, 10000])\\n self.assertRaises(IndexError, sparse_map.__getitem__, indices)\\n self.assertRaises(IndexError, sparse_map.__getitem__, indices[0])\",\n \"def assert_stored_ks(self):\\n assert(self.ks is None or type(self.ks) in [list, np.ndarray])\\n if self.ks is not None:\\n assert(type(self.ks[0]) in inttypes)\",\n \"def testAccidentalHitRemoval(self):\\n np.random.seed(0)\\n num_classes = 5\\n batch_size = 3\\n sampled = [1, 0, 2, 3]\\n\\n for num_true in range(1, 5):\\n labels = np.random.randint(\\n low=0, high=num_classes, size=batch_size * num_true)\\n (weights, biases, hidden_acts, sampled_vals, _,\\n _) = self._GenerateTestData(\\n num_classes=num_classes,\\n dim=10,\\n batch_size=batch_size,\\n num_true=num_true,\\n labels=labels,\\n sampled=sampled,\\n subtract_log_q=False)\\n logits_tensor, _ = _compute_sampled_logits(\\n weights=constant_op.constant(weights),\\n biases=constant_op.constant(biases),\\n labels=constant_op.constant(\\n labels, dtype=dtypes.int64, shape=(batch_size, num_true)),\\n inputs=constant_op.constant(hidden_acts),\\n num_sampled=len(sampled),\\n num_classes=num_classes,\\n num_true=num_true,\\n sampled_values=sampled_vals,\\n subtract_log_q=False,\\n remove_accidental_hits=True,\\n partition_strategy=\\\"div\\\",\\n name=\\\"sampled_logits_accidental_hit_removal_num_true_%d\\\" % num_true)\\n # Test that the exponentiated logits of accidental hits are near 0.\\n # First we need to find the hits in this random test run:\\n labels_reshape = labels.reshape((batch_size, num_true))\\n got_logits = self.evaluate(logits_tensor)\\n for row in range(batch_size):\\n row_labels = labels_reshape[row, :]\\n for col in range(len(sampled)):\\n if sampled[col] in row_labels:\\n # We need to add the num_true_test offset into logits_*\\n self.assertNear(\\n np.exp(got_logits[row, col + num_true]), 0., self._eps)\",\n \"def test_k(self):\\n\\n # We have a new K. It should have nothing in it.\\n loc_, sloc_, test_loc, test_sloc = self.k__.get_totals()\\n self.assertEqual(loc_, 0)\\n self.assertEqual(sloc_, 0)\\n self.assertEqual(test_loc, 0)\\n self.assertEqual(test_sloc, 0)\\n\\n self.check_counts('zz', 0, 0, 0, 0) # not in map\\n self.check_counts('py', 0, 0, 0, 0) # not in map\\n\\n self.k__.add_counts('py', 7, 3)\\n self.check_counts('py', 7, 3, 0, 0)\\n self.k__.add_counts('py', 5, 2)\\n self.check_counts('py', 12, 5, 0, 0)\\n\\n self.k__.add_test_counts('py', 8, 4)\\n self.check_counts('py', 12, 5, 8, 4)\\n self.k__.add_test_counts('py', 9, 3)\\n self.check_counts('py', 12, 5, 17, 7)\\n\\n expected = \\\"py:%d/%d T%.1f%%\\\" % (12 + 17, 5 + 7, 700.0 / 12)\\n # DEBUG\\n # print(\\\"Expected: %s\\\" % expected)\\n # END\\n self.assertEqual(self.k__.pretty_counts('py'), expected)\",\n \"def test_empty_input(self):\\n discs = calc_disc_c(np.ones(0), np.ones(0), np.ones(0), 0.3)\\n np.testing.assert_almost_equal(discs, np.array([]))\",\n \"def test_no_spike_after_table(self):\\n n = 5\\n dt = 1.0\\n t_max = 2*dt\\n # make sure we have spikes at the end\\n table = np.ones((1, n))\\n\\n G = TableSpikers(n)\\n G.spike_table = table\\n\\n sim = simulation.Simulation(G, dt=dt)\\n sim.run(t_max)\\n \\n self.assertFalse(np.any(G.spike))\",\n \"def check_none_zero_values(self):\\n hits = -1\\n if (len(self.data.shape) == 3):\\n hits = 0\\n frames = self.data.shape[0]\\n pixels = self.data.shape[1]\\n bins = self.data.shape[2]\\n for i in range(frames):\\n for j in range(pixels):\\n for k in range(bins):\\n value = self.data[i][j][k]\\n if value > 0:\\n hits += 1\\n print(\\\"self.data[{}][{}][{}]; Sum so far = {}\\\".format(i, j, k, hits))\\n return hits\",\n \"def test_k_rank_approximate(corpus):\\n return\",\n \"def test_k_index():\\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\\n 400.]) * units.hPa\\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\\n -23.5]) * units.degC\\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\\n -57.5]) * units.degC\\n ki = k_index(pressure, temperature, dewpoint)\\n assert_almost_equal(ki, 33.5 * units.degC, 2)\",\n \"def count_nonzero(a):\\n return (np.count_nonzero(a))\",\n \"def ks_test(timeseries):\\r\\n\\r\\n hour_ago = time() - 3600\\r\\n ten_minutes_ago = time() - 600\\r\\n reference = scipy.array([x[1] for x in timeseries if x[0] >= hour_ago and x[0] < ten_minutes_ago])\\r\\n probe = scipy.array([x[1] for x in timeseries if x[0] >= ten_minutes_ago])\\r\\n\\r\\n if reference.size < 20 or probe.size < 20:\\r\\n return False\\r\\n\\r\\n ks_d,ks_p_value = scipy.stats.ks_2samp(reference, probe)\\r\\n\\r\\n if ks_p_value < 0.05 and ks_d > 0.5:\\r\\n adf = sm.tsa.stattools.adfuller(reference, 10)\\r\\n if adf[1] < 0.05:\\r\\n return True\\r\\n\\r\\n return False\",\n \"def _test_obsdup(t):\\n return t.shape[0] != len(set(t.ids(axis='observation')))\",\n \"def test_empty(self):\\n a = np.ones((3, 4, 5))\\n ai = np.ones((3, 0, 5), dtype=np.intp)\\n\\n actual = take_along_axis(a, ai, axis=1)\\n assert_equal(actual.shape, ai.shape)\",\n \"def is_empty(self):\\n return self.idx == 0\",\n \"def test_00_create_sparse_1d_array(self):\\n ncells = 100\\n sparsity = 3.0 # 1 / density\\n _, err = _iquery(\\\"create array SPARSE <v:int64>[i=0:{0}:0:5]\\\".format(\\n ncells - 1))\\n assert not err, err\\n self._array_cleanups.append('SPARSE')\\n _, err = _iquery(\\\"\\\"\\\"\\n insert(\\n redimension(\\n apply(\\n build(<i:int64>[fud=0:{0}], {1}*fud),\\n (v, 1)),\\n SPARSE),\\n SPARSE)\\\"\\\"\\\".format(int(ncells / sparsity) - 1,\\n int(sparsity)))\\n assert not err, err\\n check_v_sum('SPARSE')\\n nchunks = chunk_count(vaid_of('SPARSE'))\\n prt(\\\"SPARSE has\\\", nchunks, \\\"chunks\\\")\",\n \"def test_sparsity_topk_mask_dykstra(self, l=1e-2):\\n n = int(1e3)\\n seed = np.random.RandomState(0)\\n y = jnp.array(seed.randn(n))\\n k = 10\\n out_top_k_dykstra = sparse_soft_topk_mask_dykstra(y, k, l=l)\\n self.assertAlmostEqual(\\n y.argsort()[::-1][:k].sort().sum(),\\n out_top_k_dykstra.argsort()[::-1][:k].sort().sum(),\\n )\\n self.assertAlmostEqual(len(jnp.where(out_top_k_dykstra > 0)[0]), k)\",\n \"def test_insert_on_empty(empty_trie):\\n empty_trie.insert('hello')\\n assert 'h' in empty_trie.root.keys()\\n assert empty_trie.size == 1\",\n \"def test_spike_masked(self):\\n\\n arr = [10, 12, 999.99, 13, 15, 40, 9, 9, None, 10, 10, 999.99, 10, None]\\n\\n # First and last elements should always be good data, unless someone\\n # has set a threshold to zero.\\n expected = [1, 4, 4, 4, 1, 3, 1, 1, 9, 9, 4, 4, 4, 9]\\n\\n inputs = [\\n arr,\\n np.asarray(arr, dtype=np.floating),\\n dask_arr(np.asarray(arr, dtype=np.floating))\\n ]\\n for i in inputs:\\n npt.assert_array_equal(\\n qartod.spike_test(\\n inp=i,\\n suspect_threshold=self.suspect_threshold,\\n fail_threshold=self.fail_threshold\\n ),\\n expected\\n )\",\n \"def test_identity_function(data_and_labels):\\n input_data = data_and_labels[0]\\n\\n output_data = unprotected_query(input_data)\\n\\n np.testing.assert_array_equal(input_data, output_data)\",\n \"def _check_no_nonzero_features(self,\\n features: np.ndarray,\\n dropped_idx: np.ndarray,\\n axis: Optional[int] = None):\\n if axis is not None:\\n # Dropped node.\\n features_of_dropped_nodes = np.take(features, dropped_idx, axis=axis)\\n self.assertEqual(0, np.nonzero(features_of_dropped_nodes)[0].shape[0])\\n self.assertEqual(0, np.nonzero(features_of_dropped_nodes)[1].shape[0])\\n else:\\n # Dropped edge.\\n features_of_dropped_edge = features[dropped_idx[0], dropped_idx[1]]\\n self.assertEqual(0, np.nonzero(features_of_dropped_edge)[0].shape[0])\",\n \"def test_shannon(self):\\n c = array([5])\\n self.assertFloatEqual(shannon(c), 0)\\n c = array([5,5])\\n self.assertFloatEqual(shannon(c), 1)\\n c = array([1,1,1,1,0])\\n self.assertEqual(shannon(c), 2)\",\n \"def test_missing_indices():\\n\\n data = pd.read_csv(\\n \\\"https://raw.githubusercontent.com/facebook/prophet/main/examples/example_wp_log_peyton_manning.csv\\\"\\n )\\n data[\\\"ds\\\"] = pd.to_datetime(data[\\\"ds\\\"])\\n data.set_index(\\\"ds\\\", inplace=True)\\n data.index = data.index.to_period(\\\"D\\\")\\n data.info()\\n\\n exp = TSForecastingExperiment()\\n\\n with pytest.raises(ValueError) as errmsg:\\n exp.setup(data=data, fh=365, session_id=42)\\n exceptionmsg = errmsg.value.args[0]\\n\\n assert \\\"Data has missing indices!\\\" in exceptionmsg\",\n \"def test_empty_input(self):\\n discs = calc_disc_b(np.ones(0), np.ones(0), np.ones(0), 0.3)\\n np.testing.assert_almost_equal(discs, np.array([]))\",\n \"def KS_algorithm(dataset_x, dataset_y, train_size = 0.7, return_dataset = True):\\n #Decide number of total samples\\n n = dataset_x.shape[0]\\n \\n #Turn into train_size to float\\n try: \\n train_size = float(train_size)\\n except Expection as e:\\n print(e)\\n \\n #Jusge if the train_size is by ratio or quantity\\n if 0 < train_size < 1: \\n num_of_samples = round(n*train_size)\\n elif 1 < train_size < 2: \\n return \\\"Train size must be between 1 to 0 or 2 to number of total samples\\\" \\n elif train_size == n or train_size == 1:\\n return [x for x in range(n)]\\n elif 2 <= train_size < n:\\n num_of_samples = round(train_size)\\n elif train_size > n:\\n return \\\"Num_of_samples must be less than or equal to original number of samples\\\"\\n \\n #Create original sample index\\n samples = [x for x in range(n)]\\n \\n #Create distance matrix\\n print('Building distance matrix')\\n dist_matrix = create_dist_matrix(dataset_x)\\n\\n #Pick first two furthest away data points\\n print('Picking two furthest away samples')\\n max_array = np.argmax(dist_matrix == np.max(dist_matrix), axis = 1)\\n ind1 = max_array[max_array != 0][0]\\n ind2 = max_array[ind1]\\n\\n #Initiate chosen sample list, append first two samples and remove from remaining sample list\\n chosen_samples = [ind1, ind2]\\n samples.remove(ind1)\\n samples.remove(ind2) \\n remaining_samples = num_of_samples - 2\\n\\n #Continue picking samples if not yet reaching target number of samples\\n while remaining_samples > 0:\\n sub_array = np.min(dist_matrix[:,chosen_samples], axis=1)\\n chosen = np.argmax(sub_array)\\n chosen_samples.append(chosen)\\n samples.remove(chosen)\\n remaining_samples -= 1\\n \\n #See if this function should return train and test set or simply index of chosen samples\\n if return_dataset == True:\\n not_chosen_samples = [x for x in range(n) if x not in chosen_samples]\\n return dataset_x.iloc[chosen_samples,:], dataset_x.iloc[not_chosen_samples,:], dataset_y.iloc[chosen_samples,:], dataset_y.iloc[not_chosen_samples,:] \\n else:\\n return chosen_samples\",\n \"def do_knn(x_data):\\n return True\",\n \"def test_fill_nnz(seed, shape):\\n # Generate 4 matrices of 100x100 pixls with random density between 0 and 10%\\n mats = gen_mats(seed, shape)\\n nnz_union = pap.get_nnz_union(mats)\\n # Check if all matrices have been filled to the sparsity of nnz_union\\n for mat in mats:\\n filled = pap.fill_nnz(mat, nnz_union)\\n assert filled.nnz == nnz_union.shape[0]\",\n \"def zero_examples(self):\\n for ex in self.each_non_trivial_example():\\n u = ex.start\\n v = ex.end\\n attempt = self.cached_test_function(\\n self.buffer[:u] + hbytes(v - u) + self.buffer[v:]\\n )\\n\\n if attempt is Overrun:\\n continue\\n\\n in_replacement = attempt.examples[ex.index]\\n used = in_replacement.length\\n\\n if (\\n not self.__predicate(attempt)\\n and in_replacement.end < len(attempt.buffer)\\n and used < ex.length\\n ):\\n self.incorporate_new_buffer(\\n self.buffer[:u] + hbytes(used) + self.buffer[v:]\\n )\",\n \"def test_index_start(self):\\n sp_file = os.path.join(\\\"tests\\\", \\\"data\\\", \\\"geolife\\\", \\\"geolife_staypoints.csv\\\")\\n sp = ti.read_staypoints_csv(sp_file, tz=\\\"utc\\\", index_col=\\\"id\\\", crs=\\\"epsg:4326\\\")\\n\\n # reproject to WGS_1984_UTM_Zone_49N\\n sp = sp.to_crs(\\\"epsg:32649\\\")\\n\\n distance_metric_ls = [\\\"haversine\\\", \\\"euclidean\\\"]\\n agg_level_ls = [\\\"dataset\\\", \\\"user\\\"]\\n for distance_metric in distance_metric_ls:\\n for agg_level in agg_level_ls:\\n _, locations = sp.as_staypoints.generate_locations(\\n method=\\\"dbscan\\\", epsilon=10, num_samples=1, distance_metric=distance_metric, agg_level=agg_level\\n )\\n assert (locations.index == np.arange(len(locations))).any()\",\n \"def testAlphaZeroSamplesMatchACauchyDistribution(self):\\n num_samples = 16384\\n scale = 1.7\\n rng = random.PRNGKey(0)\\n samples = self._distribution.draw_samples(rng, jnp.zeros(num_samples),\\n scale * jnp.ones(num_samples))\\n # Perform the Kolmogorov-Smirnov test against a Cauchy distribution.\\n ks_statistic = scipy.stats.kstest(samples, 'cauchy',\\n (0, scale * jnp.sqrt(2))).statistic\\n self.assertLess(ks_statistic, 0.02)\",\n \"def is_empty(self):\\n return ch.prod(ch.tensor(self.x.shape)).item() == 0\",\n \"def ks_test_function(dim, thresh):\\n def ks_test(table1, table2):\\n from scipy.stats import ks_2samp\\n sample1 = table1.get_cols(dim)[0]\\n sample2 = table2.get_cols(dim)[0]\\n if thresh != None:\\n sample1[sample1<thresh] = 0\\n sample2[sample2<thresh] = 0\\n ks, p_ks = ks_2samp(sample1, sample2)\\n return ks\\n return ks_test\",\n \"def test_ones(self):\\n scores = np.column_stack((np.ones(10), np.ones(10), np.ones(10)))\\n discs = calc_disc(scores)\\n np.testing.assert_array_equal(discs, np.zeros(10))\",\n \"def test_32_test_not_init_array(self):\\n example = Example(groups=7, origins=5,\\n init_arrays=False, threading=False)\\n with pytest.raises(AttributeError):\\n print(example.not_initialized_ij)\",\n \"def test_32_test_not_init_array(self):\\n example = Example(groups=7, origins=5,\\n init_arrays=False, threading=False)\\n with pytest.raises(AttributeError):\\n print(example.not_initialized_ij)\",\n \"def test_removing_index(self):\",\n \"def _test_obssize(t):\\n return t.shape[0] != len(t.ids(axis='observation'))\",\n \"def testUnknownIndices(self):\\n params = constant_op.constant(((0, 1, 2),))\\n indices = array_ops.placeholder(dtypes.int32)\\n gather_nd_t = array_ops.gather_nd(params, indices, batch_dims=1)\\n shape = gather_nd_t.get_shape()\\n self.assertIsNone(shape.ndims)\\n self.assertIsNone(tensor_shape.dimension_value(shape[0]))\",\n \"def test_negative_stop(self):\\n self.assertArrayEqual(self.dset[2:-2], self.arr[2:-2])\",\n \"def test_swap_k_zero_size(self):\\n \\n nums = []\\n k = 0\\n\\n a1.swap_k(nums, k)\\n\\n self.assertEqual(nums, [])\",\n \"def vectorized(self):\\n return False\",\n \"def test_scalar_index(self):\\n dset = self.f.create_dataset('x', shape=(), dtype='f')\\n out = dset[...]\\n self.assertIsInstance(out, np.ndarray)\\n self.assertEqual(out.shape, ())\",\n \"def check_input_k(input_k, ar_iterations):\\n if isinstance(input_k, list):\\n input_k = np.array(input_k)\\n # Check indexing is sorted increasingly\\n if not is_sorted_array(input_k, increasing=True):\\n raise ValueError(\\\"Provide input_k sorted increasingly\\\")\\n # Checks for forecasting mode\\n if ar_iterations > 0:\\n if np.any(input_k == 0):\\n raise ValueError(\\n \\\"input_k contains values equal to 0. Past timesteps must be specified with negative values\\\"\\n )\\n if np.all(input_k > 0):\\n raise ValueError(\\\"input_k requires negative values in 'forecasting' mode\\\")\\n return input_k\",\n \"def sample_noreplace(arr, n, k): \\n # code from https://www.iditect.com/how-to/58566613.html\\n idx = np.random.randint(len(arr) - np.arange(k), size=[n, k])\\n for i in range(k-1, 0, -1):\\n idx[:,i:] += idx[:,i:] >= idx[:,i-1,None]\\n return np.array(arr)[idx]\",\n \"def test_spike_realdata(self):\\n suspect_threshold = 0.5\\n fail_threshold = 1\\n\\n arr = [-0.189, -0.0792, -0.0122, 0.0457, 0.0671, 0.0213, -0.0488, -0.1463, -0.2438, -0.3261, -0.3871, -0.4054,\\n -0.3932, -0.3383, -0.2804, -0.2347, -0.2134, -0.2347, -0.2926, -0.3597, -0.442, -0.509, 0, -0.5944,\\n -0.57, -0.4267, -0.2926, -0.1585, -0.0945, -0.0762]\\n\\n expected = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1]\\n\\n inputs = [\\n arr,\\n np.asarray(arr, dtype=np.floating),\\n dask_arr(np.asarray(arr, dtype=np.floating))\\n ]\\n for i in inputs:\\n npt.assert_array_equal(\\n qartod.spike_test(\\n inp=i,\\n suspect_threshold=suspect_threshold,\\n fail_threshold=fail_threshold\\n ),\\n expected\\n )\",\n \"def test00(self):\\n a = np.arange(1, 11) > 0\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()\\n cwt = [i for i in b.wheretrue()]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()\\n # print \\\"where ->\\\", [i for i in b.wheretrue()]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def test_is_filled(self):\\n n = 10\\n matrix = g.np.random.uniform(size=(n + 1,) * 3) > 0.5\\n not_matrix = g.np.logical_not(matrix)\\n pitch = 1. / n\\n origin = g.np.random.uniform(size=(3,))\\n vox = g.trimesh.voxel.VoxelGrid(matrix)\\n vox = vox.apply_scale(pitch).apply_translation(origin)\\n not_vox = g.trimesh.voxel.VoxelGrid(not_matrix)\\n not_vox = not_vox.apply_scale(pitch).apply_translation(origin)\\n for a, b in ((vox, not_vox), (not_vox, vox)):\\n points = a.points\\n # slight jitter - shouldn't change indices\\n points += (\\n g.np.random.uniform(size=points.shape) - 1) * 0.4 * pitch\\n g.np.random.shuffle(points)\\n\\n # all points are filled, and no empty points are filled\\n assert g.np.all(a.is_filled(points))\\n assert not g.np.any(b.is_filled(points))\\n\\n # test different number of dimensions\\n points = g.np.stack([points, points[-1::-1]], axis=1)\\n assert g.np.all(a.is_filled(points))\\n assert not g.np.any(b.is_filled(points))\",\n \"def _zero(array):\\n a = array.ravel()\\n for i in numba.prange(len(a)):\\n a[i] = 0\\n return True\",\n \"def isEmpty(self):\\n return self._N == 0\",\n \"def _test_sampsize(t):\\n return t.shape[1] != len(t.ids(axis='sample'))\",\n \"def test_double_insert_on_empty(empty_trie):\\n empty_trie.insert('hello')\\n empty_trie.insert('hello')\\n assert empty_trie.size == 1\",\n \"def spca(a, s, k, d):\\n\\n p = a.shape[0]\\n X = np.zeros((p, k))\\n\\n for l in range(k):\\n # 1\\n [w, V] = linalg.eigh(a)\\n idx = w.argsort()\\n w = w[idx]\\n V = V[:, idx]\\n\\n # 2\\n xprime, value = spannogram(V[:, -d:], w[-d:], s=s)\\n X[:, l] = xprime[:, 0]\\n\\n # 3\\n idx = np.abs(xprime).argsort(axis=0)\\n for i in idx[-s:]:\\n a[i, :] = 0\\n a[:, i] = 0\\n\\n return X\",\n \"def _test_once(self, data, alpha):\\n target_index, value = self._target(data)\\n\\n g = value / data.std()\\n g_test = self._get_g_test(data, alpha)\\n return target_index if g > g_test else None\",\n \"def test02(self):\\n a = np.arange(1, 1e5) < 0\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()\\n cwt = [i for i in b.wheretrue()]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()\\n # print \\\"where ->\\\", [i for i in b.wheretrue()]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def test_hashed_feature_random_sign():\\n\\n group = Group({\\\"a\\\": Hashed(buckets=100, random_sign=True), })\\n\\n for i in range(100):\\n for j in range(100):\\n group.set(randstr(), weight=123)\\n group.push()\\n\\n array = group.array()\\n assert array.shape == (100, 100)\\n\\n pos, neg = 0, 0\\n for row in array:\\n for value in row:\\n assert value == 0 or abs(value) == 123\\n pos += int(value > 0)\\n neg += int(value < 0)\\n assert pos and neg and abs(pos - neg) < (pos + neg) * 0.1\",\n \"def isEmpty(self): # total O(1)\\n return self._size == 0 #O(1)\",\n \"def nnz(self):\",\n \"def test_occupied1(self):\\n array = np.array(['A'])\\n self.assertFalse(self.tt.occupied(array, 0, 0))\",\n \"def test_getitem_other(self):\\n random.seed(12345)\\n\\n nside_coverage = 32\\n nside_map = 128\\n\\n full_map = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\\n full_map[0: 5000] = random.random(size=5000)\\n\\n sparse_map = healsparse.HealSparseMap(healpix_map=full_map, nside_coverage=nside_coverage)\\n\\n indices = (1, 2, 3, 4)\\n self.assertRaises(IndexError, sparse_map.__getitem__, indices)\\n\\n indices = 5.0\\n self.assertRaises(IndexError, sparse_map.__getitem__, indices)\",\n \"def test_index_geq_3(self):\\n self.insert()\\n data = self.tbl[6:]\\n assert self.check(self.idata[2:], data)\",\n \"def test_setitem_other(self):\\n random.seed(12345)\\n\\n nside_coverage = 32\\n nside_map = 128\\n\\n full_map = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\\n full_map[0: 5000] = random.random(size=5000)\\n\\n sparse_map = healsparse.HealSparseMap(healpix_map=full_map, nside_coverage=nside_coverage)\\n\\n indices = (1, 2, 3, 4)\\n self.assertRaises(IndexError, sparse_map.__setitem__, indices, 1.0)\\n\\n indices = 5.0\\n self.assertRaises(IndexError, sparse_map.__setitem__, indices, 1.0)\",\n \"def test_insert(empty_bucket): # pylint: disable=redefined-outer-name\\n for idx in range(2):\\n element_number = idx + 1\\n empty_bucket.insert(f\\\"key {element_number}\\\", f\\\"value {element_number}\\\")\\n\\n elements = list(iter(empty_bucket))\\n for idx, (key, value) in enumerate(reversed(elements)):\\n element_number = idx + 1\\n assert key == f\\\"key {element_number}\\\"\\n assert value == f\\\"value {element_number}\\\"\",\n \"def test_empty_generation(self, example_staypoints):\\n # the pfs would not generate staypoints with the default parameters\\n sp = example_staypoints\\n # select subset of sp such that no locations can be generated\\n sp = sp.iloc[:3]\\n\\n warn_string = \\\"No locations can be generated, returning empty locs.\\\"\\n with pytest.warns(UserWarning, match=warn_string):\\n sp, locs = sp.as_staypoints.generate_locations(\\n method=\\\"dbscan\\\", epsilon=10, num_samples=2, distance_metric=\\\"haversine\\\", agg_level=\\\"user\\\"\\n )\\n assert len(locs) == 0\",\n \"def test_index_stability(self, example_staypoints):\\n sp = example_staypoints\\n sp2, locs = sp.as_staypoints.generate_locations(\\n method=\\\"dbscan\\\", epsilon=10, num_samples=2, distance_metric=\\\"haversine\\\", agg_level=\\\"user\\\"\\n )\\n assert sp.index.equals(sp2.index)\",\n \"def test01(self):\\n a = np.arange(1, 11) < 0\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()\\n cwt = [i for i in b.wheretrue()]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()\\n # print \\\"where ->\\\", [i for i in b.wheretrue()]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def test_fit_predict(is_sparse):\\n rng = np.random.RandomState(0)\\n\\n X = rng.rand(10, 2)\\n\\n if is_sparse:\\n X[X < 0.8] = 0\\n X = sp.csr_matrix(X)\\n\\n bisect_means = BisectingKMeans(n_clusters=3, random_state=0)\\n bisect_means.fit(X)\\n\\n assert_array_equal(bisect_means.labels_, bisect_means.predict(X))\",\n \"def min_necessary_ks(Nx, Ny):\\n ks = []\\n arrs = []\\n for kx in range(Nx):\\n for ky in range(Ny):\\n arr = np.outer(np.exp(2j * np.pi * kx * np.arange(Nx) / Nx),\\n np.exp(2j * np.pi * ky * np.arange(Ny) / Ny))\\n for arr0 in arrs:\\n if np.allclose(arr0, arr) or np.allclose(arr0, arr.conjugate()):\\n break\\n else:\\n ks.append((kx, ky))\\n arrs.append(arr)\\n return ks\",\n \"def test_rastrigin(self):\\n rastrigin = get_problem('rastrigin', dimension=self.dimension)\\n self.assertEqual(rastrigin(self.array), 0.0)\",\n \"def assert_uncoalesced(self, x):\\n assert not x.is_coalesced()\\n existing_indices = set()\\n for i in range(x._nnz()):\\n index = str(x._indices()[:, i])\\n if index in existing_indices:\\n return True\\n else:\\n existing_indices.add(index)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70587337","0.65909284","0.6385907","0.5999898","0.5820923","0.5819541","0.57032824","0.56986374","0.5642348","0.5551414","0.55201554","0.54983246","0.5488126","0.5454441","0.54420024","0.54296124","0.5424802","0.54022473","0.53976005","0.5383299","0.53648037","0.53434795","0.5329406","0.5307623","0.5307011","0.5301138","0.53002816","0.52873904","0.5281624","0.5280695","0.5264113","0.52628404","0.52484494","0.52335364","0.5206028","0.5203644","0.51940817","0.5184033","0.5156569","0.51500154","0.51459205","0.5141768","0.5137601","0.51353586","0.51310885","0.512909","0.51255155","0.5125248","0.5124645","0.51224184","0.50997543","0.5096965","0.5082389","0.508154","0.5077121","0.507628","0.50588083","0.50574756","0.5054117","0.50433457","0.5038871","0.5038432","0.5037229","0.50362074","0.5030928","0.5030928","0.5029663","0.500732","0.50072074","0.5006999","0.50067794","0.5005948","0.5003822","0.5003027","0.5002815","0.4999105","0.49983025","0.49975967","0.49950716","0.49906045","0.49894756","0.49894336","0.49874955","0.49805117","0.4979386","0.4977572","0.49757907","0.49756017","0.4968422","0.49602962","0.49554798","0.49505997","0.49436492","0.49421632","0.4940576","0.4934333","0.49336073","0.49167928","0.49065298","0.49055937"],"string":"[\n \"0.70587337\",\n \"0.65909284\",\n \"0.6385907\",\n \"0.5999898\",\n \"0.5820923\",\n \"0.5819541\",\n \"0.57032824\",\n \"0.56986374\",\n \"0.5642348\",\n \"0.5551414\",\n \"0.55201554\",\n \"0.54983246\",\n \"0.5488126\",\n \"0.5454441\",\n \"0.54420024\",\n \"0.54296124\",\n \"0.5424802\",\n \"0.54022473\",\n \"0.53976005\",\n \"0.5383299\",\n \"0.53648037\",\n \"0.53434795\",\n \"0.5329406\",\n \"0.5307623\",\n \"0.5307011\",\n \"0.5301138\",\n \"0.53002816\",\n \"0.52873904\",\n \"0.5281624\",\n \"0.5280695\",\n \"0.5264113\",\n \"0.52628404\",\n \"0.52484494\",\n \"0.52335364\",\n \"0.5206028\",\n \"0.5203644\",\n \"0.51940817\",\n \"0.5184033\",\n \"0.5156569\",\n \"0.51500154\",\n \"0.51459205\",\n \"0.5141768\",\n \"0.5137601\",\n \"0.51353586\",\n \"0.51310885\",\n \"0.512909\",\n \"0.51255155\",\n \"0.5125248\",\n \"0.5124645\",\n \"0.51224184\",\n \"0.50997543\",\n \"0.5096965\",\n \"0.5082389\",\n \"0.508154\",\n \"0.5077121\",\n \"0.507628\",\n \"0.50588083\",\n \"0.50574756\",\n \"0.5054117\",\n \"0.50433457\",\n \"0.5038871\",\n \"0.5038432\",\n \"0.5037229\",\n \"0.50362074\",\n \"0.5030928\",\n \"0.5030928\",\n \"0.5029663\",\n \"0.500732\",\n \"0.50072074\",\n \"0.5006999\",\n \"0.50067794\",\n \"0.5005948\",\n \"0.5003822\",\n \"0.5003027\",\n \"0.5002815\",\n \"0.4999105\",\n \"0.49983025\",\n \"0.49975967\",\n \"0.49950716\",\n \"0.49906045\",\n \"0.49894756\",\n \"0.49894336\",\n \"0.49874955\",\n \"0.49805117\",\n \"0.4979386\",\n \"0.4977572\",\n \"0.49757907\",\n \"0.49756017\",\n \"0.4968422\",\n \"0.49602962\",\n \"0.49554798\",\n \"0.49505997\",\n \"0.49436492\",\n \"0.49421632\",\n \"0.4940576\",\n \"0.4934333\",\n \"0.49336073\",\n \"0.49167928\",\n \"0.49065298\",\n \"0.49055937\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8038088"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83166,"cells":{"query":{"kind":"string","value":"Test the Bonferroni correction for pvalues"},"document":{"kind":"string","value":"def test_bonferroni_correction():\n p_values = np.linspace(0, 0.5, 4)\n rejected, corrected, alpha = bonferroni_correction(p_values)\n np.testing.assert_array_equal(corrected, np.array([0, 2 / 3, 1, 1]))\n assert rejected.tolist() == [True, False, False, False]\n assert alpha == 0.0125"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_bonferroni_correction(self):\r\n pvals = array([.1, .7, .5, .3, .9])\r\n exp = pvals * 5.\r\n obs = bonferroni_correction(pvals)\r\n self.assertFloatEqual(obs, exp)","def bonferroni_correction(pvals):\r\n return (\r\n array(pvals, dtype=float) * len(pvals) # float conversion: Nones->nans\r\n )","def test_correct_p_values(self):\r\n exp = [0.003, 0.006, 0.003]\r\n obs = self.mc._correct_p_values([0.001, 0.002, 0.001])\r\n assert_almost_equal(obs, exp)","def correct_pvalues_for_multiple_testing(pvalues, correction_type = \"Benjamini-Hochberg\"):\n pvalues = array(pvalues)\n n = int(pvalues.shape[0])\n new_pvalues = empty(n)\n if correction_type == \"Bonferroni\":\n new_pvalues = n * pvalues\n elif correction_type == \"Bonferroni-Holm\":\n values = [ (pvalue, i) for i, pvalue in enumerate(pvalues) ]\n values.sort()\n for rank, vals in enumerate(values):\n pvalue, i = vals\n new_pvalues[i] = (n-rank) * pvalue\n elif correction_type == \"Benjamini-Hochberg\":\n values = [ (pvalue, i) for i, pvalue in enumerate(pvalues) ]\n values.sort()\n values.reverse()\n new_values = []\n for i, vals in enumerate(values):\n rank = n - i\n pvalue, index = vals\n new_values.append((n/rank) * pvalue)\n for i in range(0, int(n)-1):\n if new_values[i] < new_values[i+1]:\n new_values[i+1] = new_values[i]\n for i, vals in enumerate(values):\n pvalue, index = vals\n new_pvalues[index] = new_values[i]\n return new_pvalues","def correct_pvalues_for_multiple_testing(pvalues, correction_type=\"Benjamini-Hochberg\"):\r\n from numpy import array, empty\r\n pvalues = array(pvalues)\r\n n = float(pvalues.shape[0])\r\n new_pvalues = empty(n)\r\n if correction_type == \"Bonferroni\":\r\n new_pvalues = n * pvalues\r\n elif correction_type == \"Bonferroni-Holm\":\r\n values = [(pvalue, i) for i, pvalue in enumerate(pvalues)]\r\n values.sort()\r\n for rank, vals in enumerate(values):\r\n pvalue, i = vals\r\n new_pvalues[i] = (n - rank) * pvalue\r\n elif correction_type == \"Benjamini-Hochberg\":\r\n values = [(pvalue, i) for i, pvalue in enumerate(pvalues)]\r\n values.sort()\r\n values.reverse()\r\n new_values = []\r\n for i, vals in enumerate(values):\r\n rank = n - i\r\n pvalue, index = vals\r\n new_values.append((n / rank) * pvalue)\r\n for i in range(0, int(n) - 1):\r\n if new_values[i] < new_values[i + 1]:\r\n new_values[i + 1] = new_values[i]\r\n for i, vals in enumerate(values):\r\n pvalue, index = vals\r\n new_pvalues[index] = new_values[i]\r\n return new_pvalues","def bonferroni_dunn(p_values, control):\n\n # Initial Checking\n if type(p_values) == pd.DataFrame:\n algorithms = p_values.columns\n p_values = p_values.values\n elif type(p_values) == np.ndarray:\n algorithms = np.array([\"Alg%d\" % alg for alg in range(p_values.shape[1])])\n\n if type(control) == str:\n control = int(np.where(algorithms == control)[0])\n if control is None:\n raise ValueError(\"Initialization ERROR. Incorrect value for control.\")\n\n k = p_values.shape[1]\n\n # sort p-values p(0) <= p(1) <= ... <= p(k-1)\n argsorted_pvals = np.argsort(p_values[0, :])\n\n APVs = np.zeros((k - 1, 1))\n comparison = []\n for i in range(k - 1):\n comparison.append(algorithms[control] + \" vs \" + algorithms[argsorted_pvals[i]])\n APVs[i, 0] = np.min([(k - 1) * p_values[0, argsorted_pvals[i]], 1])\n return pd.DataFrame(data=APVs, index=comparison, columns=[\"Bonferroni\"])","def test_fdr_correction(self):\r\n pvals = array([.1, .7, .5, .3, .9])\r\n exp = array([.5, .7 * 5 / 4., .5 * 5 / 3., .3 * 5 / 2., .9])\r\n obs = fdr_correction(pvals)\r\n self.assertFloatEqual(obs, exp)","def test_bisection_system(testFunctions,tol, printFlag):\n pass","def test_rr_bciimbensmanski(results):\n trueci = np.asarray([3.29158006, 6.46606603])\n ci1 = results.effect_ci_imbensmanski()\n ci2 = results.effect_ci(citype=\"Imbens-Manski\")\n assert ci1 == pytest.approx(trueci)\n assert ci2 == pytest.approx(trueci)","def test_correct_p_values_no_change(self):\r\n exp = [None, 0.008]\r\n obs = self.mc._correct_p_values([None, 0.008])\r\n self.assertEqual(obs, exp)\r\n exp = [0.007]\r\n obs = self.mc._correct_p_values([0.007])\r\n assert_almost_equal(obs, exp)","def multiple_testing_correction(pvalues, correction_type=\"FDR\"):\n from numpy import array, empty\n pvalues = array(pvalues)\n sample_size = pvalues.shape[0]\n qvalues = empty(sample_size)\n if correction_type == \"Bonferroni\":\n # Bonferroni correction\n qvalues = sample_size * pvalues\n elif correction_type == \"Bonferroni-Holm\":\n # Bonferroni-Holm correction\n values = [(pvalue, i) for i, pvalue in enumerate(pvalues)]\n values.sort()\n for rank, vals in enumerate(values):\n pvalue, i = vals\n qvalues[i] = (sample_size-rank) * pvalue\n elif correction_type == \"FDR\":\n # Benjamini-Hochberg, AKA - FDR test\n values = [(pvalue, i) for i, pvalue in enumerate(pvalues)]\n values.sort()\n values.reverse()\n new_values = []\n for i, vals in enumerate(values):\n rank = sample_size - i\n pvalue, index = vals\n new_values.append((sample_size/rank) * pvalue)\n for i in range(0, int(sample_size)-1):\n if new_values[i] < new_values[i+1]:\n new_values[i+1] = new_values[i]\n for i, vals in enumerate(values):\n pvalue, index = vals\n qvalues[index] = new_values[i]\n return qvalues","def _correct_p(self, f0, f1):\n return self.p * np.exp(self.dbeta * (f0 + f1) / 2)","def testPerron(self):\n self.assertTrue(irreducible.perron(self.f1))\n self.assertEqual(None, irreducible.perron(self.f2), \"non-monic\")","def ExpectedVal():\n input = f.LoadFile('\\\\rosalind_ebin.txt').splitlines()\n n = int(input[0])\n P = [float(x) for x in input[1].split()]\n \n B = [str(round(i*n,4)) for i in P]\n f.ExportToFile('rosalind_ebin_output.txt',' '.join(B))\n return","def P(phi, phib, df):\n\tprint 'P'\n\tif f(0,phi,phib,df)*f(1,phi,phib,df) < 0:\n\t\tprint 'brent'\n\t\t#return opt.brentq(f, 0, 1, args=(phi,df)) # Brent's method\n\t\t#return opt.brenth(f, 0, 1, args=(phi,df)) # Brent's method\n\t\treturn opt.bisect(f, 0, 1, args=(phi,phib,df)) # Bisection method\n\t\t#x,r = opt.bisect(f, 0, 1, args=(phi,df), full_output=True) # Bisection method\n\t\t#print r.iterations\n\t\t#return x\n\telse:\n\t\tprint 'newton'\n\t\treturn opt.newton(f, 0.5, args=(phi,phib,df)) # Newton-Raphson\n\t#print 'newtonpre'\n #return opt.newton(f, 1.0, args=(phi,phib,df)) # Newton-Raphson\n\t#print 'newtonpost'","def test_cape_cin_value_error():\n pressure = np.array([1012.0, 1009.0, 1002.0, 1000.0, 925.0, 896.0, 855.0, 850.0, 849.0,\n 830.0, 775.0, 769.0, 758.0, 747.0, 741.0, 731.0, 712.0, 700.0, 691.0,\n 671.0, 636.0, 620.0, 610.0, 601.0, 594.0, 587.0, 583.0, 580.0, 571.0,\n 569.0, 554.0, 530.0, 514.0, 506.0, 502.0, 500.0, 492.0, 484.0, 475.0,\n 456.0, 449.0, 442.0, 433.0, 427.0, 400.0, 395.0, 390.0, 351.0, 300.0,\n 298.0, 294.0, 274.0, 250.0]) * units.hPa\n temperature = np.array([27.8, 25.8, 24.2, 24, 18.8, 16, 13, 12.6, 12.6, 11.6, 9.2, 8.6,\n 8.4, 9.2, 10, 9.4, 7.4, 6.2, 5.2, 3.2, -0.3, -2.3, -3.3, -4.5,\n -5.5, -6.1, -6.1, -6.1, -6.3, -6.3, -7.7, -9.5, -9.9, -10.3,\n -10.9, -11.1, -11.9, -12.7, -13.7, -16.1, -16.9, -17.9, -19.1,\n -19.9, -23.9, -24.7, -25.3, -29.5, -39.3, -39.7, -40.5, -44.3,\n -49.3]) * units.degC\n dewpoint = np.array([19.8, 16.8, 16.2, 16, 13.8, 12.8, 10.1, 9.7, 9.7,\n 8.6, 4.2, 3.9, 0.4, -5.8, -32, -34.6, -35.6, -34.8,\n -32.8, -10.8, -9.3, -10.3, -9.3, -10.5, -10.5, -10, -16.1,\n -19.1, -23.3, -18.3, -17.7, -20.5, -27.9, -32.3, -33.9, -34.1,\n -35.9, -26.7, -37.7, -43.1, -33.9, -40.9, -46.1, -34.9, -33.9,\n -33.7, -33.3, -42.5, -50.3, -49.7, -49.5, -58.3, -61.3]) * units.degC\n cape, cin = surface_based_cape_cin(pressure, temperature, dewpoint)\n expected_cape, expected_cin = 2098.688061 * units('joules/kg'), 0.0 * units('joules/kg')\n assert_almost_equal(cape, expected_cape, 3)\n assert_almost_equal(cin, expected_cin, 3)","def test_crofton_method(self):\n\n chi_sq = lambda pred, obs: np.sum((obs - pred)**2 / pred)\n\n para_crof = np.arange(0, 9)\n\n crof = PIHM()\n\n # Data from Crofton 1971\n st1_obs = np.array([161, 111, 67, 65, 50, 30, 33, 13, 8])\n st2_obs = np.array([189, 129, 86, 51, 27, 14, 8, 1, 2])\n st3_obs = np.array([458, 81, 40, 22, 19, 4, 6, 3, 0])\n st4_obs = np.array([164, 147, 92, 43, 25, 11, 3, 0, 1])\n st5_obs = np.array([140, 77, 30, 14, 10, 3, 2, 0, 0])\n st6_obs = np.array([153, 29, 6, 2, 1, 0, 0, 0, 0])\n\n # Raw data\n st1_raw = np.repeat(para_crof, st1_obs)\n st2_raw = np.repeat(para_crof, st2_obs)\n st3_raw = np.repeat(para_crof, st3_obs)\n st4_raw = np.repeat(para_crof, st4_obs)\n st5_raw = np.repeat(para_crof, st5_obs)\n st6_raw = np.repeat(para_crof, st6_obs)\n\n # Crofton predicted with truncations!\n st1_pred = {\n 3: np.array([162.2, 103.9, 77.4, 60.4, 48.2, 38.9, 31.7, 26.0, 21.4]),\n 4: np.array([162.4, 103.4, 77.6, 61.2, 49.4, 40.5, 33.5, 27.9, 23.3]),\n 5: np.array([161.2, 107.0, 78.0, 58.7, 44.7, 34.4, 26.6, 20.7, 16.1]),\n 6: np.array([162.1, 104.6, 77.3, 59.5, 46.7, 37.1, 29.7, 23.9, 19.3]),\n 7: np.array([160.2, 108.8, 79.2, 58.9, 44.3, 33.6, 25.5, 19.5, 14.9]),\n 8: np.array([158.4, 111.7, 80.8, 59.0, 43.2, 31.7, 23.3, 17.2, 12.7])}\n\n st2_pred = {\n 3: np.array([188.6, 130.7, 83.6 , 52.0, 31.9, 19.4, 11.7, 7.0, 4.2]),\n 4: np.array([187.9, 133.0, 83.0, 49.4, 28.7, 16.5, 9.3, 5.3, 2.9,]),\n 5: np.array([187.3, 134.5, 83.0, 48.4, 27.4, 15.3, 8.4, 4.6, 2.5]),\n 6: np.array([187.2, 134.8, 83.1, 48.3, 27.3, 15.1, 8.3, 4.5, 2.4]),\n 7: np.array([185.3, 138.1, 84.2, 47.5, 25.7, 13.6, 7.0, 3.6, 1.8]),\n 8: np.array([185.5, 137.9, 84.1, 47.5, 25.8, 13.7, 7.1, 3.7, 1.9])}\n\n st3_pred = {\n 3: np.array([457.9, 81.8, 39.0, 22.5, 14.1, 9.2, 6.3, 4.3, 3.0]),\n 4: np.array([458.1, 79.5, 40.3, 25.0, 16.9, 12.0, 8.8, 6.5, 5.0]),\n 5: np.array([457.5, 83.7, 39.0, 21.9, 13.3, 8.5, 5.5, 3.7, 2.5]),\n 6: np.array([457.0, 83.4, 39.1, 22.0, 13.5, 8.6, 5.7, 3.8, 2.2]),\n 7: np.array([457.4, 84.1, 39.1, 21.8, 13.2, 8.3, 5.4, 3.6, 2.4])}\n\n # Station 1 comparison\n\n trunc = np.arange(3, 9)\n\n crof_st1_ks = [0.754, 0.736, 0.834, 0.776, 0.874, 0.951]\n crof_st1_N = [677, 708, 606, 646, 594, 573]\n our_st1_N = []\n our_st1_ks = []\n crof_st1_compare_ss = []\n\n crof.data = st1_raw\n\n for i in trunc:\n\n bin_edges = list(np.arange(0, i + 1)) + [i + 0.9]\n N, mu, k = crof.crofton_method(bin_edges)\n our_st1_ks.append(k)\n our_st1_N.append(N)\n\n assert_array_almost_equal(crof_st1_ks, our_st1_ks, decimal=1)\n\n # This will fail, but it is close\n # Uncomment and run nosetests to see results\n\n # assert_array_equal(crof_st1_N, our_st1_N)\n\n # Station 2 comparison\n\n crof_st2_ks = [1.182, 1.313, 1.392, 1.407, 1.574, 1.563]\n crof_st2_N = [535, 520, 514, 513, 508, 509]\n our_st2_N = []\n our_st2_ks = []\n crof_st2_compare_ss = []\n\n crof.data = st2_raw\n\n for i in trunc:\n\n bin_edges = list(np.arange(0, i + 1)) + [i + 0.9]\n N, mu, k = crof.crofton_method(bin_edges)\n our_st2_ks.append(k)\n our_st2_N.append(N)\n\n assert_array_almost_equal(crof_st2_ks, our_st2_ks, decimal=1)\n\n assert_array_equal(np.round(crof_st2_N, -1), np.round(our_st2_N, -1))\n\n # Station 3 comparison\n\n trunc = np.arange(3, 8)\n\n crof_st3_ks = [.229, .206, .244, .242, .247]\n crof_st3_N = [646, 670, 642, 643, 641]\n our_st3_N = []\n our_st3_ks = []\n crof_st3_compare_ss = []\n\n crof.data = st3_raw\n\n for i in trunc:\n\n bin_edges = list(np.arange(0, i + 1)) + [i + 0.9]\n N, mu, k = crof.crofton_method(bin_edges)\n our_st3_ks.append(k)\n our_st3_N.append(N)\n\n assert_array_almost_equal(crof_st3_ks, our_st3_ks, decimal=1)\n\n # Close to equal but not quite. Which is ok. We don't expect them\n # to be exactly equal\n # Uncomment and run nosetests to see\n\n # assert_array_equal(crof_st3_N, our_st3_N)","def P(phi, phib, df):\n\tif f(0,phi,phib,df)*f(1,phi,phib,df) < 0:\n\t\treturn opt.bisect(f, 0, 1, args=(phi,phib,df), maxiter=500) # Bisection method\n\telse:\n\t\treturn opt.newton(f, 1.0, args=(phi,phib,df), maxiter=5000) # Newton-Raphson","def test_robbins_confidence(self):\n c = array([1,2,3,0,1])\n r = robbins_confidence(c, 0.05)\n n = 7\n s = 2\n k = sqrt(8/0.05)\n self.assertEqual(r, ((s-k)/(n+1), (s+k)/(n+1)))","def test_correct_p_values_large_correction(self):\r\n exp = [1, None, 0.03, 0.03]\r\n obs = self.mc._correct_p_values([0.5, None, 0.01, 0.01])\r\n self.compare_multiple_level_array(obs, exp)","def test_newton_rhapson_system(testFunctions, tol, printFlag): \n pass","def getCorrectedPValues(pval_raw,alpha=0.05,method='fdr_i'):\n rej, pval_corr = smm.multipletests(pval_raw, alpha=alpha, method=method)[:2]\n return pval_corr","def test_brauer_2_dim_2_pval():\n expected_res = np.array(\n [\n [1, 1, 1],\n [0, 0, 0],\n [0, 0, 0],\n [1, 0, 0],\n [0, 0, 0],\n [0, 1, 0],\n [0, 0, 1],\n [0, 0, 0],\n [0, 0, 0],\n [0, 0, 1],\n [0, 1, 0],\n [0, 0, 0],\n [1, 0, 0],\n [0, 0, 0],\n [0, 0, 0],\n [1, 1, 1],\n ]\n )\n\n res = brauer(2, 2)\n\n bool_mat = np.isclose(res, expected_res)\n np.testing.assert_equal(np.all(bool_mat), True)","def fdr_correction(pvals):\r\n tmp = array(pvals).astype(float) # this converts Nones to nans\r\n return tmp * tmp.size / (1. + argsort(argsort(tmp)).astype(float))","def test_error_at_99tpr(self):\r\n\r\n return self.test_error_at_confidence(self.confidence_at_tpr(0.99))","def _pvalues_all(self):\n return 2.0 * (1.0 - scs.t.cdf(np.abs(self._tstat_all), self._df_err))","def lambda_test(p_values, df=1):\n from scipy.stats import chi2\n assert np.max(p_values) <= 1 and np.min(p_values) >= 0, 'These do not appear to be p-values'\n\n chi_sq_scores = chi2.ppf(1 - p_values, df)\n return np.median(chi_sq_scores) / chi2.ppf(0.5, df)","def test_newton_rhapson(testFunctions, tol, printFlag): \n pass","def test_correct_p_values_mixed(self):\r\n exp = [None, 0.008, 0.01, None]\r\n obs = self.mc._correct_p_values([None, 0.004, 0.005, None])\r\n self.assertEqual(obs, exp)","def p_value_inflation_test(p_values):\n from scipy.stats import ks_2samp\n h_null = np.random.uniform(0, 1, size=int(1e6))\n d, p_value = ks_2samp(p_values, h_null)\n return p_value, d","def test_chao1_bias_corrected(self):\n obs = chao1_bias_corrected(*osd(self.TestData))\n self.assertEqual(obs, 9.75)","def bCheck(c, v, p, b):\n val = (v+1).floor()\n deg = c.degree()\n coeffs = c.coefficients(sparse=False)\n lcoeff = coeffs[deg]; coeffs.remove(lcoeff)\n check1 = [(coeffs[i].valuation(p) - lcoeff.valuation(p))/(deg - i) for i in range(0,len(coeffs)) if coeffs[i] != 0]\n check2 = (val - lcoeff.valuation(p))/deg\n check1.append(check2)\n bval = min(check1)\n return (bval).ceil()","def test_bayes_updates_good_data(self):\r\n # result for first -> fourth calculated by hand\r\n for obs, exp in zip(bayes_updates(self.test), self.result):\r\n self.assertFloatEqualAbs(obs, exp, 1e-11)","def test_fixed_point_system(testFunctions, tol, printFlag): \n pass","def test_fixed_point(testFunctions, tol, printFlag): \n pass","def test_rr_pz(results):\n truepz = np.asarray([4.43677606e-09, 7.89531535e-01, 7.89747372e-01,\n 8.04473756e-08, 2.22044605e-15])\n test_pz = results.params_pvalue()\n assert test_pz == pytest.approx(truepz)","def _calc_pval(self):\n t = self.beta / self.stderr_beta\n return (2. * (1. - stats.t.cdf(np.abs(t), self.n - 2)))[0]","def test_error_at_995tpr(self):\r\n\r\n return self.test_error_at_confidence(self.confidence_at_tpr(0.995))","def bisection(f,a,b,tol=1e-4,Max_trial=14):\n pvalues = np.zeros(Max_trial+3)\n fvalues = np.zeros(Max_trial+3)\n fa,fb = f(a),f(b)\n pvalues[0],pvalues[1]=a,b\n fvalues[0],fvalues[1]=fa,fb\n\n if fa*fb>0:\n print('f(a)*f(b)>0 ---> specified a and b do not work!')\n print('spiting out a or b --- whichever is closer')\n \n if np.abs(fa)<=fb:\n return a,f(a)\n else:\n return b,f(b)\n \n \n p=(a+b)/2\n pvalues[2]=p\n fp=f(p)\n fvalues[2]=fp\n err=np.abs(fp)\n\n j=0\n while err > tol and j<Max_trial:\n\n if fa*fp<0:\n b=p\n p=(a+b)/2\n fp = f(p)\n else:\n a=p\n fa = fp\n p=(a+b)/2\n fp = f(p)\n\n err=abs(fp)\n print('-------------------------------------------------------')\n print('bisection trial #'+str(j)+': sol='+str(p)+', mismatch ='+str(err))\n print('-------------------------------------------------------')\n j=j+1\n pvalues[j+2]=p\n fvalues[j+2]=fp\n # print('p='+str(p))\n # print('a,b='+str(a)+'--'+str(b))\n\n pvalues,fvalues=pvalues[:j+3],fvalues[:j+3]\n\n return pvalues,fvalues","def test_prob_expectation_values(self, approx_order, strategy, tol):\r\n dev = qml.device(\"default.qubit\", wires=2)\r\n x = 0.543\r\n y = -0.654\r\n\r\n with qml.tape.JacobianTape() as tape:\r\n qml.RX(x, wires=[0])\r\n qml.RY(y, wires=[1])\r\n qml.CNOT(wires=[0, 1])\r\n qml.expval(qml.PauliZ(0))\r\n qml.probs(wires=[0, 1])\r\n\r\n tapes, fn = finite_diff(tape, approx_order=approx_order, strategy=strategy)\r\n res = fn(dev.batch_execute(tapes))\r\n assert res.shape == (5, 2)\r\n\r\n expected = (\r\n np.array(\r\n [\r\n [-2 * np.sin(x), 0],\r\n [\r\n -(np.cos(y / 2) ** 2 * np.sin(x)),\r\n -(np.cos(x / 2) ** 2 * np.sin(y)),\r\n ],\r\n [\r\n -(np.sin(x) * np.sin(y / 2) ** 2),\r\n (np.cos(x / 2) ** 2 * np.sin(y)),\r\n ],\r\n [\r\n (np.sin(x) * np.sin(y / 2) ** 2),\r\n (np.sin(x / 2) ** 2 * np.sin(y)),\r\n ],\r\n [\r\n (np.cos(y / 2) ** 2 * np.sin(x)),\r\n -(np.sin(x / 2) ** 2 * np.sin(y)),\r\n ],\r\n ]\r\n )\r\n / 2\r\n )\r\n\r\n assert np.allclose(res, expected, atol=tol, rtol=0)","def test_rr_bciupper(results):\n trueci = np.asarray([3.56102163, np.inf])\n ci1 = results.effect_ci_upper()\n ci2 = results.effect_ci(citype=\"upper\")\n assert ci1 == pytest.approx(trueci)\n assert ci2 == pytest.approx(trueci)","def pbias(self) -> float:\n return float(100.0 * sum(self.predicted - self.true) / sum(self.true))","def test_correctness(self):\n M_win = 1024\n N_fft = 131072\n # Set norm=False for correctness as the values obtained from the\n # scientific publication do not normalize the values. Normalizing\n # changes the sidelobe level from the desired value.\n w = windows.taylor(M_win, nbar=4, sll=35, norm=False, sym=False)\n f = fft(w, N_fft)\n spec = 20 * np.log10(np.abs(f / np.amax(f)))\n\n first_zero = np.argmax(np.diff(spec) > 0)\n\n PSLL = np.amax(spec[first_zero:-first_zero])\n\n BW_3dB = 2*np.argmax(spec <= -3.0102999566398121) / N_fft * M_win\n BW_18dB = 2*np.argmax(spec <= -18.061799739838872) / N_fft * M_win\n\n assert_allclose(PSLL, -35.1672, atol=1)\n assert_allclose(BW_3dB, 1.1822, atol=0.1)\n assert_allclose(BW_18dB, 2.6112, atol=0.1)","def _p_value(self):\n p_value = chi2.sf(self.test_statistic, 2)\n\n return p_value","def test_bart(self):\n valid, _ = testing_utils.eval_model(\n dict(task='integration_tests', model='bart', num_examples=10)\n )\n self.assertAlmostEqual(valid['ppl'].value(), 1.0, places=1)","def compute_pvalue(self):\n # Run permutation test\n self.PermutationTest()\n # TS obtained from the original B,T samples\n self.compute_obs_TS()\n \n # Mean and std of the TS distribution\n self.mu = np.mean(self.TS_tilde)\n self.sigma = np.std(self.TS_tilde)\n \n # Standardized test statistic (zero mean, unit variance)\n self.TS_prime = (self.TS_tilde - self.mu)/self.sigma\n self.TS_prime_obs = (self.TS_obs - self.mu)/self.sigma\n \n # Two-sided p-value from TS' distribution\n self.p_value = 2*(1 - 0.01 * stats.percentileofscore(self.TS_prime,\n abs(self.TS_prime_obs)) )\n \n # if 0, compute it from standard normal\n if self.p_value == 0.0:\n self.p_value = self.pvalue_gaussian()\n \n print(\"\")\n print(\"p-value = {:e}\".format(self.p_value))","def benjamini_hochberg_step_down(pvals):\r\n tmp = fdr_correction(pvals)\r\n corrected_vals = empty(len(pvals))\r\n max_pval = 1.\r\n for i in argsort(pvals)[::-1]:\r\n if tmp[i] < max_pval:\r\n corrected_vals[i] = tmp[i]\r\n max_pval = tmp[i]\r\n else:\r\n corrected_vals[i] = max_pval\r\n return corrected_vals","def getpval(teststat, statlist):\n \n propzero = 0\n bootvals = []\n for val in statlist:\n if val == 0:\n propzero += 1\n else:\n bootvals.append(val)\n \n propzero = float(propzero) / len(statlist)\n \n shapeinit = getstartingshape(statlist)\n \n shape = optimiselike(getlikeweibull, bootvals, shapeinit)\n scale = (sum(bootvals) / len(bootvals)) / scipy.special.gamma(1 + 1/shape)\n \n pvalue = math.exp(- (teststat/scale) ** shape)\n \n return pvalue * (1 - propzero)","def benjamin_hochberg_correction(p_values, alpha=0.05):\n m = len(p_values)\n p_values = sorted(p_values)\n for k, p in enumerate(p_values):\n if p > (k + 1) / m * alpha:\n index = k - 1\n if index < 0:\n return 0\n return p_values[index]","def calculate_f_p(genes, gene_abundance_file, gene_molecular_weight_file):\n gene_abundance = pd.read_csv(gene_abundance_file, index_col=0)\n gene_molecular_weight = json_load(gene_molecular_weight_file)\n enzy_abundance = 0\n pro_abundance = 0\n for gene_i in gene_abundance.index:\n if gene_i in gene_molecular_weight.keys():\n abundance = gene_abundance.loc[gene_i, 'abundance'] * \\\n gene_molecular_weight[gene_i]/1000\n pro_abundance += abundance\n if gene_i in genes.index:\n enzy_abundance += abundance\n f = enzy_abundance/pro_abundance\n return f","def test_pkstwo(self):\n self.assertFloatEqual(pkstwo(2.3),[1-5.084e-05],eps=1e-5)","def f_test(chi1,df1,chi2,df2,red_chi = True):\n\n# if chi1/df1 > chi2/df2:\n#\tprob = 2. * f.cdf(chi1/df1, chi2/df2, df1, df2)\n# else:\n#\tprob = 2. * f.cdf(chi2/df2, chi1/df1, df2, df1)\n if red_chi:\n\tfval = (chi1/df1) / (chi2/df2)\n else:\n\tfval = chi1 / chi2\n prob = 2. * f.cdf((chi1/df1) / (chi2/df2), df1, df2)\n if prob > 1.: \n\treturn 2. - prob\n else:\n\treturn prob","def logit_pvalue(model, x, verbose=False):\n probs = model.predict_proba(x)\n n_datapoints = probs.shape[0]\n n_feautures = len(model.coef_[0]) + 1\n coeffs = np.hstack([model.intercept_.reshape(-1, 1), model.coef_])\n x_full = np.matrix(np.insert(np.array(x), 0, 1, axis=1))\n pvals = []\n errors = []\n for coeffs_vec, p_vec in zip(coeffs, probs.T):\n ans = np.zeros((n_feautures, n_feautures))\n for i in range(n_datapoints):\n ans += np.dot(x_full[i].T, x_full[i]) * p_vec[i] * (1 - p_vec[i])\n try:\n vcov = np.linalg.inv(np.matrix(ans))\n serrors = np.sqrt(np.diag(vcov))\n t = coeffs_vec / serrors\n pn = (1 - norm.cdf(abs(t))) * 2\n except np.linalg.linalg.LinAlgError as e:\n if verbose:\n print(\"det : {0}\".format(np.linalg.det(np.matrix(ans))))\n serrors = np.zeros(ans.shape[0])\n pn = np.zeros(ans.shape[0])\n pvals.append(pn)\n errors.append(serrors)\n pvals = np.array(pvals)\n errors = np.array(errors)\n return pvals.T, coeffs.T, errors.T","def _correct_p_values(self, p_vals):\r\n num_tests = len([p_val for p_val in p_vals if p_val is not None])\r\n corrected_p_vals = []\r\n for p_val in p_vals:\r\n if p_val is not None:\r\n corrected_p_vals.append(min(p_val * num_tests, 1))\r\n else:\r\n corrected_p_vals.append(p_val)\r\n return corrected_p_vals","def lfprob (dfnum, dfden, F):\r\n p = betai(0.5*dfden, 0.5*dfnum, dfden/float(dfden+dfnum*F))\r\n return p","def check_fpp_ratio(self,\n ion_params,\n wavelength,\n fpp_ratio_min = 0.3,\n fpp_ratio_max = 1.05):\n identity = str(ion_params)\n inaccuracies = self.inaccuracies.get(identity, None)\n if (inaccuracies is None):\n inaccuracies = self.inaccuracies[identity] = set()\n if (ion_params.element.upper() in [\"MG\", \"NA\"]):\n if (self.fpp is not None) or (self.peak_anom is not None and self.peak_anom > 1):\n inaccuracies.add(self.BAD_FPP)\n else :\n # XXX in theory the fpp_ratio should be no more than 1.0 unless we are\n # right on the peak wavelength. in practice Phaser can overshoot a little\n # bit, so we need to be more tolerant. picking the maximum f'' from the\n # Sasaki and Henke tables will also limit the ratio.\n if (wavelength is not None) and (self.anomalous_flag):\n fpp_expected_sasaki = sasaki.table(ion_params.element).at_angstrom(\n wavelength).fdp()\n fpp_expected_henke = henke.table(ion_params.element).at_angstrom(\n wavelength).fdp()\n self.fpp_expected[identity] = max(fpp_expected_sasaki,\n fpp_expected_henke)\n if (self.fpp is not None) and (self.fpp_expected[identity] != 0):\n self.fpp_ratios[identity] = self.fpp / self.fpp_expected[identity]\n if ((self.fpp_ratios[identity] > fpp_ratio_max) or\n ((self.fpp >= 0.2) and\n (self.fpp_ratios[identity] < fpp_ratio_min))):\n inaccuracies.add(self.BAD_FPP)\n elif (self.fpp_expected[identity] > 0.75) and (self.peak_anom < 2):\n inaccuracies.add(self.BAD_FPP)\n return self.fpp_ratios.get(identity)","def ppf(self,x):\n ppfValue = self._distribution.inverseCdf(x,random())\n return ppfValue","def ppf(self,x):\n ppfValue = self._distribution.inverseCdf(x,random())\n return ppfValue","def test_error_at_98tpr(self):\r\n\r\n return self.test_error_at_confidence(self.confidence_at_tpr(0.98))","def test_p_or_p(self):\r\n\r\n result = self.formulaGen.mainResultOne()\r\n self.assertEqual(result, [' P ∨ P → P valid sat 1.0', ' P ∧ P ↔ P valid sat 1.0', ' P ∧ P → P valid sat 1.0', ' P ∨ P ↔ P valid sat 1.0', '(P ∨ P) ↔ P valid sat', '(P ∨ P ↔ P) valid sat', 'P ∨ (P ↔ P) valid sat'])","def expected_value_of_outcome(n, p):\r\n expected = n * p\r\n print(\"expected value / mean = \", expected)\r\n return expected","def test_jacobian(self):\n\n gT1 = Pose2(1, 2, np.pi/2)\n gT2 = Pose2(-1, 4, np.pi)\n\n expected = Pose2(2, 2, np.pi/2)\n\n def error_func(this: CustomFactor, v: gtsam.Values, H: List[np.ndarray]):\n # print(f\"{this = },\\n{v = },\\n{len(H) = }\")\n\n key0 = this.keys()[0]\n key1 = this.keys()[1]\n gT1, gT2 = v.atPose2(key0), v.atPose2(key1)\n error = Pose2(0, 0, 0).localCoordinates(gT1.between(gT2))\n \n if len(H) > 0:\n result = gT1.between(gT2)\n H[0] = -result.inverse().AdjointMap()\n H[1] = np.eye(3)\n return error\n \n noise_model = gtsam.noiseModel.Unit.Create(3)\n cf = ge.CustomFactor(noise_model, gtsam.KeyVector([0, 1]), error_func)\n v = Values()\n v.insert(0, gT1)\n v.insert(1, gT2)\n \n bf = gtsam.BetweenFactorPose2(0, 1, Pose2(0, 0, 0), noise_model)\n\n gf = cf.linearize(v)\n gf_b = bf.linearize(v)\n\n J_cf, b_cf = gf.jacobian()\n J_bf, b_bf = gf_b.jacobian()\n np.testing.assert_allclose(J_cf, J_bf)\n np.testing.assert_allclose(b_cf, b_bf)","def test_PhredValueTest(self):\n phredscore=0\n realscore=[6.197200000000001 ,0.08488999999999997]\n for line in self.phredlines:\n phredscore=phredvalues_version8(line)\n self.assertEqual(phredscore, realscore)\n #since the function is used in errorproducer, the absurdly high value of 6.197 is needed to match self.fastQ's phred score","def test_bs(self):\r\n res = BlackScholes(100, 0.10, 0.5, 1.00)\r\n self.assertEqual(round(res, 2), 23.93)","def test_Sobol_G_raises_error_if_values_gt_one():\n evaluate(np.array([0, 1, .02, 0.23, 1.234, 0.02848848, 0, 0.78]))","def clopper_pearson_err(k, n, CL=[0.025, 0.975]):\n # Special case must be treated separately\n if k == 0:\n lower = 0\n upper = 1 - (1-CL[1])**(1/n)\n\n # Special case must be treated separately\n elif k == n:\n lower = CL[0]**(1/n)\n upper = 1\n\n # Normal case\n else:\n lower = stats.beta.ppf(q=CL[0], a=k, b=n-k+1)\n upper = stats.beta.ppf(q=CL[1], a=k+1, b=n-k)\n\n return np.array([lower, upper])","def prf(stats):\n if stats['pred'] == 0:\n return 0, 0, 0\n p = stats['corr']/stats['pred']\n r = stats['corr']/stats['gold']\n if p > 0 and r > 0:\n f = 2*p*r/(p+r)\n else:\n f = 0\n return p, r, f","def test_correct_p_values_empty(self):\r\n exp = []\r\n obs = self.mc._correct_p_values([])\r\n assert_almost_equal(obs, exp)","def ErrorCorrect(val,fEC):\n return val * fEC","def test_bisection_1b(self):\n logging.info(\"\\nANSWERS TO EXERCISE 1.1B\")\n left = 0.5\n right = 3.1\n\n # The final interval should contain the desired root.\n root, (left, right) = undertest.bisection(self.func, left, right, self.maxit)\n self.assertTrue(_root_in_interval(self.desired_root, left, right))","def Pvar(magnitude, error):\n\n #magnitude = data[0]\n #error = data[1]\n\n# print(magnitude)\n \n# print(error)\n \n mean_mag = np.mean(magnitude)\n nepochs = float(len(magnitude))\n\n chi = np.sum((magnitude - mean_mag)**2. / error**2.)\n p_chi = chi2.cdf(chi, (nepochs-1))\n\n return p_chi","def infer_pvalues(self, p=0.05, mcp='fdr'):\n # ---------------------------------------------------------------------\n # check that pac and surrogates has already been computed\n assert hasattr(self, 'erpac'), (\"You should compute ERPAC first. Use \"\n \"the `fit` method\")\n assert mcp in ['fdr', 'bonferroni']\n\n # correct the p-values for multiple comparisons (Voytek's only)\n if \"Voytek\" in self.method:\n logger.info(f\" Correct p-values for multiple-comparisons using \"\n f\"{mcp} correction of MNE-Python\")\n from mne.stats import fdr_correction, bonferroni_correction\n fcn = fdr_correction if mcp is 'fdr' else bonferroni_correction\n _, self._pvalues = fcn(self._pvalues, alpha=p)\n else:\n assert hasattr(self, 'surrogates'), \"No surrogates computed\"\n # compute the p-values using maxstat (gcPAC)\n self._pvalues = self._infer_pvalues(self.erpac, self.surrogates,\n p=p)\n\n return self._pvalues","def test_correct_pl_gates(self, basis_state, wires, target_wires):\n\n with patch(\"pennylane.PauliX\") as mock:\n BasisStatePreparation(basis_state, wires)\n\n called_wires = [args[0] for args, kwargs in mock.call_args_list]\n\n assert len(target_wires) == len(called_wires)\n assert np.array_equal(called_wires, target_wires)","def p_value(beta_hat_j, sigma_hat_j):\n if beta_hat_j > 0:\n return 2 - (1 * norm.cdf(beta_hat_j / sigma_hat_j))\n else:\n return 2 * norm.cdf(beta_hat_j / sigma_hat_j)","def test_b_coefficients(x1,x2,x3,y1,y2,y3,CCoefficients,DCoefficients,expected_slope):\n\tB = b_coefficients(x1,x2,x3,y1,y2,y3,CCoefficients,DCoefficients)\n\tresult = abs(B[0]-expected_slope)< 0.001\n\treturn(result)\n\tassert B[0]==expected_slope, \"First b coefficient (%f) does not equal initial slope (%f).\" (B[0],expected_slope)","def validate_probabilities(pmf, ops):\n one = ops.one\n zero = ops.zero\n\n # Make sure the values are in the correct range.\n # Recall ops.zero = +inf for bases less than 1.\n # ops.zero = -inf for bases greater than 1.\n\n # First find the values which are possibly bad.\n too_low = pmf < min(zero, one)\n too_high = pmf > max(zero, one)\n if too_low.any() or too_high.any():\n # But 1.000000000000001 is not really bad. So let's keep only the\n # values that are significantly too low or too high.\n too_low[too_low] = np.logical_not(np.isclose(pmf[too_low], zero))\n too_high[too_high] = np.logical_not(np.isclose(pmf[too_high], one))\n if too_low.any() or too_high.any():\n bad = pmf[np.logical_or(too_low, too_high)]\n raise InvalidProbability(bad, ops=ops)\n\n return True","def test_error_at_95tpr(self):\r\n\r\n return self.test_error_at_confidence(self.confidence_at_tpr(0.95))","def ppf(self,x):\n ppfValue = self.invCDF(x)\n return ppfValue","def test_bayes_updates_permuted(self):\r\n for obs, exp in zip(bayes_updates(self.permuted), self.result):\r\n self.assertFloatEqualAbs(obs, exp, 1e-11)","def correct_fwe_montecarlo(self, result, n_iters=10000, n_cores=1):\n n_cores = _check_ncores(n_cores)\n\n log_p_map, t_map, _ = permuted_ols(\n self.parameters_[\"tested_vars\"],\n self.inputs_[\"beta_maps\"],\n confounding_vars=self.parameters_[\"confounding_vars\"],\n model_intercept=False, # modeled by tested_vars\n n_perm=n_iters,\n two_sided_test=self.two_sided,\n random_state=42,\n n_jobs=n_cores,\n verbose=0,\n )\n\n # Fill complete maps\n p_map = np.power(10.0, -log_p_map)\n\n # Convert p to z, preserving signs\n sign = np.sign(t_map)\n sign[sign == 0] = 1\n z_map = p_to_z(p_map, tail=\"two\") * sign\n maps = {\n \"logp_level-voxel\": _boolean_unmask(\n log_p_map.squeeze(), self.inputs_[\"aggressive_mask\"]\n ),\n \"z_level-voxel\": _boolean_unmask(z_map.squeeze(), self.inputs_[\"aggressive_mask\"]),\n }\n\n description = (\n \"Family-wise error rate correction was performed using Nilearn's \"\n \"\\\\citep{10.3389/fninf.2014.00014} permuted OLS method, in which null distributions \"\n \"of test statistics were estimated using the \"\n \"max-value permutation method detailed in \\\\cite{freedman1983nonstochastic}. \"\n f\"{n_iters} iterations were performed to generate the null distribution.\"\n )\n\n return maps, {}, description","def get_initial_params(self, x, y, yerr):\n# p0 = zeros(self.max_phonons + 1)\n p0 = zeros(2)\n p0[0] = 100\n p0[1] = .1\n return p0","def test_joint_fitter(self):\n p1 = [14.9, 0.3]\n p2 = [13, 0.4]\n A = 9.8\n p = np.r_[A, p1, p2]\n\n def model(A, p, x):\n return A * np.exp(-0.5 / p[1] ** 2 * (x - p[0]) ** 2)\n\n def errfunc(p, x1, y1, x2, y2):\n return np.ravel(\n np.r_[model(p[0], p[1:3], x1) - y1, model(p[0], p[3:], x2) - y2]\n )\n\n coeff, _ = optimize.leastsq(\n errfunc, p, args=(self.x, self.ny1, self.x, self.ny2)\n )\n assert_allclose(coeff, self.jf.fitparams, rtol=10 ** (-2))","def test_pi_func(self):\n result = calculator.pi_func(2)\n self.assertEqual(result, 6.28)","def bisection(f, fu, point_a, point_b, point_c, point_d, lower_bound, upper_bound, length):\n n = 1\n theta = 0\n a = lower_bound\n b = upper_bound\n while n <= 100:\n theta = (a + b) / 2.0\n if -1e-6 < f(fu(point_a, point_b, point_c, theta), point_d) - length < 1e-6:\n # print 'Residual', f(fu(point_a, point_b, point_c, theta), point_d) - length\n # print 'iteration', n\n return theta\n else:\n n = n + 1\n if f(fu(point_a, point_b, point_c, theta), point_d) - length > 0:\n b = theta\n else:\n a = theta\n\n print 'failedtheta', theta, 'Residual', f(fu(point_a, point_b, point_c, theta), point_d) - length\n print 'iteration', n\n return False","def test_reference_value(self):\n\n self.helmholtz_spin_flipper.windings = 124\n self.helmholtz_spin_flipper.radius = 14.9 * 1e-2 # [m]\n self.helmholtz_spin_flipper.current = 1\n\n position = (0, 0, 0)\n\n reference_value = 0.29539497010675775 # [T]\n\n # Evaluate\n b_field_value = self.helmholtz_spin_flipper.b_field(position)[0]\n\n # Assert numerical value\n self.assertEqual(reference_value, b_field_value)","def test_correlation_test_pearson(self):\r\n # These results were verified with R.\r\n\r\n # Test with non-default confidence level and permutations.\r\n obs = correlation_test(self.data1, self.data2, method='pearson',\r\n confidence_level=0.90, permutations=990)\r\n self.assertFloatEqual(obs[:2], (-0.03760147, 0.91786297277172868))\r\n self.assertEqual(len(obs[2]), 990)\r\n for r in obs[2]:\r\n self.assertTrue(r >= -1.0 and r <= 1.0)\r\n self.assertCorrectPValue(0.9, 0.93, correlation_test,\r\n (self.data1, self.data2),\r\n {'method': 'pearson', 'confidence_level': 0.90,\r\n 'permutations': 990}, p_val_idx=3)\r\n self.assertFloatEqual(obs[4], (-0.5779077, 0.5256224))\r\n\r\n # Test with non-default tail type.\r\n obs = correlation_test(self.data1, self.data2, method='pearson',\r\n confidence_level=0.90, permutations=990,\r\n tails='low')\r\n self.assertFloatEqual(obs[:2], (-0.03760147, 0.45893148638586434))\r\n self.assertEqual(len(obs[2]), 990)\r\n for r in obs[2]:\r\n self.assertTrue(r >= -1.0 and r <= 1.0)\r\n self.assertCorrectPValue(0.41, 0.46, correlation_test,\r\n (self.data1, self.data2),\r\n {'method': 'pearson', 'confidence_level': 0.90,\r\n 'permutations': 990, 'tails': 'low'}, p_val_idx=3)\r\n self.assertFloatEqual(obs[4], (-0.5779077, 0.5256224))","def pvalue_test(self, alpha=0.01):\n CL = int((1-alpha)*100) # confidence level\n \n if self.p_value < alpha:\n print(\"Null hypothesis rejected at {:d}%CL => distributions are different\".format(CL))\n else:\n print(\"Null hypothesis NOT rejected => distributions are the same\")","def test_call(self):\r\n exp = {'method_name': 'BEST',\r\n 'rho_vals': [\r\n (0.75, '8'),\r\n (0.5, '1,11'),\r\n (0.5107142857142857, '1,8,11'),\r\n (0.47857142857142854, '1,6,8,11'),\r\n (0.46071428571428574, '1,5,6,8,9'),\r\n (0.4357142857142857, '1,5,6,8,9,11'),\r\n (0.38928571428571423, '1,2,4,5,6,7,8'),\r\n (0.38928571428571423, '1,2,4,5,6,7,8,9'),\r\n (0.38928571428571423, '1,2,4,5,6,7,8,9,10'),\r\n (0.38928571428571423, '1,2,4,5,6,7,8,9,10,11'),\r\n (0.16785714285714282, '1,2,3,4,5,6,7,8,9,10,11')],\r\n 'num_vars': 11,\r\n 'vars': ['TOT_ORG_CARB = 1', 'SILT_CLAY = 2',\r\n 'ELEVATION = 3', 'SOIL_MOISTURE_DEFICIT = 4',\r\n 'CARB_NITRO_RATIO = 5', 'ANNUAL_SEASON_TEMP = 6',\r\n 'ANNUAL_SEASON_PRECPT = 7', 'PH = 8',\r\n 'CMIN_RATE = 9', 'LONGITUDE = 10',\r\n 'LATITUDE = 11']}\r\n\r\n # the difference caused by the new spearmans_rho function is in the\r\n # final decimal place of the rho_vals. its not a significant difference,\r\n # but the test is failing because we are doing a dict comparison for\r\n # float values.\r\n obs = self.best()\r\n self.assertEqual(exp['method_name'], obs['method_name'])\r\n self.assertEqual(exp['num_vars'], obs['num_vars'])\r\n self.assertEqual(exp['vars'], obs['vars'])\r\n for i, j in zip(exp['rho_vals'], obs['rho_vals']):\r\n assert_almost_equal(i[0], j[0])\r\n self.assertEqual(i[1], j[1])\r\n # check that the keys are the same since we have checked all the values\r\n # we expect to be there are the same\r\n self.assertTrue(set(exp.keys()) == set(obs.keys()))","def test_converges_to_accurate_values(fake_args):\n with tempfile.TemporaryDirectory() as tmp_dir:\n fake_args.return_value = FakeArguments('orvara/tests/diagnostic_config.ini', tmp_dir)\n tt = run()[1].data\n # check params\n i = -1 # walker index.\n burn = 250 # number of burn in steps to discard\n rv_jitter = np.mean(tt['jitter'][i, burn:])\n rv_jitter_err = np.std(tt['jitter'][i, burn:])\n companion_jup_mass = np.mean(tt['msec0'][i, burn:]*1989/1.898)\n companion_mass_stderr = np.std(tt['msec0'][i, burn:]*1989/1.898)\n separation_AU = np.mean(tt['sau0'][i, burn:])\n separation_stderr = np.std(tt['sau0'][i, burn:])\n eccentricity = np.mean(tt['esino0'][i, burn:]**2 + tt['ecoso0'][i, burn:]**2)\n eccentricity_stderr = np.std(tt['esino0'][i, burn:]**2 + tt['ecoso0'][i, burn:]**2)\n inclination_deg = np.mean(tt['inc0'][i, burn:]*180/np.pi)\n inclination_err = np.std(tt['inc0'][i, burn:]*180/np.pi)\n\n expected_1_sigma_errors = [0.6282, 2.9215, 0.44668, 0.0030392, 2.3431]\n expected_values = [4.9378, 67.04218, 10.189, 0.73568, 49.89184]\n values = [rv_jitter, companion_jup_mass, separation_AU, eccentricity, inclination_deg]\n errors = [rv_jitter_err, companion_mass_stderr, separation_stderr,\n eccentricity_stderr, inclination_err]\n for value, expected, sigma in zip(values, expected_values, expected_1_sigma_errors):\n assert np.isclose(value, expected, atol=3 * sigma)\n assert np.allclose(errors, expected_1_sigma_errors, rtol=.5)","def test_rr_ci(results):\n trueci = np.asarray([[8.19806824, -51.8197922, -183.75877191, 3.25948071,\n 3.91491988],\n [16.42312995, 68.15921213, 241.62975025, 7.01060682,\n 6.48808526]])\n test_ci = results.params_ci()\n assert test_ci == pytest.approx(trueci)","def atmoBowman(f): \n freq = np.array([\n 0.01, 0.0155, 0.0239, 0.0367, 0.0567,\n 0.0874, 0.1345, 0.2075, 0.32, 0.5,\n 0.76, 1.17, 1.8, 2.79, 4.3,\n 6.64, 10, 100,\n ])\n pressure_asd = sqrt([\n 22.8, 4, 0.7, 0.14, 0.027, 0.004,\n 0.0029, 0.0039, 7e-4, 1.44e-4, 0.37e-4,\n 0.12e-4, 0.56e-5, 0.35e-5, 0.26e-5, 0.24e-5,\n 2e-6, 2e-6,\n ])\n return 10**(np.interp(log10(f), log10(freq), log10(pressure_asd)))","def test_pressure_increasing_check_some_constants(mocker, pressure_values, expected):\n profile = mocker.patch.object(argortqcpy.profile, \"Profile\")\n profile.get_property_data = mocker.Mock(return_value=ma.masked_array(pressure_values))\n\n pic = PressureIncreasingCheck(profile, None)\n output = pic.run()\n\n assert np.all(output.get_output_flags_for_property(\"PRES\").data == expected)","def test_model(parameters):\n if parameters is None:\n return \"No Value\"\n else:\n return round(modelo.predict_proba([parameters])[0]*100, 3)","def calc_b_wilson(labelcorrs_plugin, numsamps, failure_prob=0.01):\n err_est = 0.5*(1.0 - labelcorrs_plugin)\n z = sp.stats.norm.ppf(0.5*(2-failure_prob))\n zsq_n = z*z/numsamps\n sleeping_specs = np.isinf(zsq_n)\n recentered_mean_errors = np.multiply(1.0/(1+zsq_n), (err_est + 0.5*zsq_n))\n recentered_plugins = 1.0 - 2*recentered_mean_errors\n stddevs = np.sqrt(np.multiply(zsq_n, np.multiply(\n err_est, 1.0 - err_est)) + np.square(0.5*zsq_n))\n stddevs = np.multiply(1.0/(1+zsq_n), stddevs)\n toret = np.maximum(recentered_plugins - 2*stddevs, 0.0)\n toret[sleeping_specs] = 0.0\n return toret","def test_dixon_price(self):\n fun = get_problem('dixon_price', 2, -10, 10)\n solution = np.array([1.0, 0.70710678])\n self.assertAlmostEqual(fun(solution), 0.0)","def stats_holmBonf(p,plot='false'):\t\n\talpha = 0.05\n\tk = len(p)\n\tidx = [i[0] for i in sorted(enumerate(p), key=lambda x:x[1])]\n\tcorrected_p = alpha/np.arange(k+1,1,-1)\n\t\n\th = p <= corrected_p\n\tif np.sum(h) > 0 :\n\t\tidx_first_zero = np.where(h == 0)[0][0] #get first index where you cannot reject the null-hypothesis\n\t\th[idx_zero:] = 0\n\t\n\t\tif plot == 'true': \n\t\t\tplt.plot(p,'ko-')\n\t\t\tplt.plot(c,'r-')\n\t\t\tx=np.arange(len(p))\n\t\t\tplt.fill_between(x,0,p,where=h,facecolor='red')\n\t\n\t\th = h[idx]\n\t\tp_holm = c[idx_first_zero]\n\telse:\n\t\tprint \"None of the p-value exceed the Holm-Bonferroni corrected threshold\"\n\t\tp_holm = nan\n\t\t\n\treturn h,corrected_p,p_holm","def test_rf_value(self):\n\t\tdetails = self.watcher.describe()\t\t\n\t\tself.assertTrue((details.rf.to_numpy()[0:8] == 9.0).all())","def test_pk1x(self):\n self.assertFloatEqual(pkolmogorov1x(0.06, 30), 0.2248113)","def test_probabilities_are_ok(self, seed):\n bins = defaultdict(int)\n probs = (0.1, 0.2, 0.3, 0.4)\n categories = (\"asdfa\", \"2\", \"3\", \"4\")\n categories = OrderedDict(zip(categories, probs))\n dim = Categorical(\"yolo\", categories)\n for _ in range(500):\n sample = dim.sample(seed=seed)[0]\n bins[sample] += 1\n for keys in bins.keys():\n bins[keys] /= float(500)\n for key, value in categories.items():\n assert abs(bins[key] - value) < 0.01","def test_solve_toruscases_bce():\n import numpy as np\n from crpm.setup_toruscases import setup_toruscases\n from crpm.fwdprop import fwdprop\n from crpm.lossfunctions import loss\n from crpm.gradientdecent import gradientdecent\n from crpm.analyzebinaryclassifier import analyzebinaryclassifier\n\n #init numpy seed\n np.random.seed(40017)\n\n #setup model\n model, data = setup_toruscases()\n nx = data.shape[0]\n nsample = data.shape[1]\n\n #partition training and validation data\n valid = data[1:data.shape[0],0:nsample//3]\n validtargets = data[0,0:nsample//3]\n train = data[1:data.shape[0],nsample//3:nsample]\n targets =data[0,nsample//3:nsample]\n\n #calculate initial binary cross entropy error\n pred, _ = fwdprop(train, model)\n icost, _ = loss(\"bce\", pred, targets)\n\n #analyze binary classifier\n pred, _ = fwdprop(valid, model)\n roc, ireport = analyzebinaryclassifier(pred, validtargets)\n if ireport[\"AreaUnderCurve\"]<.5:\n pred = 1-pred\n icost, _ = loss(\"bce\", pred, validtargets)\n roc, ireport = analyzebinaryclassifier(pred, validtargets)\n print(ireport)\n #plotroc(roc)\n\n #train model\n pred, cost, _ = gradientdecent(model, train, targets, \"bce\", valid, validtargets, earlystop=True)\n\n #analyze binary classifier\n pred, _ = fwdprop(valid, model)\n roc, report = analyzebinaryclassifier(pred, validtargets)\n if report[\"AreaUnderCurve\"]<.5:\n pred = 1-pred\n cost, _ = loss(\"bce\", pred, validtargets)\n roc, report = analyzebinaryclassifier(pred, validtargets)\n print(report)\n #plotroc(roc)\n\n\n #print(model)\n print(icost)\n print(cost)\n assert icost > cost\n assert cost < .4\n assert report[\"MatthewsCorrCoef\"] > .1\n #don't expect problem can be solved with linear model\n #assert report[\"AreaUnderCurve\"] > ireport[\"AreaUnderCurve\"]"],"string":"[\n \"def test_bonferroni_correction(self):\\r\\n pvals = array([.1, .7, .5, .3, .9])\\r\\n exp = pvals * 5.\\r\\n obs = bonferroni_correction(pvals)\\r\\n self.assertFloatEqual(obs, exp)\",\n \"def bonferroni_correction(pvals):\\r\\n return (\\r\\n array(pvals, dtype=float) * len(pvals) # float conversion: Nones->nans\\r\\n )\",\n \"def test_correct_p_values(self):\\r\\n exp = [0.003, 0.006, 0.003]\\r\\n obs = self.mc._correct_p_values([0.001, 0.002, 0.001])\\r\\n assert_almost_equal(obs, exp)\",\n \"def correct_pvalues_for_multiple_testing(pvalues, correction_type = \\\"Benjamini-Hochberg\\\"):\\n pvalues = array(pvalues)\\n n = int(pvalues.shape[0])\\n new_pvalues = empty(n)\\n if correction_type == \\\"Bonferroni\\\":\\n new_pvalues = n * pvalues\\n elif correction_type == \\\"Bonferroni-Holm\\\":\\n values = [ (pvalue, i) for i, pvalue in enumerate(pvalues) ]\\n values.sort()\\n for rank, vals in enumerate(values):\\n pvalue, i = vals\\n new_pvalues[i] = (n-rank) * pvalue\\n elif correction_type == \\\"Benjamini-Hochberg\\\":\\n values = [ (pvalue, i) for i, pvalue in enumerate(pvalues) ]\\n values.sort()\\n values.reverse()\\n new_values = []\\n for i, vals in enumerate(values):\\n rank = n - i\\n pvalue, index = vals\\n new_values.append((n/rank) * pvalue)\\n for i in range(0, int(n)-1):\\n if new_values[i] < new_values[i+1]:\\n new_values[i+1] = new_values[i]\\n for i, vals in enumerate(values):\\n pvalue, index = vals\\n new_pvalues[index] = new_values[i]\\n return new_pvalues\",\n \"def correct_pvalues_for_multiple_testing(pvalues, correction_type=\\\"Benjamini-Hochberg\\\"):\\r\\n from numpy import array, empty\\r\\n pvalues = array(pvalues)\\r\\n n = float(pvalues.shape[0])\\r\\n new_pvalues = empty(n)\\r\\n if correction_type == \\\"Bonferroni\\\":\\r\\n new_pvalues = n * pvalues\\r\\n elif correction_type == \\\"Bonferroni-Holm\\\":\\r\\n values = [(pvalue, i) for i, pvalue in enumerate(pvalues)]\\r\\n values.sort()\\r\\n for rank, vals in enumerate(values):\\r\\n pvalue, i = vals\\r\\n new_pvalues[i] = (n - rank) * pvalue\\r\\n elif correction_type == \\\"Benjamini-Hochberg\\\":\\r\\n values = [(pvalue, i) for i, pvalue in enumerate(pvalues)]\\r\\n values.sort()\\r\\n values.reverse()\\r\\n new_values = []\\r\\n for i, vals in enumerate(values):\\r\\n rank = n - i\\r\\n pvalue, index = vals\\r\\n new_values.append((n / rank) * pvalue)\\r\\n for i in range(0, int(n) - 1):\\r\\n if new_values[i] < new_values[i + 1]:\\r\\n new_values[i + 1] = new_values[i]\\r\\n for i, vals in enumerate(values):\\r\\n pvalue, index = vals\\r\\n new_pvalues[index] = new_values[i]\\r\\n return new_pvalues\",\n \"def bonferroni_dunn(p_values, control):\\n\\n # Initial Checking\\n if type(p_values) == pd.DataFrame:\\n algorithms = p_values.columns\\n p_values = p_values.values\\n elif type(p_values) == np.ndarray:\\n algorithms = np.array([\\\"Alg%d\\\" % alg for alg in range(p_values.shape[1])])\\n\\n if type(control) == str:\\n control = int(np.where(algorithms == control)[0])\\n if control is None:\\n raise ValueError(\\\"Initialization ERROR. Incorrect value for control.\\\")\\n\\n k = p_values.shape[1]\\n\\n # sort p-values p(0) <= p(1) <= ... <= p(k-1)\\n argsorted_pvals = np.argsort(p_values[0, :])\\n\\n APVs = np.zeros((k - 1, 1))\\n comparison = []\\n for i in range(k - 1):\\n comparison.append(algorithms[control] + \\\" vs \\\" + algorithms[argsorted_pvals[i]])\\n APVs[i, 0] = np.min([(k - 1) * p_values[0, argsorted_pvals[i]], 1])\\n return pd.DataFrame(data=APVs, index=comparison, columns=[\\\"Bonferroni\\\"])\",\n \"def test_fdr_correction(self):\\r\\n pvals = array([.1, .7, .5, .3, .9])\\r\\n exp = array([.5, .7 * 5 / 4., .5 * 5 / 3., .3 * 5 / 2., .9])\\r\\n obs = fdr_correction(pvals)\\r\\n self.assertFloatEqual(obs, exp)\",\n \"def test_bisection_system(testFunctions,tol, printFlag):\\n pass\",\n \"def test_rr_bciimbensmanski(results):\\n trueci = np.asarray([3.29158006, 6.46606603])\\n ci1 = results.effect_ci_imbensmanski()\\n ci2 = results.effect_ci(citype=\\\"Imbens-Manski\\\")\\n assert ci1 == pytest.approx(trueci)\\n assert ci2 == pytest.approx(trueci)\",\n \"def test_correct_p_values_no_change(self):\\r\\n exp = [None, 0.008]\\r\\n obs = self.mc._correct_p_values([None, 0.008])\\r\\n self.assertEqual(obs, exp)\\r\\n exp = [0.007]\\r\\n obs = self.mc._correct_p_values([0.007])\\r\\n assert_almost_equal(obs, exp)\",\n \"def multiple_testing_correction(pvalues, correction_type=\\\"FDR\\\"):\\n from numpy import array, empty\\n pvalues = array(pvalues)\\n sample_size = pvalues.shape[0]\\n qvalues = empty(sample_size)\\n if correction_type == \\\"Bonferroni\\\":\\n # Bonferroni correction\\n qvalues = sample_size * pvalues\\n elif correction_type == \\\"Bonferroni-Holm\\\":\\n # Bonferroni-Holm correction\\n values = [(pvalue, i) for i, pvalue in enumerate(pvalues)]\\n values.sort()\\n for rank, vals in enumerate(values):\\n pvalue, i = vals\\n qvalues[i] = (sample_size-rank) * pvalue\\n elif correction_type == \\\"FDR\\\":\\n # Benjamini-Hochberg, AKA - FDR test\\n values = [(pvalue, i) for i, pvalue in enumerate(pvalues)]\\n values.sort()\\n values.reverse()\\n new_values = []\\n for i, vals in enumerate(values):\\n rank = sample_size - i\\n pvalue, index = vals\\n new_values.append((sample_size/rank) * pvalue)\\n for i in range(0, int(sample_size)-1):\\n if new_values[i] < new_values[i+1]:\\n new_values[i+1] = new_values[i]\\n for i, vals in enumerate(values):\\n pvalue, index = vals\\n qvalues[index] = new_values[i]\\n return qvalues\",\n \"def _correct_p(self, f0, f1):\\n return self.p * np.exp(self.dbeta * (f0 + f1) / 2)\",\n \"def testPerron(self):\\n self.assertTrue(irreducible.perron(self.f1))\\n self.assertEqual(None, irreducible.perron(self.f2), \\\"non-monic\\\")\",\n \"def ExpectedVal():\\n input = f.LoadFile('\\\\\\\\rosalind_ebin.txt').splitlines()\\n n = int(input[0])\\n P = [float(x) for x in input[1].split()]\\n \\n B = [str(round(i*n,4)) for i in P]\\n f.ExportToFile('rosalind_ebin_output.txt',' '.join(B))\\n return\",\n \"def P(phi, phib, df):\\n\\tprint 'P'\\n\\tif f(0,phi,phib,df)*f(1,phi,phib,df) < 0:\\n\\t\\tprint 'brent'\\n\\t\\t#return opt.brentq(f, 0, 1, args=(phi,df)) # Brent's method\\n\\t\\t#return opt.brenth(f, 0, 1, args=(phi,df)) # Brent's method\\n\\t\\treturn opt.bisect(f, 0, 1, args=(phi,phib,df)) # Bisection method\\n\\t\\t#x,r = opt.bisect(f, 0, 1, args=(phi,df), full_output=True) # Bisection method\\n\\t\\t#print r.iterations\\n\\t\\t#return x\\n\\telse:\\n\\t\\tprint 'newton'\\n\\t\\treturn opt.newton(f, 0.5, args=(phi,phib,df)) # Newton-Raphson\\n\\t#print 'newtonpre'\\n #return opt.newton(f, 1.0, args=(phi,phib,df)) # Newton-Raphson\\n\\t#print 'newtonpost'\",\n \"def test_cape_cin_value_error():\\n pressure = np.array([1012.0, 1009.0, 1002.0, 1000.0, 925.0, 896.0, 855.0, 850.0, 849.0,\\n 830.0, 775.0, 769.0, 758.0, 747.0, 741.0, 731.0, 712.0, 700.0, 691.0,\\n 671.0, 636.0, 620.0, 610.0, 601.0, 594.0, 587.0, 583.0, 580.0, 571.0,\\n 569.0, 554.0, 530.0, 514.0, 506.0, 502.0, 500.0, 492.0, 484.0, 475.0,\\n 456.0, 449.0, 442.0, 433.0, 427.0, 400.0, 395.0, 390.0, 351.0, 300.0,\\n 298.0, 294.0, 274.0, 250.0]) * units.hPa\\n temperature = np.array([27.8, 25.8, 24.2, 24, 18.8, 16, 13, 12.6, 12.6, 11.6, 9.2, 8.6,\\n 8.4, 9.2, 10, 9.4, 7.4, 6.2, 5.2, 3.2, -0.3, -2.3, -3.3, -4.5,\\n -5.5, -6.1, -6.1, -6.1, -6.3, -6.3, -7.7, -9.5, -9.9, -10.3,\\n -10.9, -11.1, -11.9, -12.7, -13.7, -16.1, -16.9, -17.9, -19.1,\\n -19.9, -23.9, -24.7, -25.3, -29.5, -39.3, -39.7, -40.5, -44.3,\\n -49.3]) * units.degC\\n dewpoint = np.array([19.8, 16.8, 16.2, 16, 13.8, 12.8, 10.1, 9.7, 9.7,\\n 8.6, 4.2, 3.9, 0.4, -5.8, -32, -34.6, -35.6, -34.8,\\n -32.8, -10.8, -9.3, -10.3, -9.3, -10.5, -10.5, -10, -16.1,\\n -19.1, -23.3, -18.3, -17.7, -20.5, -27.9, -32.3, -33.9, -34.1,\\n -35.9, -26.7, -37.7, -43.1, -33.9, -40.9, -46.1, -34.9, -33.9,\\n -33.7, -33.3, -42.5, -50.3, -49.7, -49.5, -58.3, -61.3]) * units.degC\\n cape, cin = surface_based_cape_cin(pressure, temperature, dewpoint)\\n expected_cape, expected_cin = 2098.688061 * units('joules/kg'), 0.0 * units('joules/kg')\\n assert_almost_equal(cape, expected_cape, 3)\\n assert_almost_equal(cin, expected_cin, 3)\",\n \"def test_crofton_method(self):\\n\\n chi_sq = lambda pred, obs: np.sum((obs - pred)**2 / pred)\\n\\n para_crof = np.arange(0, 9)\\n\\n crof = PIHM()\\n\\n # Data from Crofton 1971\\n st1_obs = np.array([161, 111, 67, 65, 50, 30, 33, 13, 8])\\n st2_obs = np.array([189, 129, 86, 51, 27, 14, 8, 1, 2])\\n st3_obs = np.array([458, 81, 40, 22, 19, 4, 6, 3, 0])\\n st4_obs = np.array([164, 147, 92, 43, 25, 11, 3, 0, 1])\\n st5_obs = np.array([140, 77, 30, 14, 10, 3, 2, 0, 0])\\n st6_obs = np.array([153, 29, 6, 2, 1, 0, 0, 0, 0])\\n\\n # Raw data\\n st1_raw = np.repeat(para_crof, st1_obs)\\n st2_raw = np.repeat(para_crof, st2_obs)\\n st3_raw = np.repeat(para_crof, st3_obs)\\n st4_raw = np.repeat(para_crof, st4_obs)\\n st5_raw = np.repeat(para_crof, st5_obs)\\n st6_raw = np.repeat(para_crof, st6_obs)\\n\\n # Crofton predicted with truncations!\\n st1_pred = {\\n 3: np.array([162.2, 103.9, 77.4, 60.4, 48.2, 38.9, 31.7, 26.0, 21.4]),\\n 4: np.array([162.4, 103.4, 77.6, 61.2, 49.4, 40.5, 33.5, 27.9, 23.3]),\\n 5: np.array([161.2, 107.0, 78.0, 58.7, 44.7, 34.4, 26.6, 20.7, 16.1]),\\n 6: np.array([162.1, 104.6, 77.3, 59.5, 46.7, 37.1, 29.7, 23.9, 19.3]),\\n 7: np.array([160.2, 108.8, 79.2, 58.9, 44.3, 33.6, 25.5, 19.5, 14.9]),\\n 8: np.array([158.4, 111.7, 80.8, 59.0, 43.2, 31.7, 23.3, 17.2, 12.7])}\\n\\n st2_pred = {\\n 3: np.array([188.6, 130.7, 83.6 , 52.0, 31.9, 19.4, 11.7, 7.0, 4.2]),\\n 4: np.array([187.9, 133.0, 83.0, 49.4, 28.7, 16.5, 9.3, 5.3, 2.9,]),\\n 5: np.array([187.3, 134.5, 83.0, 48.4, 27.4, 15.3, 8.4, 4.6, 2.5]),\\n 6: np.array([187.2, 134.8, 83.1, 48.3, 27.3, 15.1, 8.3, 4.5, 2.4]),\\n 7: np.array([185.3, 138.1, 84.2, 47.5, 25.7, 13.6, 7.0, 3.6, 1.8]),\\n 8: np.array([185.5, 137.9, 84.1, 47.5, 25.8, 13.7, 7.1, 3.7, 1.9])}\\n\\n st3_pred = {\\n 3: np.array([457.9, 81.8, 39.0, 22.5, 14.1, 9.2, 6.3, 4.3, 3.0]),\\n 4: np.array([458.1, 79.5, 40.3, 25.0, 16.9, 12.0, 8.8, 6.5, 5.0]),\\n 5: np.array([457.5, 83.7, 39.0, 21.9, 13.3, 8.5, 5.5, 3.7, 2.5]),\\n 6: np.array([457.0, 83.4, 39.1, 22.0, 13.5, 8.6, 5.7, 3.8, 2.2]),\\n 7: np.array([457.4, 84.1, 39.1, 21.8, 13.2, 8.3, 5.4, 3.6, 2.4])}\\n\\n # Station 1 comparison\\n\\n trunc = np.arange(3, 9)\\n\\n crof_st1_ks = [0.754, 0.736, 0.834, 0.776, 0.874, 0.951]\\n crof_st1_N = [677, 708, 606, 646, 594, 573]\\n our_st1_N = []\\n our_st1_ks = []\\n crof_st1_compare_ss = []\\n\\n crof.data = st1_raw\\n\\n for i in trunc:\\n\\n bin_edges = list(np.arange(0, i + 1)) + [i + 0.9]\\n N, mu, k = crof.crofton_method(bin_edges)\\n our_st1_ks.append(k)\\n our_st1_N.append(N)\\n\\n assert_array_almost_equal(crof_st1_ks, our_st1_ks, decimal=1)\\n\\n # This will fail, but it is close\\n # Uncomment and run nosetests to see results\\n\\n # assert_array_equal(crof_st1_N, our_st1_N)\\n\\n # Station 2 comparison\\n\\n crof_st2_ks = [1.182, 1.313, 1.392, 1.407, 1.574, 1.563]\\n crof_st2_N = [535, 520, 514, 513, 508, 509]\\n our_st2_N = []\\n our_st2_ks = []\\n crof_st2_compare_ss = []\\n\\n crof.data = st2_raw\\n\\n for i in trunc:\\n\\n bin_edges = list(np.arange(0, i + 1)) + [i + 0.9]\\n N, mu, k = crof.crofton_method(bin_edges)\\n our_st2_ks.append(k)\\n our_st2_N.append(N)\\n\\n assert_array_almost_equal(crof_st2_ks, our_st2_ks, decimal=1)\\n\\n assert_array_equal(np.round(crof_st2_N, -1), np.round(our_st2_N, -1))\\n\\n # Station 3 comparison\\n\\n trunc = np.arange(3, 8)\\n\\n crof_st3_ks = [.229, .206, .244, .242, .247]\\n crof_st3_N = [646, 670, 642, 643, 641]\\n our_st3_N = []\\n our_st3_ks = []\\n crof_st3_compare_ss = []\\n\\n crof.data = st3_raw\\n\\n for i in trunc:\\n\\n bin_edges = list(np.arange(0, i + 1)) + [i + 0.9]\\n N, mu, k = crof.crofton_method(bin_edges)\\n our_st3_ks.append(k)\\n our_st3_N.append(N)\\n\\n assert_array_almost_equal(crof_st3_ks, our_st3_ks, decimal=1)\\n\\n # Close to equal but not quite. Which is ok. We don't expect them\\n # to be exactly equal\\n # Uncomment and run nosetests to see\\n\\n # assert_array_equal(crof_st3_N, our_st3_N)\",\n \"def P(phi, phib, df):\\n\\tif f(0,phi,phib,df)*f(1,phi,phib,df) < 0:\\n\\t\\treturn opt.bisect(f, 0, 1, args=(phi,phib,df), maxiter=500) # Bisection method\\n\\telse:\\n\\t\\treturn opt.newton(f, 1.0, args=(phi,phib,df), maxiter=5000) # Newton-Raphson\",\n \"def test_robbins_confidence(self):\\n c = array([1,2,3,0,1])\\n r = robbins_confidence(c, 0.05)\\n n = 7\\n s = 2\\n k = sqrt(8/0.05)\\n self.assertEqual(r, ((s-k)/(n+1), (s+k)/(n+1)))\",\n \"def test_correct_p_values_large_correction(self):\\r\\n exp = [1, None, 0.03, 0.03]\\r\\n obs = self.mc._correct_p_values([0.5, None, 0.01, 0.01])\\r\\n self.compare_multiple_level_array(obs, exp)\",\n \"def test_newton_rhapson_system(testFunctions, tol, printFlag): \\n pass\",\n \"def getCorrectedPValues(pval_raw,alpha=0.05,method='fdr_i'):\\n rej, pval_corr = smm.multipletests(pval_raw, alpha=alpha, method=method)[:2]\\n return pval_corr\",\n \"def test_brauer_2_dim_2_pval():\\n expected_res = np.array(\\n [\\n [1, 1, 1],\\n [0, 0, 0],\\n [0, 0, 0],\\n [1, 0, 0],\\n [0, 0, 0],\\n [0, 1, 0],\\n [0, 0, 1],\\n [0, 0, 0],\\n [0, 0, 0],\\n [0, 0, 1],\\n [0, 1, 0],\\n [0, 0, 0],\\n [1, 0, 0],\\n [0, 0, 0],\\n [0, 0, 0],\\n [1, 1, 1],\\n ]\\n )\\n\\n res = brauer(2, 2)\\n\\n bool_mat = np.isclose(res, expected_res)\\n np.testing.assert_equal(np.all(bool_mat), True)\",\n \"def fdr_correction(pvals):\\r\\n tmp = array(pvals).astype(float) # this converts Nones to nans\\r\\n return tmp * tmp.size / (1. + argsort(argsort(tmp)).astype(float))\",\n \"def test_error_at_99tpr(self):\\r\\n\\r\\n return self.test_error_at_confidence(self.confidence_at_tpr(0.99))\",\n \"def _pvalues_all(self):\\n return 2.0 * (1.0 - scs.t.cdf(np.abs(self._tstat_all), self._df_err))\",\n \"def lambda_test(p_values, df=1):\\n from scipy.stats import chi2\\n assert np.max(p_values) <= 1 and np.min(p_values) >= 0, 'These do not appear to be p-values'\\n\\n chi_sq_scores = chi2.ppf(1 - p_values, df)\\n return np.median(chi_sq_scores) / chi2.ppf(0.5, df)\",\n \"def test_newton_rhapson(testFunctions, tol, printFlag): \\n pass\",\n \"def test_correct_p_values_mixed(self):\\r\\n exp = [None, 0.008, 0.01, None]\\r\\n obs = self.mc._correct_p_values([None, 0.004, 0.005, None])\\r\\n self.assertEqual(obs, exp)\",\n \"def p_value_inflation_test(p_values):\\n from scipy.stats import ks_2samp\\n h_null = np.random.uniform(0, 1, size=int(1e6))\\n d, p_value = ks_2samp(p_values, h_null)\\n return p_value, d\",\n \"def test_chao1_bias_corrected(self):\\n obs = chao1_bias_corrected(*osd(self.TestData))\\n self.assertEqual(obs, 9.75)\",\n \"def bCheck(c, v, p, b):\\n val = (v+1).floor()\\n deg = c.degree()\\n coeffs = c.coefficients(sparse=False)\\n lcoeff = coeffs[deg]; coeffs.remove(lcoeff)\\n check1 = [(coeffs[i].valuation(p) - lcoeff.valuation(p))/(deg - i) for i in range(0,len(coeffs)) if coeffs[i] != 0]\\n check2 = (val - lcoeff.valuation(p))/deg\\n check1.append(check2)\\n bval = min(check1)\\n return (bval).ceil()\",\n \"def test_bayes_updates_good_data(self):\\r\\n # result for first -> fourth calculated by hand\\r\\n for obs, exp in zip(bayes_updates(self.test), self.result):\\r\\n self.assertFloatEqualAbs(obs, exp, 1e-11)\",\n \"def test_fixed_point_system(testFunctions, tol, printFlag): \\n pass\",\n \"def test_fixed_point(testFunctions, tol, printFlag): \\n pass\",\n \"def test_rr_pz(results):\\n truepz = np.asarray([4.43677606e-09, 7.89531535e-01, 7.89747372e-01,\\n 8.04473756e-08, 2.22044605e-15])\\n test_pz = results.params_pvalue()\\n assert test_pz == pytest.approx(truepz)\",\n \"def _calc_pval(self):\\n t = self.beta / self.stderr_beta\\n return (2. * (1. - stats.t.cdf(np.abs(t), self.n - 2)))[0]\",\n \"def test_error_at_995tpr(self):\\r\\n\\r\\n return self.test_error_at_confidence(self.confidence_at_tpr(0.995))\",\n \"def bisection(f,a,b,tol=1e-4,Max_trial=14):\\n pvalues = np.zeros(Max_trial+3)\\n fvalues = np.zeros(Max_trial+3)\\n fa,fb = f(a),f(b)\\n pvalues[0],pvalues[1]=a,b\\n fvalues[0],fvalues[1]=fa,fb\\n\\n if fa*fb>0:\\n print('f(a)*f(b)>0 ---> specified a and b do not work!')\\n print('spiting out a or b --- whichever is closer')\\n \\n if np.abs(fa)<=fb:\\n return a,f(a)\\n else:\\n return b,f(b)\\n \\n \\n p=(a+b)/2\\n pvalues[2]=p\\n fp=f(p)\\n fvalues[2]=fp\\n err=np.abs(fp)\\n\\n j=0\\n while err > tol and j<Max_trial:\\n\\n if fa*fp<0:\\n b=p\\n p=(a+b)/2\\n fp = f(p)\\n else:\\n a=p\\n fa = fp\\n p=(a+b)/2\\n fp = f(p)\\n\\n err=abs(fp)\\n print('-------------------------------------------------------')\\n print('bisection trial #'+str(j)+': sol='+str(p)+', mismatch ='+str(err))\\n print('-------------------------------------------------------')\\n j=j+1\\n pvalues[j+2]=p\\n fvalues[j+2]=fp\\n # print('p='+str(p))\\n # print('a,b='+str(a)+'--'+str(b))\\n\\n pvalues,fvalues=pvalues[:j+3],fvalues[:j+3]\\n\\n return pvalues,fvalues\",\n \"def test_prob_expectation_values(self, approx_order, strategy, tol):\\r\\n dev = qml.device(\\\"default.qubit\\\", wires=2)\\r\\n x = 0.543\\r\\n y = -0.654\\r\\n\\r\\n with qml.tape.JacobianTape() as tape:\\r\\n qml.RX(x, wires=[0])\\r\\n qml.RY(y, wires=[1])\\r\\n qml.CNOT(wires=[0, 1])\\r\\n qml.expval(qml.PauliZ(0))\\r\\n qml.probs(wires=[0, 1])\\r\\n\\r\\n tapes, fn = finite_diff(tape, approx_order=approx_order, strategy=strategy)\\r\\n res = fn(dev.batch_execute(tapes))\\r\\n assert res.shape == (5, 2)\\r\\n\\r\\n expected = (\\r\\n np.array(\\r\\n [\\r\\n [-2 * np.sin(x), 0],\\r\\n [\\r\\n -(np.cos(y / 2) ** 2 * np.sin(x)),\\r\\n -(np.cos(x / 2) ** 2 * np.sin(y)),\\r\\n ],\\r\\n [\\r\\n -(np.sin(x) * np.sin(y / 2) ** 2),\\r\\n (np.cos(x / 2) ** 2 * np.sin(y)),\\r\\n ],\\r\\n [\\r\\n (np.sin(x) * np.sin(y / 2) ** 2),\\r\\n (np.sin(x / 2) ** 2 * np.sin(y)),\\r\\n ],\\r\\n [\\r\\n (np.cos(y / 2) ** 2 * np.sin(x)),\\r\\n -(np.sin(x / 2) ** 2 * np.sin(y)),\\r\\n ],\\r\\n ]\\r\\n )\\r\\n / 2\\r\\n )\\r\\n\\r\\n assert np.allclose(res, expected, atol=tol, rtol=0)\",\n \"def test_rr_bciupper(results):\\n trueci = np.asarray([3.56102163, np.inf])\\n ci1 = results.effect_ci_upper()\\n ci2 = results.effect_ci(citype=\\\"upper\\\")\\n assert ci1 == pytest.approx(trueci)\\n assert ci2 == pytest.approx(trueci)\",\n \"def pbias(self) -> float:\\n return float(100.0 * sum(self.predicted - self.true) / sum(self.true))\",\n \"def test_correctness(self):\\n M_win = 1024\\n N_fft = 131072\\n # Set norm=False for correctness as the values obtained from the\\n # scientific publication do not normalize the values. Normalizing\\n # changes the sidelobe level from the desired value.\\n w = windows.taylor(M_win, nbar=4, sll=35, norm=False, sym=False)\\n f = fft(w, N_fft)\\n spec = 20 * np.log10(np.abs(f / np.amax(f)))\\n\\n first_zero = np.argmax(np.diff(spec) > 0)\\n\\n PSLL = np.amax(spec[first_zero:-first_zero])\\n\\n BW_3dB = 2*np.argmax(spec <= -3.0102999566398121) / N_fft * M_win\\n BW_18dB = 2*np.argmax(spec <= -18.061799739838872) / N_fft * M_win\\n\\n assert_allclose(PSLL, -35.1672, atol=1)\\n assert_allclose(BW_3dB, 1.1822, atol=0.1)\\n assert_allclose(BW_18dB, 2.6112, atol=0.1)\",\n \"def _p_value(self):\\n p_value = chi2.sf(self.test_statistic, 2)\\n\\n return p_value\",\n \"def test_bart(self):\\n valid, _ = testing_utils.eval_model(\\n dict(task='integration_tests', model='bart', num_examples=10)\\n )\\n self.assertAlmostEqual(valid['ppl'].value(), 1.0, places=1)\",\n \"def compute_pvalue(self):\\n # Run permutation test\\n self.PermutationTest()\\n # TS obtained from the original B,T samples\\n self.compute_obs_TS()\\n \\n # Mean and std of the TS distribution\\n self.mu = np.mean(self.TS_tilde)\\n self.sigma = np.std(self.TS_tilde)\\n \\n # Standardized test statistic (zero mean, unit variance)\\n self.TS_prime = (self.TS_tilde - self.mu)/self.sigma\\n self.TS_prime_obs = (self.TS_obs - self.mu)/self.sigma\\n \\n # Two-sided p-value from TS' distribution\\n self.p_value = 2*(1 - 0.01 * stats.percentileofscore(self.TS_prime,\\n abs(self.TS_prime_obs)) )\\n \\n # if 0, compute it from standard normal\\n if self.p_value == 0.0:\\n self.p_value = self.pvalue_gaussian()\\n \\n print(\\\"\\\")\\n print(\\\"p-value = {:e}\\\".format(self.p_value))\",\n \"def benjamini_hochberg_step_down(pvals):\\r\\n tmp = fdr_correction(pvals)\\r\\n corrected_vals = empty(len(pvals))\\r\\n max_pval = 1.\\r\\n for i in argsort(pvals)[::-1]:\\r\\n if tmp[i] < max_pval:\\r\\n corrected_vals[i] = tmp[i]\\r\\n max_pval = tmp[i]\\r\\n else:\\r\\n corrected_vals[i] = max_pval\\r\\n return corrected_vals\",\n \"def getpval(teststat, statlist):\\n \\n propzero = 0\\n bootvals = []\\n for val in statlist:\\n if val == 0:\\n propzero += 1\\n else:\\n bootvals.append(val)\\n \\n propzero = float(propzero) / len(statlist)\\n \\n shapeinit = getstartingshape(statlist)\\n \\n shape = optimiselike(getlikeweibull, bootvals, shapeinit)\\n scale = (sum(bootvals) / len(bootvals)) / scipy.special.gamma(1 + 1/shape)\\n \\n pvalue = math.exp(- (teststat/scale) ** shape)\\n \\n return pvalue * (1 - propzero)\",\n \"def benjamin_hochberg_correction(p_values, alpha=0.05):\\n m = len(p_values)\\n p_values = sorted(p_values)\\n for k, p in enumerate(p_values):\\n if p > (k + 1) / m * alpha:\\n index = k - 1\\n if index < 0:\\n return 0\\n return p_values[index]\",\n \"def calculate_f_p(genes, gene_abundance_file, gene_molecular_weight_file):\\n gene_abundance = pd.read_csv(gene_abundance_file, index_col=0)\\n gene_molecular_weight = json_load(gene_molecular_weight_file)\\n enzy_abundance = 0\\n pro_abundance = 0\\n for gene_i in gene_abundance.index:\\n if gene_i in gene_molecular_weight.keys():\\n abundance = gene_abundance.loc[gene_i, 'abundance'] * \\\\\\n gene_molecular_weight[gene_i]/1000\\n pro_abundance += abundance\\n if gene_i in genes.index:\\n enzy_abundance += abundance\\n f = enzy_abundance/pro_abundance\\n return f\",\n \"def test_pkstwo(self):\\n self.assertFloatEqual(pkstwo(2.3),[1-5.084e-05],eps=1e-5)\",\n \"def f_test(chi1,df1,chi2,df2,red_chi = True):\\n\\n# if chi1/df1 > chi2/df2:\\n#\\tprob = 2. * f.cdf(chi1/df1, chi2/df2, df1, df2)\\n# else:\\n#\\tprob = 2. * f.cdf(chi2/df2, chi1/df1, df2, df1)\\n if red_chi:\\n\\tfval = (chi1/df1) / (chi2/df2)\\n else:\\n\\tfval = chi1 / chi2\\n prob = 2. * f.cdf((chi1/df1) / (chi2/df2), df1, df2)\\n if prob > 1.: \\n\\treturn 2. - prob\\n else:\\n\\treturn prob\",\n \"def logit_pvalue(model, x, verbose=False):\\n probs = model.predict_proba(x)\\n n_datapoints = probs.shape[0]\\n n_feautures = len(model.coef_[0]) + 1\\n coeffs = np.hstack([model.intercept_.reshape(-1, 1), model.coef_])\\n x_full = np.matrix(np.insert(np.array(x), 0, 1, axis=1))\\n pvals = []\\n errors = []\\n for coeffs_vec, p_vec in zip(coeffs, probs.T):\\n ans = np.zeros((n_feautures, n_feautures))\\n for i in range(n_datapoints):\\n ans += np.dot(x_full[i].T, x_full[i]) * p_vec[i] * (1 - p_vec[i])\\n try:\\n vcov = np.linalg.inv(np.matrix(ans))\\n serrors = np.sqrt(np.diag(vcov))\\n t = coeffs_vec / serrors\\n pn = (1 - norm.cdf(abs(t))) * 2\\n except np.linalg.linalg.LinAlgError as e:\\n if verbose:\\n print(\\\"det : {0}\\\".format(np.linalg.det(np.matrix(ans))))\\n serrors = np.zeros(ans.shape[0])\\n pn = np.zeros(ans.shape[0])\\n pvals.append(pn)\\n errors.append(serrors)\\n pvals = np.array(pvals)\\n errors = np.array(errors)\\n return pvals.T, coeffs.T, errors.T\",\n \"def _correct_p_values(self, p_vals):\\r\\n num_tests = len([p_val for p_val in p_vals if p_val is not None])\\r\\n corrected_p_vals = []\\r\\n for p_val in p_vals:\\r\\n if p_val is not None:\\r\\n corrected_p_vals.append(min(p_val * num_tests, 1))\\r\\n else:\\r\\n corrected_p_vals.append(p_val)\\r\\n return corrected_p_vals\",\n \"def lfprob (dfnum, dfden, F):\\r\\n p = betai(0.5*dfden, 0.5*dfnum, dfden/float(dfden+dfnum*F))\\r\\n return p\",\n \"def check_fpp_ratio(self,\\n ion_params,\\n wavelength,\\n fpp_ratio_min = 0.3,\\n fpp_ratio_max = 1.05):\\n identity = str(ion_params)\\n inaccuracies = self.inaccuracies.get(identity, None)\\n if (inaccuracies is None):\\n inaccuracies = self.inaccuracies[identity] = set()\\n if (ion_params.element.upper() in [\\\"MG\\\", \\\"NA\\\"]):\\n if (self.fpp is not None) or (self.peak_anom is not None and self.peak_anom > 1):\\n inaccuracies.add(self.BAD_FPP)\\n else :\\n # XXX in theory the fpp_ratio should be no more than 1.0 unless we are\\n # right on the peak wavelength. in practice Phaser can overshoot a little\\n # bit, so we need to be more tolerant. picking the maximum f'' from the\\n # Sasaki and Henke tables will also limit the ratio.\\n if (wavelength is not None) and (self.anomalous_flag):\\n fpp_expected_sasaki = sasaki.table(ion_params.element).at_angstrom(\\n wavelength).fdp()\\n fpp_expected_henke = henke.table(ion_params.element).at_angstrom(\\n wavelength).fdp()\\n self.fpp_expected[identity] = max(fpp_expected_sasaki,\\n fpp_expected_henke)\\n if (self.fpp is not None) and (self.fpp_expected[identity] != 0):\\n self.fpp_ratios[identity] = self.fpp / self.fpp_expected[identity]\\n if ((self.fpp_ratios[identity] > fpp_ratio_max) or\\n ((self.fpp >= 0.2) and\\n (self.fpp_ratios[identity] < fpp_ratio_min))):\\n inaccuracies.add(self.BAD_FPP)\\n elif (self.fpp_expected[identity] > 0.75) and (self.peak_anom < 2):\\n inaccuracies.add(self.BAD_FPP)\\n return self.fpp_ratios.get(identity)\",\n \"def ppf(self,x):\\n ppfValue = self._distribution.inverseCdf(x,random())\\n return ppfValue\",\n \"def ppf(self,x):\\n ppfValue = self._distribution.inverseCdf(x,random())\\n return ppfValue\",\n \"def test_error_at_98tpr(self):\\r\\n\\r\\n return self.test_error_at_confidence(self.confidence_at_tpr(0.98))\",\n \"def test_p_or_p(self):\\r\\n\\r\\n result = self.formulaGen.mainResultOne()\\r\\n self.assertEqual(result, [' P ∨ P → P valid sat 1.0', ' P ∧ P ↔ P valid sat 1.0', ' P ∧ P → P valid sat 1.0', ' P ∨ P ↔ P valid sat 1.0', '(P ∨ P) ↔ P valid sat', '(P ∨ P ↔ P) valid sat', 'P ∨ (P ↔ P) valid sat'])\",\n \"def expected_value_of_outcome(n, p):\\r\\n expected = n * p\\r\\n print(\\\"expected value / mean = \\\", expected)\\r\\n return expected\",\n \"def test_jacobian(self):\\n\\n gT1 = Pose2(1, 2, np.pi/2)\\n gT2 = Pose2(-1, 4, np.pi)\\n\\n expected = Pose2(2, 2, np.pi/2)\\n\\n def error_func(this: CustomFactor, v: gtsam.Values, H: List[np.ndarray]):\\n # print(f\\\"{this = },\\\\n{v = },\\\\n{len(H) = }\\\")\\n\\n key0 = this.keys()[0]\\n key1 = this.keys()[1]\\n gT1, gT2 = v.atPose2(key0), v.atPose2(key1)\\n error = Pose2(0, 0, 0).localCoordinates(gT1.between(gT2))\\n \\n if len(H) > 0:\\n result = gT1.between(gT2)\\n H[0] = -result.inverse().AdjointMap()\\n H[1] = np.eye(3)\\n return error\\n \\n noise_model = gtsam.noiseModel.Unit.Create(3)\\n cf = ge.CustomFactor(noise_model, gtsam.KeyVector([0, 1]), error_func)\\n v = Values()\\n v.insert(0, gT1)\\n v.insert(1, gT2)\\n \\n bf = gtsam.BetweenFactorPose2(0, 1, Pose2(0, 0, 0), noise_model)\\n\\n gf = cf.linearize(v)\\n gf_b = bf.linearize(v)\\n\\n J_cf, b_cf = gf.jacobian()\\n J_bf, b_bf = gf_b.jacobian()\\n np.testing.assert_allclose(J_cf, J_bf)\\n np.testing.assert_allclose(b_cf, b_bf)\",\n \"def test_PhredValueTest(self):\\n phredscore=0\\n realscore=[6.197200000000001 ,0.08488999999999997]\\n for line in self.phredlines:\\n phredscore=phredvalues_version8(line)\\n self.assertEqual(phredscore, realscore)\\n #since the function is used in errorproducer, the absurdly high value of 6.197 is needed to match self.fastQ's phred score\",\n \"def test_bs(self):\\r\\n res = BlackScholes(100, 0.10, 0.5, 1.00)\\r\\n self.assertEqual(round(res, 2), 23.93)\",\n \"def test_Sobol_G_raises_error_if_values_gt_one():\\n evaluate(np.array([0, 1, .02, 0.23, 1.234, 0.02848848, 0, 0.78]))\",\n \"def clopper_pearson_err(k, n, CL=[0.025, 0.975]):\\n # Special case must be treated separately\\n if k == 0:\\n lower = 0\\n upper = 1 - (1-CL[1])**(1/n)\\n\\n # Special case must be treated separately\\n elif k == n:\\n lower = CL[0]**(1/n)\\n upper = 1\\n\\n # Normal case\\n else:\\n lower = stats.beta.ppf(q=CL[0], a=k, b=n-k+1)\\n upper = stats.beta.ppf(q=CL[1], a=k+1, b=n-k)\\n\\n return np.array([lower, upper])\",\n \"def prf(stats):\\n if stats['pred'] == 0:\\n return 0, 0, 0\\n p = stats['corr']/stats['pred']\\n r = stats['corr']/stats['gold']\\n if p > 0 and r > 0:\\n f = 2*p*r/(p+r)\\n else:\\n f = 0\\n return p, r, f\",\n \"def test_correct_p_values_empty(self):\\r\\n exp = []\\r\\n obs = self.mc._correct_p_values([])\\r\\n assert_almost_equal(obs, exp)\",\n \"def ErrorCorrect(val,fEC):\\n return val * fEC\",\n \"def test_bisection_1b(self):\\n logging.info(\\\"\\\\nANSWERS TO EXERCISE 1.1B\\\")\\n left = 0.5\\n right = 3.1\\n\\n # The final interval should contain the desired root.\\n root, (left, right) = undertest.bisection(self.func, left, right, self.maxit)\\n self.assertTrue(_root_in_interval(self.desired_root, left, right))\",\n \"def Pvar(magnitude, error):\\n\\n #magnitude = data[0]\\n #error = data[1]\\n\\n# print(magnitude)\\n \\n# print(error)\\n \\n mean_mag = np.mean(magnitude)\\n nepochs = float(len(magnitude))\\n\\n chi = np.sum((magnitude - mean_mag)**2. / error**2.)\\n p_chi = chi2.cdf(chi, (nepochs-1))\\n\\n return p_chi\",\n \"def infer_pvalues(self, p=0.05, mcp='fdr'):\\n # ---------------------------------------------------------------------\\n # check that pac and surrogates has already been computed\\n assert hasattr(self, 'erpac'), (\\\"You should compute ERPAC first. Use \\\"\\n \\\"the `fit` method\\\")\\n assert mcp in ['fdr', 'bonferroni']\\n\\n # correct the p-values for multiple comparisons (Voytek's only)\\n if \\\"Voytek\\\" in self.method:\\n logger.info(f\\\" Correct p-values for multiple-comparisons using \\\"\\n f\\\"{mcp} correction of MNE-Python\\\")\\n from mne.stats import fdr_correction, bonferroni_correction\\n fcn = fdr_correction if mcp is 'fdr' else bonferroni_correction\\n _, self._pvalues = fcn(self._pvalues, alpha=p)\\n else:\\n assert hasattr(self, 'surrogates'), \\\"No surrogates computed\\\"\\n # compute the p-values using maxstat (gcPAC)\\n self._pvalues = self._infer_pvalues(self.erpac, self.surrogates,\\n p=p)\\n\\n return self._pvalues\",\n \"def test_correct_pl_gates(self, basis_state, wires, target_wires):\\n\\n with patch(\\\"pennylane.PauliX\\\") as mock:\\n BasisStatePreparation(basis_state, wires)\\n\\n called_wires = [args[0] for args, kwargs in mock.call_args_list]\\n\\n assert len(target_wires) == len(called_wires)\\n assert np.array_equal(called_wires, target_wires)\",\n \"def p_value(beta_hat_j, sigma_hat_j):\\n if beta_hat_j > 0:\\n return 2 - (1 * norm.cdf(beta_hat_j / sigma_hat_j))\\n else:\\n return 2 * norm.cdf(beta_hat_j / sigma_hat_j)\",\n \"def test_b_coefficients(x1,x2,x3,y1,y2,y3,CCoefficients,DCoefficients,expected_slope):\\n\\tB = b_coefficients(x1,x2,x3,y1,y2,y3,CCoefficients,DCoefficients)\\n\\tresult = abs(B[0]-expected_slope)< 0.001\\n\\treturn(result)\\n\\tassert B[0]==expected_slope, \\\"First b coefficient (%f) does not equal initial slope (%f).\\\" (B[0],expected_slope)\",\n \"def validate_probabilities(pmf, ops):\\n one = ops.one\\n zero = ops.zero\\n\\n # Make sure the values are in the correct range.\\n # Recall ops.zero = +inf for bases less than 1.\\n # ops.zero = -inf for bases greater than 1.\\n\\n # First find the values which are possibly bad.\\n too_low = pmf < min(zero, one)\\n too_high = pmf > max(zero, one)\\n if too_low.any() or too_high.any():\\n # But 1.000000000000001 is not really bad. So let's keep only the\\n # values that are significantly too low or too high.\\n too_low[too_low] = np.logical_not(np.isclose(pmf[too_low], zero))\\n too_high[too_high] = np.logical_not(np.isclose(pmf[too_high], one))\\n if too_low.any() or too_high.any():\\n bad = pmf[np.logical_or(too_low, too_high)]\\n raise InvalidProbability(bad, ops=ops)\\n\\n return True\",\n \"def test_error_at_95tpr(self):\\r\\n\\r\\n return self.test_error_at_confidence(self.confidence_at_tpr(0.95))\",\n \"def ppf(self,x):\\n ppfValue = self.invCDF(x)\\n return ppfValue\",\n \"def test_bayes_updates_permuted(self):\\r\\n for obs, exp in zip(bayes_updates(self.permuted), self.result):\\r\\n self.assertFloatEqualAbs(obs, exp, 1e-11)\",\n \"def correct_fwe_montecarlo(self, result, n_iters=10000, n_cores=1):\\n n_cores = _check_ncores(n_cores)\\n\\n log_p_map, t_map, _ = permuted_ols(\\n self.parameters_[\\\"tested_vars\\\"],\\n self.inputs_[\\\"beta_maps\\\"],\\n confounding_vars=self.parameters_[\\\"confounding_vars\\\"],\\n model_intercept=False, # modeled by tested_vars\\n n_perm=n_iters,\\n two_sided_test=self.two_sided,\\n random_state=42,\\n n_jobs=n_cores,\\n verbose=0,\\n )\\n\\n # Fill complete maps\\n p_map = np.power(10.0, -log_p_map)\\n\\n # Convert p to z, preserving signs\\n sign = np.sign(t_map)\\n sign[sign == 0] = 1\\n z_map = p_to_z(p_map, tail=\\\"two\\\") * sign\\n maps = {\\n \\\"logp_level-voxel\\\": _boolean_unmask(\\n log_p_map.squeeze(), self.inputs_[\\\"aggressive_mask\\\"]\\n ),\\n \\\"z_level-voxel\\\": _boolean_unmask(z_map.squeeze(), self.inputs_[\\\"aggressive_mask\\\"]),\\n }\\n\\n description = (\\n \\\"Family-wise error rate correction was performed using Nilearn's \\\"\\n \\\"\\\\\\\\citep{10.3389/fninf.2014.00014} permuted OLS method, in which null distributions \\\"\\n \\\"of test statistics were estimated using the \\\"\\n \\\"max-value permutation method detailed in \\\\\\\\cite{freedman1983nonstochastic}. \\\"\\n f\\\"{n_iters} iterations were performed to generate the null distribution.\\\"\\n )\\n\\n return maps, {}, description\",\n \"def get_initial_params(self, x, y, yerr):\\n# p0 = zeros(self.max_phonons + 1)\\n p0 = zeros(2)\\n p0[0] = 100\\n p0[1] = .1\\n return p0\",\n \"def test_joint_fitter(self):\\n p1 = [14.9, 0.3]\\n p2 = [13, 0.4]\\n A = 9.8\\n p = np.r_[A, p1, p2]\\n\\n def model(A, p, x):\\n return A * np.exp(-0.5 / p[1] ** 2 * (x - p[0]) ** 2)\\n\\n def errfunc(p, x1, y1, x2, y2):\\n return np.ravel(\\n np.r_[model(p[0], p[1:3], x1) - y1, model(p[0], p[3:], x2) - y2]\\n )\\n\\n coeff, _ = optimize.leastsq(\\n errfunc, p, args=(self.x, self.ny1, self.x, self.ny2)\\n )\\n assert_allclose(coeff, self.jf.fitparams, rtol=10 ** (-2))\",\n \"def test_pi_func(self):\\n result = calculator.pi_func(2)\\n self.assertEqual(result, 6.28)\",\n \"def bisection(f, fu, point_a, point_b, point_c, point_d, lower_bound, upper_bound, length):\\n n = 1\\n theta = 0\\n a = lower_bound\\n b = upper_bound\\n while n <= 100:\\n theta = (a + b) / 2.0\\n if -1e-6 < f(fu(point_a, point_b, point_c, theta), point_d) - length < 1e-6:\\n # print 'Residual', f(fu(point_a, point_b, point_c, theta), point_d) - length\\n # print 'iteration', n\\n return theta\\n else:\\n n = n + 1\\n if f(fu(point_a, point_b, point_c, theta), point_d) - length > 0:\\n b = theta\\n else:\\n a = theta\\n\\n print 'failedtheta', theta, 'Residual', f(fu(point_a, point_b, point_c, theta), point_d) - length\\n print 'iteration', n\\n return False\",\n \"def test_reference_value(self):\\n\\n self.helmholtz_spin_flipper.windings = 124\\n self.helmholtz_spin_flipper.radius = 14.9 * 1e-2 # [m]\\n self.helmholtz_spin_flipper.current = 1\\n\\n position = (0, 0, 0)\\n\\n reference_value = 0.29539497010675775 # [T]\\n\\n # Evaluate\\n b_field_value = self.helmholtz_spin_flipper.b_field(position)[0]\\n\\n # Assert numerical value\\n self.assertEqual(reference_value, b_field_value)\",\n \"def test_correlation_test_pearson(self):\\r\\n # These results were verified with R.\\r\\n\\r\\n # Test with non-default confidence level and permutations.\\r\\n obs = correlation_test(self.data1, self.data2, method='pearson',\\r\\n confidence_level=0.90, permutations=990)\\r\\n self.assertFloatEqual(obs[:2], (-0.03760147, 0.91786297277172868))\\r\\n self.assertEqual(len(obs[2]), 990)\\r\\n for r in obs[2]:\\r\\n self.assertTrue(r >= -1.0 and r <= 1.0)\\r\\n self.assertCorrectPValue(0.9, 0.93, correlation_test,\\r\\n (self.data1, self.data2),\\r\\n {'method': 'pearson', 'confidence_level': 0.90,\\r\\n 'permutations': 990}, p_val_idx=3)\\r\\n self.assertFloatEqual(obs[4], (-0.5779077, 0.5256224))\\r\\n\\r\\n # Test with non-default tail type.\\r\\n obs = correlation_test(self.data1, self.data2, method='pearson',\\r\\n confidence_level=0.90, permutations=990,\\r\\n tails='low')\\r\\n self.assertFloatEqual(obs[:2], (-0.03760147, 0.45893148638586434))\\r\\n self.assertEqual(len(obs[2]), 990)\\r\\n for r in obs[2]:\\r\\n self.assertTrue(r >= -1.0 and r <= 1.0)\\r\\n self.assertCorrectPValue(0.41, 0.46, correlation_test,\\r\\n (self.data1, self.data2),\\r\\n {'method': 'pearson', 'confidence_level': 0.90,\\r\\n 'permutations': 990, 'tails': 'low'}, p_val_idx=3)\\r\\n self.assertFloatEqual(obs[4], (-0.5779077, 0.5256224))\",\n \"def pvalue_test(self, alpha=0.01):\\n CL = int((1-alpha)*100) # confidence level\\n \\n if self.p_value < alpha:\\n print(\\\"Null hypothesis rejected at {:d}%CL => distributions are different\\\".format(CL))\\n else:\\n print(\\\"Null hypothesis NOT rejected => distributions are the same\\\")\",\n \"def test_call(self):\\r\\n exp = {'method_name': 'BEST',\\r\\n 'rho_vals': [\\r\\n (0.75, '8'),\\r\\n (0.5, '1,11'),\\r\\n (0.5107142857142857, '1,8,11'),\\r\\n (0.47857142857142854, '1,6,8,11'),\\r\\n (0.46071428571428574, '1,5,6,8,9'),\\r\\n (0.4357142857142857, '1,5,6,8,9,11'),\\r\\n (0.38928571428571423, '1,2,4,5,6,7,8'),\\r\\n (0.38928571428571423, '1,2,4,5,6,7,8,9'),\\r\\n (0.38928571428571423, '1,2,4,5,6,7,8,9,10'),\\r\\n (0.38928571428571423, '1,2,4,5,6,7,8,9,10,11'),\\r\\n (0.16785714285714282, '1,2,3,4,5,6,7,8,9,10,11')],\\r\\n 'num_vars': 11,\\r\\n 'vars': ['TOT_ORG_CARB = 1', 'SILT_CLAY = 2',\\r\\n 'ELEVATION = 3', 'SOIL_MOISTURE_DEFICIT = 4',\\r\\n 'CARB_NITRO_RATIO = 5', 'ANNUAL_SEASON_TEMP = 6',\\r\\n 'ANNUAL_SEASON_PRECPT = 7', 'PH = 8',\\r\\n 'CMIN_RATE = 9', 'LONGITUDE = 10',\\r\\n 'LATITUDE = 11']}\\r\\n\\r\\n # the difference caused by the new spearmans_rho function is in the\\r\\n # final decimal place of the rho_vals. its not a significant difference,\\r\\n # but the test is failing because we are doing a dict comparison for\\r\\n # float values.\\r\\n obs = self.best()\\r\\n self.assertEqual(exp['method_name'], obs['method_name'])\\r\\n self.assertEqual(exp['num_vars'], obs['num_vars'])\\r\\n self.assertEqual(exp['vars'], obs['vars'])\\r\\n for i, j in zip(exp['rho_vals'], obs['rho_vals']):\\r\\n assert_almost_equal(i[0], j[0])\\r\\n self.assertEqual(i[1], j[1])\\r\\n # check that the keys are the same since we have checked all the values\\r\\n # we expect to be there are the same\\r\\n self.assertTrue(set(exp.keys()) == set(obs.keys()))\",\n \"def test_converges_to_accurate_values(fake_args):\\n with tempfile.TemporaryDirectory() as tmp_dir:\\n fake_args.return_value = FakeArguments('orvara/tests/diagnostic_config.ini', tmp_dir)\\n tt = run()[1].data\\n # check params\\n i = -1 # walker index.\\n burn = 250 # number of burn in steps to discard\\n rv_jitter = np.mean(tt['jitter'][i, burn:])\\n rv_jitter_err = np.std(tt['jitter'][i, burn:])\\n companion_jup_mass = np.mean(tt['msec0'][i, burn:]*1989/1.898)\\n companion_mass_stderr = np.std(tt['msec0'][i, burn:]*1989/1.898)\\n separation_AU = np.mean(tt['sau0'][i, burn:])\\n separation_stderr = np.std(tt['sau0'][i, burn:])\\n eccentricity = np.mean(tt['esino0'][i, burn:]**2 + tt['ecoso0'][i, burn:]**2)\\n eccentricity_stderr = np.std(tt['esino0'][i, burn:]**2 + tt['ecoso0'][i, burn:]**2)\\n inclination_deg = np.mean(tt['inc0'][i, burn:]*180/np.pi)\\n inclination_err = np.std(tt['inc0'][i, burn:]*180/np.pi)\\n\\n expected_1_sigma_errors = [0.6282, 2.9215, 0.44668, 0.0030392, 2.3431]\\n expected_values = [4.9378, 67.04218, 10.189, 0.73568, 49.89184]\\n values = [rv_jitter, companion_jup_mass, separation_AU, eccentricity, inclination_deg]\\n errors = [rv_jitter_err, companion_mass_stderr, separation_stderr,\\n eccentricity_stderr, inclination_err]\\n for value, expected, sigma in zip(values, expected_values, expected_1_sigma_errors):\\n assert np.isclose(value, expected, atol=3 * sigma)\\n assert np.allclose(errors, expected_1_sigma_errors, rtol=.5)\",\n \"def test_rr_ci(results):\\n trueci = np.asarray([[8.19806824, -51.8197922, -183.75877191, 3.25948071,\\n 3.91491988],\\n [16.42312995, 68.15921213, 241.62975025, 7.01060682,\\n 6.48808526]])\\n test_ci = results.params_ci()\\n assert test_ci == pytest.approx(trueci)\",\n \"def atmoBowman(f): \\n freq = np.array([\\n 0.01, 0.0155, 0.0239, 0.0367, 0.0567,\\n 0.0874, 0.1345, 0.2075, 0.32, 0.5,\\n 0.76, 1.17, 1.8, 2.79, 4.3,\\n 6.64, 10, 100,\\n ])\\n pressure_asd = sqrt([\\n 22.8, 4, 0.7, 0.14, 0.027, 0.004,\\n 0.0029, 0.0039, 7e-4, 1.44e-4, 0.37e-4,\\n 0.12e-4, 0.56e-5, 0.35e-5, 0.26e-5, 0.24e-5,\\n 2e-6, 2e-6,\\n ])\\n return 10**(np.interp(log10(f), log10(freq), log10(pressure_asd)))\",\n \"def test_pressure_increasing_check_some_constants(mocker, pressure_values, expected):\\n profile = mocker.patch.object(argortqcpy.profile, \\\"Profile\\\")\\n profile.get_property_data = mocker.Mock(return_value=ma.masked_array(pressure_values))\\n\\n pic = PressureIncreasingCheck(profile, None)\\n output = pic.run()\\n\\n assert np.all(output.get_output_flags_for_property(\\\"PRES\\\").data == expected)\",\n \"def test_model(parameters):\\n if parameters is None:\\n return \\\"No Value\\\"\\n else:\\n return round(modelo.predict_proba([parameters])[0]*100, 3)\",\n \"def calc_b_wilson(labelcorrs_plugin, numsamps, failure_prob=0.01):\\n err_est = 0.5*(1.0 - labelcorrs_plugin)\\n z = sp.stats.norm.ppf(0.5*(2-failure_prob))\\n zsq_n = z*z/numsamps\\n sleeping_specs = np.isinf(zsq_n)\\n recentered_mean_errors = np.multiply(1.0/(1+zsq_n), (err_est + 0.5*zsq_n))\\n recentered_plugins = 1.0 - 2*recentered_mean_errors\\n stddevs = np.sqrt(np.multiply(zsq_n, np.multiply(\\n err_est, 1.0 - err_est)) + np.square(0.5*zsq_n))\\n stddevs = np.multiply(1.0/(1+zsq_n), stddevs)\\n toret = np.maximum(recentered_plugins - 2*stddevs, 0.0)\\n toret[sleeping_specs] = 0.0\\n return toret\",\n \"def test_dixon_price(self):\\n fun = get_problem('dixon_price', 2, -10, 10)\\n solution = np.array([1.0, 0.70710678])\\n self.assertAlmostEqual(fun(solution), 0.0)\",\n \"def stats_holmBonf(p,plot='false'):\\t\\n\\talpha = 0.05\\n\\tk = len(p)\\n\\tidx = [i[0] for i in sorted(enumerate(p), key=lambda x:x[1])]\\n\\tcorrected_p = alpha/np.arange(k+1,1,-1)\\n\\t\\n\\th = p <= corrected_p\\n\\tif np.sum(h) > 0 :\\n\\t\\tidx_first_zero = np.where(h == 0)[0][0] #get first index where you cannot reject the null-hypothesis\\n\\t\\th[idx_zero:] = 0\\n\\t\\n\\t\\tif plot == 'true': \\n\\t\\t\\tplt.plot(p,'ko-')\\n\\t\\t\\tplt.plot(c,'r-')\\n\\t\\t\\tx=np.arange(len(p))\\n\\t\\t\\tplt.fill_between(x,0,p,where=h,facecolor='red')\\n\\t\\n\\t\\th = h[idx]\\n\\t\\tp_holm = c[idx_first_zero]\\n\\telse:\\n\\t\\tprint \\\"None of the p-value exceed the Holm-Bonferroni corrected threshold\\\"\\n\\t\\tp_holm = nan\\n\\t\\t\\n\\treturn h,corrected_p,p_holm\",\n \"def test_rf_value(self):\\n\\t\\tdetails = self.watcher.describe()\\t\\t\\n\\t\\tself.assertTrue((details.rf.to_numpy()[0:8] == 9.0).all())\",\n \"def test_pk1x(self):\\n self.assertFloatEqual(pkolmogorov1x(0.06, 30), 0.2248113)\",\n \"def test_probabilities_are_ok(self, seed):\\n bins = defaultdict(int)\\n probs = (0.1, 0.2, 0.3, 0.4)\\n categories = (\\\"asdfa\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\")\\n categories = OrderedDict(zip(categories, probs))\\n dim = Categorical(\\\"yolo\\\", categories)\\n for _ in range(500):\\n sample = dim.sample(seed=seed)[0]\\n bins[sample] += 1\\n for keys in bins.keys():\\n bins[keys] /= float(500)\\n for key, value in categories.items():\\n assert abs(bins[key] - value) < 0.01\",\n \"def test_solve_toruscases_bce():\\n import numpy as np\\n from crpm.setup_toruscases import setup_toruscases\\n from crpm.fwdprop import fwdprop\\n from crpm.lossfunctions import loss\\n from crpm.gradientdecent import gradientdecent\\n from crpm.analyzebinaryclassifier import analyzebinaryclassifier\\n\\n #init numpy seed\\n np.random.seed(40017)\\n\\n #setup model\\n model, data = setup_toruscases()\\n nx = data.shape[0]\\n nsample = data.shape[1]\\n\\n #partition training and validation data\\n valid = data[1:data.shape[0],0:nsample//3]\\n validtargets = data[0,0:nsample//3]\\n train = data[1:data.shape[0],nsample//3:nsample]\\n targets =data[0,nsample//3:nsample]\\n\\n #calculate initial binary cross entropy error\\n pred, _ = fwdprop(train, model)\\n icost, _ = loss(\\\"bce\\\", pred, targets)\\n\\n #analyze binary classifier\\n pred, _ = fwdprop(valid, model)\\n roc, ireport = analyzebinaryclassifier(pred, validtargets)\\n if ireport[\\\"AreaUnderCurve\\\"]<.5:\\n pred = 1-pred\\n icost, _ = loss(\\\"bce\\\", pred, validtargets)\\n roc, ireport = analyzebinaryclassifier(pred, validtargets)\\n print(ireport)\\n #plotroc(roc)\\n\\n #train model\\n pred, cost, _ = gradientdecent(model, train, targets, \\\"bce\\\", valid, validtargets, earlystop=True)\\n\\n #analyze binary classifier\\n pred, _ = fwdprop(valid, model)\\n roc, report = analyzebinaryclassifier(pred, validtargets)\\n if report[\\\"AreaUnderCurve\\\"]<.5:\\n pred = 1-pred\\n cost, _ = loss(\\\"bce\\\", pred, validtargets)\\n roc, report = analyzebinaryclassifier(pred, validtargets)\\n print(report)\\n #plotroc(roc)\\n\\n\\n #print(model)\\n print(icost)\\n print(cost)\\n assert icost > cost\\n assert cost < .4\\n assert report[\\\"MatthewsCorrCoef\\\"] > .1\\n #don't expect problem can be solved with linear model\\n #assert report[\\\"AreaUnderCurve\\\"] > ireport[\\\"AreaUnderCurve\\\"]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.83021456","0.71167046","0.6553124","0.6406347","0.6259637","0.6220493","0.60953826","0.602094","0.5866166","0.5811663","0.58097947","0.5803982","0.5756479","0.5751217","0.57412875","0.5739286","0.5718708","0.5704229","0.5698823","0.56808656","0.5674409","0.5650607","0.56499326","0.5644787","0.56430995","0.5637371","0.5626845","0.5622571","0.5618137","0.5606045","0.5602787","0.55907506","0.55790985","0.5578654","0.55732995","0.55648357","0.5519931","0.5515665","0.549714","0.5473801","0.544833","0.54306823","0.54306227","0.5420887","0.53979635","0.53864384","0.5377417","0.5359836","0.53571725","0.5350865","0.5332018","0.5322111","0.5314327","0.5310988","0.53105104","0.5304724","0.5291307","0.5291307","0.528727","0.5286607","0.52841914","0.52776605","0.52762926","0.5275014","0.5273717","0.5266914","0.52667487","0.52602905","0.52587026","0.5257356","0.524835","0.5248179","0.5247664","0.52366614","0.5233605","0.52293116","0.5227018","0.52184016","0.5217304","0.5206701","0.51918626","0.518853","0.5187866","0.517336","0.51633525","0.516228","0.5155629","0.51508325","0.5145672","0.51439005","0.51418114","0.5139877","0.5137654","0.513753","0.51348156","0.51325774","0.5119432","0.51186657","0.51165295","0.5113878"],"string":"[\n \"0.83021456\",\n \"0.71167046\",\n \"0.6553124\",\n \"0.6406347\",\n \"0.6259637\",\n \"0.6220493\",\n \"0.60953826\",\n \"0.602094\",\n \"0.5866166\",\n \"0.5811663\",\n \"0.58097947\",\n \"0.5803982\",\n \"0.5756479\",\n \"0.5751217\",\n \"0.57412875\",\n \"0.5739286\",\n \"0.5718708\",\n \"0.5704229\",\n \"0.5698823\",\n \"0.56808656\",\n \"0.5674409\",\n \"0.5650607\",\n \"0.56499326\",\n \"0.5644787\",\n \"0.56430995\",\n \"0.5637371\",\n \"0.5626845\",\n \"0.5622571\",\n \"0.5618137\",\n \"0.5606045\",\n \"0.5602787\",\n \"0.55907506\",\n \"0.55790985\",\n \"0.5578654\",\n \"0.55732995\",\n \"0.55648357\",\n \"0.5519931\",\n \"0.5515665\",\n \"0.549714\",\n \"0.5473801\",\n \"0.544833\",\n \"0.54306823\",\n \"0.54306227\",\n \"0.5420887\",\n \"0.53979635\",\n \"0.53864384\",\n \"0.5377417\",\n \"0.5359836\",\n \"0.53571725\",\n \"0.5350865\",\n \"0.5332018\",\n \"0.5322111\",\n \"0.5314327\",\n \"0.5310988\",\n \"0.53105104\",\n \"0.5304724\",\n \"0.5291307\",\n \"0.5291307\",\n \"0.528727\",\n \"0.5286607\",\n \"0.52841914\",\n \"0.52776605\",\n \"0.52762926\",\n \"0.5275014\",\n \"0.5273717\",\n \"0.5266914\",\n \"0.52667487\",\n \"0.52602905\",\n \"0.52587026\",\n \"0.5257356\",\n \"0.524835\",\n \"0.5248179\",\n \"0.5247664\",\n \"0.52366614\",\n \"0.5233605\",\n \"0.52293116\",\n \"0.5227018\",\n \"0.52184016\",\n \"0.5217304\",\n \"0.5206701\",\n \"0.51918626\",\n \"0.518853\",\n \"0.5187866\",\n \"0.517336\",\n \"0.51633525\",\n \"0.516228\",\n \"0.5155629\",\n \"0.51508325\",\n \"0.5145672\",\n \"0.51439005\",\n \"0.51418114\",\n \"0.5139877\",\n \"0.5137654\",\n \"0.513753\",\n \"0.51348156\",\n \"0.51325774\",\n \"0.5119432\",\n \"0.51186657\",\n \"0.51165295\",\n \"0.5113878\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.80394477"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":83167,"cells":{"query":{"kind":"string","value":"Convert ID sequences into mask matrices"},"document":{"kind":"string","value":"def idseqs_to_mask(idseqs: List[List[int]],\n n_seqlen: Optional[int] = None,\n n_vocab_sz: Optional[int] = None,\n ignore: Optional[List[int]] = [],\n dtype: Optional[torch.dtype] = torch.bool,\n dense: Optional[bool] = False\n ) -> torch.sparse.FloatTensor:\n if n_seqlen is None:\n n_seqlen = max([len(seq) for seq in idseqs])\n\n # create a list of IDs\n if n_vocab_sz is None:\n ids = set(itertools.chain(*idseqs))\n else:\n ids = set(range(0, n_vocab_sz))\n\n # remove IDs that we ignore\n ids = ids.difference(set(ignore))\n n_features = len(ids)\n\n # convert to list to lookup with .index() method\n ids = list(ids)\n\n # loop over each ID sequence\n masks = []\n for seq in idseqs:\n # extract index pairs of the sparse matrix\n featidx = []\n seqidx = []\n for step, elem in enumerate(seq[:n_seqlen]):\n try:\n featidx.append(ids.index(elem))\n seqidx.append(step)\n except Exception:\n pass\n # convert to COO matrix\n tmp = torch.sparse.FloatTensor(\n indices=torch.LongTensor([seqidx, featidx]),\n values=torch.FloatTensor([1.0 for _ in range(len(seqidx))]),\n size=torch.Size([n_seqlen, n_features])\n ).coalesce()\n # save it\n masks.append(tmp)\n\n # stack into one 3D tensor <batch_sz, n_seqlen, vocab_sz>\n masks = torch.stack(masks).coalesce()\n\n # convert to dense matrix if requested\n if dense:\n masks = masks.to_dense().type(dtype)\n\n # done\n return masks"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def build_attention_mask(input_ids): \n attention_masks = [] \n\n # 1 for input and 0 for pad\n for seq in input_ids: \n attention_masks.append([float(i>0) for i in seq])\n\n return attention_masks","def mask_id(self):\n m = 2 * self.mask_full()\n m[0:self.size, 0:self.size] = self.id * self.mask()\n return m.astype(np.int16)","def _prepare_mask_file(mask):\n result = np.ndarray((mask.shape[0], mask.shape[1]), dtype=np.uint8)\n for i in range(mask.shape[0]):\n for j in range(mask.shape[1]):\n\n if mask[i][j] > 0:\n result[i][j] = 1\n else:\n result[i][j] = 0\n \n return result","def load_mask(self, image_id):\n # Override this function to load a mask from your dataset.\n # Otherwise, it returns an empty mask.\n mask = np.empty([0, 0, 0])\n class_ids = np.empty([0], np.int32)\n return mask, class_ids","def load_mask(self, window_id):\n streams = self.load_streams(window_id)\n info=self.window_info[window_id]\n shape=info[\"shape\"]\n\n mask = np.zeros([shape[0], shape[1], 1], dtype=np.uint8)\n\n for stream_id,stream in enumerate(streams):\n\n for trace in stream:\n if trace.stats.channel==\"U\":\n start=int(round(trace.stats.sac[\"a\"]*100))\n end=int(round(trace.stats.sac[\"t0\"]*100))\n else:\n continue\n\n mask[stream_id,start:end+1,0]= 1\n\n class_ids = np.ones([1])\n\n if self.shuffle:\n random.seed(window_id)\n random_index=random.sample(range(shape[0]),shape[0])\n mask[:,:,0]=mask[:,:,0][random_index]\n\n streams=[streams[i] for i in random_index]\n\n\n\n station=np.zeros([shape[0],shape[0],2])\n for i,j in itertools.product(range(shape[0]),range(shape[0])):\n station[i,j]=[streams[j][0].stats.sac[\"stla\"]/streams[i][0].stats.sac[\"stla\"],streams[j][0].stats.sac[\"stlo\"]/streams[i][0].stats.sac[\"stlo\"]]\n\n\n return mask.astype(np.bool), class_ids.astype(np.int32),station.astype(np.float32)","def label_to_mask(labels):\n # get the image size\n h, w = labels.shape\n\n # build a color to label map\n idx_to_color = {}\n for label in class_info:\n idx_to_color[class_info[label].id] = class_info[label].color\n\n # generate label matrix\n mask = np.zeros((h, w, 3), dtype=np.uint8)\n for y in range(h):\n for x in range(w):\n id = labels[y, x]\n r, g, b = idx_to_color[id]\n mask[y, x] = np.array([b, g, r])\n\n return mask","def load_mask(self, image_id):\n # Override this function to load a mask from your dataset.\n # Otherwise, it returns an empty mask.\n logging.warning(\"You are using the default load_mask(), maybe you need to define your own one.\")\n mask = np.empty([0, 0, 0])\n class_ids = np.empty([0], np.int32)\n return mask, class_ids","def create_mask_list(self, seg_img, K):\n all_ids = np.unique(seg_img)\n chosen_ids = np.random.choice(all_ids, K)\n\n return [(seg_img == ID).astype(np.float32) for ID in chosen_ids]","def get_ids(self, tensor=False):\n array = self.array\n id_mask = np.zeros(array.shape, dtype=np.uint8)\n for c, val in enumerate(self.class_values):\n id_mask[array == val] = c\n \n if tensor:\n id_mask = torch.from_numpy(id_mask) # takes numpy dtype, not float\n\n return id_mask","def load_mask(self, image_id):\n info = self.image_info[image_id]\n image_name = str(info['id']).zfill(6) + \"_10.png\"\n gt_image = imageio.imread(\"./training/instance/\" + image_name)\n instance_gt = np.array(gt_image) % 256\n semantic_gt = np.array(gt_image) // 256\n instance_gt = cv2.resize(instance_gt, (self.width, self.height), interpolation=cv2.INTER_NEAREST)\n semantic_gt = cv2.resize(semantic_gt, (self.width, self.height), interpolation=cv2.INTER_NEAREST)\n labels = [26, 24]\n masks = []\n class_ids = []\n for l in labels:\n mask_sem = (semantic_gt == [l]).astype(np.int_) * 255\n mask_ins = instance_gt & mask_sem\n num_ins = np.max(mask_ins)\n if(num_ins > 30):\n print(\"WARNING: num ins %d for label l %d\" % (num_ins, l))\n\n for i in range(1, num_ins + 1):\n mask_obj = (mask_ins == [i]).astype(np.int_) * 255\n masks.append(mask_obj)\n if l == 24:\n class_ids.append(2)\n else:\n class_ids.append(1)\n masks = np.array(masks)\n masks = np.moveaxis(masks, 0, -1)\n class_ids = np.array(class_ids)\n return masks, class_ids","def transform_targets_to_boolean(dataset, img_id, img_size):\n ann_ids = dataset.getAnnIds(img_id)\n anns = dataset.loadAnns(ann_ids)\n out_mask = np.zeros(img_size, dtype=bool)\n adder = np.array([0., 1., 0., 1.])\n\n for ann in anns:\n bbox = (np.array(ann['bbox']) + adder).astype(int)\n bbox[3] = bbox[1] + bbox[3]\n bbox[2] = bbox[0] + bbox[2]\n out_mask[bbox[1]:bbox[3], bbox[0]:bbox[2]] = True\n\n return out_mask","def _source_mask(self, ilens):\n x_masks = make_non_pad_mask(ilens)\n return x_masks.unsqueeze(-2)","def generate_mask_aligned(data, length, tp_union):\n mask = np.zeros((data.shape[0], tp_union.shape[0]))\n e_data = torch.zeros((data.shape[0], tp_union.shape[0], data.shape[2]))\n e_data = e_data.to(data.device)\n r_arr = []\n\n for i, l in enumerate(length):\n mask[i, :l] = 1\n e_data[i, :l] = data[i, :l]\n r_arr.append(np.where(mask[i] == 1)[0])\n\n return mask, e_data, r_arr","def test_get_mask(self):\n\n spine_data_loader = SpineDataLoader(dirpath_data=self.dirpath,\n batch_size=4)\n\n for idx in range(4):\n mask = spine_data_loader.get_mask(str(idx))\n assert mask.shape == (256, 256, 1)\n assert mask.dtype == 'int64'","def mod_mask(self):\n # Check the *_masq values\n self.__log.debug(\"Checking the *_masq arrays\")\n # Retrieve the kid boxes\n masq_names = np.unique([\"{}_masq\".format(item[1]) for item in self.list_detector])\n self.__check_attributes(masq_names, read_missing=False)\n # Check that they are all the same\n warnings.warn(\"Temporary fix to int8\")\n masqs = [getattr(self, masq).astype(np.int8) for masq in masq_names]\n\n if np.any(np.std(masqs, axis=0) != 0):\n self.__log.error(\"*_masq is varying -- Please check : {}\".format(pprint_list(masq_names, \"_masq\")))\n\n # AB private comm) main_flag should be the bitwise_or of all boxes\n # Well not exactly....\n # cast into 8 bit, is more than enough, only 3 bits used anyway...\n masq = np.bitwise_or.reduce(masqs, axis=0).astype(np.int8)\n\n # AB (#CONCERTO_DAQ January 11 13:02)\n # _flag_balayage_en_cours & _flag_blanking_synthe\n # Ainsi on aura la modulation en bit0 et 1 et le flag blanking en bit\n # AB (#CONCERTO_DAQ February 11 11:07)\n # bit 1 & 2 code the modulation as a signed integer -1 0 1 : 11 00 01 ie 3 0 1\n # bit 3 is a blanking bit, which does not exist for KISS, but should not be taken into account for CONCERTO\n\n # Thus as a temporary fix, let's clear the 3rd bit, actually a bad idea...\n # self.__log.warning(\"Temporary fix : clearing the 3rd bit of masq\")\n # masq = masq & ~(1 << 2)\n\n return masq","def load_mask(self, image_id):\r\n info = self.image_info[image_id]\r\n mask = tifffile.imread(self.mask_path[self.ids[image_id]])\r\n\r\n if np.unique(mask).__len__() > 1:\r\n count = np.unique(mask).__len__()-1 # one less because of 0\r\n\r\n mask_new = np.zeros([info['height'], info['width'], count], dtype=np.uint8) # one more for background\r\n running = 0\r\n for i in np.unique(mask): #range(1, count):\r\n if ((i > 0) & ((mask == i).sum() > 0)):\r\n mask_new[:, :, running] = (mask == i)\r\n running = running + 1\r\n # Map class names to class IDs.\r\n class_ids = np.ones(count)\r\n else:\r\n mask_new = np.zeros([info['height'], info['width'], 1], dtype=np.uint8)\r\n class_ids = np.zeros([1])\r\n return mask_new, class_ids.astype(np.int32)","def get_labels(self) -> np.array:\n nb_samples = len(self.list_IDs)\n M = np.empty((nb_samples, *self.dim[:-1], 3))\n\n for i, ID in enumerate(self.list_IDs):\n M[i,] = np.load(self.mask_data_path + ID, allow_pickle=True)\n\n return M","def load_mask(self, image_id):\n info = self.image_info[image_id]\n # Get mask directory from image path\n mask_dir = os.path.join(os.path.dirname(os.path.dirname(info['path'])), \"masks\")\n\n # Read mask files from .png image\n mask = []\n # for f in next(os.walk(mask_dir))[2]:\n m = skimage.io.imread(os.path.join(mask_dir, info['id']+'.png')).astype(np.bool)\n mask.append(m)\n # print(mask)\n mask = np.stack(mask, axis=-1)\n # Return mask, and array of class IDs of each instance. Since we have\n # one class ID, we return an array of ones\n return mask, np.ones([mask.shape[-1]], dtype=np.int32)","def load_mask(self, image_id):\n info = self.image_info[image_id]['mask_info']\n mask_, id_ = info\n\n return mask_, id_ #mask.astype(np.bool)","def load_mask(self, image_id):\n image_info = self.image_info[image_id]\n annotations = image_info['annotations']\n instance_masks = []\n class_ids = []\n \n for annotation in annotations:\n class_id = annotation['category_id']\n mask = Image.new('1', (image_info['width'], image_info['height']))\n mask_draw = ImageDraw.ImageDraw(mask, '1')\n for segmentation in annotation['segmentation']:\n mask_draw.polygon(segmentation, fill=1)\n bool_array = np.array(mask) > 0\n instance_masks.append(bool_array)\n class_ids.append(class_id)\n\n mask = np.dstack(instance_masks)\n class_ids = np.array(class_ids, dtype=np.int32)\n \n return mask, class_ids","def load_mask(self, image_id):\n info = self.image_info[image_id]\n mask_paths = glob.glob(info['path'].replace('images', 'masks').replace('.png', '*.png'))\n masks = []\n class_ids = []\n for mask_path in mask_paths:\n# print(mask_path)\n mask = cv2.imread(mask_path,cv2.IMREAD_GRAYSCALE) \n masks.append(mask)\n if 'normal' in mask_path:\n class_ids.append(0)\n if 'benign' in mask_path:\n class_ids.append(1)\n if 'malignant' in mask_path:\n class_ids.append(2)\n masks = np.moveaxis(masks,0,-1)\n class_ids = np.array(class_ids)\n return masks, class_ids","def create_padding_mask(seq):\r\n seq = tf.cast(tf.math.equal(seq, 0), tf.float32)\r\n return seq[:, tf.newaxis, tf.newaxis, :] # (batch_size, 1, 1, seq_len)\r","def _load_mask(self, image_id):\n\n mask_pattern = os.path.join(self.directory, image_id, \"masks/*.png\")\n ic = ImageCollection(mask_pattern)\n\n mask = np.zeros(self.imsize, dtype='uint8')\n for lbl, indiv_mask in enumerate(ic):\n mask += ((\n 1 + lbl) * self._process(indiv_mask, True).astype('uint8'))\n\n return mask","def mask(self):","def seqs_to_toks(self,id_array,remove_pads=True):\n return [self.ids_to_toks(seq,remove_pads)\n for seq in id_array]","def get_sample_mask(self):","def load_mask(self, image_id):\n info = self.image_info[image_id]\n num_cards = info['cards']\n # count = len(num_cards)\n count = 1 # there will only ever be 1 card per image (for simplicity) TODO: do multiple documents?\n mask = np.zeros([info['height'], info['width'], count], dtype=np.uint8)\n # for i, _ in enumerate(info['cards']):\n mask[:, :, 0] = self.draw_quadrilateral(mask[:, :, 0].copy(), info['cornerpoints'], 1)\n\n # Handle occlusions\n occlusion = np.logical_not(mask[:, :, -1]).astype(np.uint8)\n for i in range(count-2, -1, -1):\n mask[:, :, i] = mask[:, :, i] * occlusion\n occlusion = np.logical_and(occlusion, np.logical_not(mask[:, :, i]))\n # Map class names to class IDs.\n # class_ids = np.array([self.class_names.index(s[0]) for s in num_categories])\n\n # Return mask, and array of class IDs of each instance. Since we have\n # one class ID only, we return an array of 1s\n return mask.astype(np.bool), np.ones([mask.shape[-1]], dtype=np.int32)","def maskArr(arrIn, segMap, maskID):\n return np.logical_and(segMap != maskID, segMap != 0)","def mask(self):\n return list(self._mask_generator())","def load_mask(self, image_id):\n info = self.image_info[image_id]\n ships = info['ships']\n count = len(ships)\n mask = np.zeros([info['height'], info['width'], count], dtype=np.uint8)\n for i, (ship, dims) in enumerate(info['ships']):\n mask[:, :, i:i + 1] = self.draw_mask(mask[:, :, i:i + 1].copy(),\n ship, dims)\n # Handle occlusions\n occlusion = np.logical_not(mask[:, :, -1]).astype(np.uint8)\n for i in range(count - 2, -1, -1):\n mask[:, :, i] = mask[:, :, i] * occlusion\n occlusion = np.logical_and(\n occlusion, np.logical_not(mask[:, :, i]))\n # Map class names to class IDs.\n class_ids = np.array([self.class_names.index(s[0]) for s in ships])\n return mask, class_ids.astype(np.int32)","def get_masks(data):\n return [patient[0] for i, patient in enumerate(data) if i in good_patients]","def generate_mask(self):\n\n polymer_length = len(self.sequence)\n protein_length = len(self.particle_order) - polymer_length\n\n if self.filter_specification == 'type':\n mask = np.in1d(self.particle_order, self.monomer_id)\n elif self.filter_specification == 'id':\n if self.molecule == 'polymer':\n offset = protein_length\n else:\n offset = 0\n mask = np.array([False] * (polymer_length + protein_length))\n absolute_id = [x+offset for x in self.monomer_id]\n mask[absolute_id] = True\n else:\n raise NotImplementedError(\"Filter is unknown. Use 'type' or 'id'!\")\n\n # if molecule == 'full', nothing needs to be done\n if self.molecule == 'polymer':\n mask[:protein_length] = [False] * protein_length\n elif self.molecule == 'protein':\n mask[protein_length:] = [False] * polymer_length\n\n return mask","def _compute_masked_targets(self, item_ids: tf.Tensor, training: bool = False) -> MaskingInfo:\n\n labels = tf.cast(tf.fill(item_ids.shape, self.padding_idx), dtype=item_ids.dtype)\n non_padded_mask = tf.cast(item_ids != self.padding_idx, labels.dtype)\n rows_ids = tf.range(labels.shape[0], dtype=tf.int64)\n # During training, masks labels to be predicted according to a probability, ensuring that\n # each session has at least one label to predict\n if training:\n # Selects a percentage of items to be masked (selected as labels)\n probability_matrix = tf.cast(\n backend.random_bernoulli(array_ops.shape(labels), p=self.mlm_probability),\n labels.dtype,\n )\n\n mask_labels = probability_matrix * non_padded_mask\n labels = tf.where(\n tf.cast(mask_labels, tf.bool),\n item_ids,\n tf.cast(tf.fill(item_ids.shape, self.padding_idx), dtype=item_ids.dtype),\n )\n\n # Set at least one item in the sequence to mask, so that the network\n # can learn something with this session\n one_random_index_by_session = tf.random.categorical(\n tf.math.log(tf.cast(non_padded_mask, tf.float32)), num_samples=1\n )\n indices = tf.concat([tf.expand_dims(rows_ids, 1), one_random_index_by_session], axis=1)\n labels = tf.tensor_scatter_nd_update(\n labels, indices=indices, updates=tf.gather_nd(item_ids, indices)\n )\n mask_labels = tf.cast(labels != self.padding_idx, labels.dtype)\n\n # If a sequence has only masked labels, unmask one of the labels\n sequences_with_only_labels = tf.reduce_sum(mask_labels, axis=1) == tf.reduce_sum(\n non_padded_mask, axis=1\n )\n sampled_labels_to_unmask = tf.random.categorical(\n tf.math.log(tf.cast(mask_labels, tf.float32)), num_samples=1\n )\n\n labels_to_unmask = tf.boolean_mask(sampled_labels_to_unmask, sequences_with_only_labels)\n rows_to_unmask = tf.boolean_mask(rows_ids, sequences_with_only_labels)\n indices = tf.concat([tf.expand_dims(rows_to_unmask, 1), labels_to_unmask], axis=1)\n num_updates, _ = indices.shape.as_list()\n labels = tf.tensor_scatter_nd_update(\n labels, indices, tf.cast(tf.fill(num_updates, self.padding_idx), labels.dtype)\n )\n mask_labels = labels != self.padding_idx\n\n else:\n if self.eval_on_last_item_seq_only:\n last_item_sessions = tf.reduce_sum(non_padded_mask, axis=1) - 1\n\n indices = tf.concat(\n [\n tf.expand_dims(rows_ids, 1),\n tf.cast(tf.expand_dims(last_item_sessions, 1), tf.int64),\n ],\n axis=1,\n )\n labels = tf.tensor_scatter_nd_update(\n labels, indices=indices, updates=tf.gather_nd(item_ids, indices)\n )\n mask_labels = labels != self.padding_idx\n else:\n masking_info = self.predict_all(item_ids)\n mask_labels, labels = masking_info.schema, masking_info.targets\n\n return MaskingInfo(mask_labels, labels)","def _make_causal_mask(\n input_ids_shape: torch.Size, dtype: torch.dtype, device: torch.device, past_key_values_length: int = 0\n):\n bsz, tgt_len = input_ids_shape\n mask = torch.full((tgt_len, tgt_len), torch.finfo(dtype).min, device=device)\n mask_cond = torch.arange(mask.size(-1), device=device)\n mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0)\n mask = mask.to(dtype)\n\n if past_key_values_length > 0:\n mask = torch.cat([torch.zeros(tgt_len, past_key_values_length, dtype=dtype, device=device), mask], dim=-1)\n return mask[None, None, :, :].expand(bsz, 1, tgt_len, tgt_len + past_key_values_length)","def prepare_data(seqs, labels, maxlen=None, xdim=3):\n # Trim all output seqs to have only maxlen steps\n if maxlen is not None:\n Iseqs = []\n Oseqs = []\n for i_seq, o_seq in zip(seqs, labels):\n if len(o_seq) < maxlen:\n Iseqs.append(i_seq)\n Oseqs.append(o_seq)\n seqs = Iseqs\n labels = Oseqs\n else:\n maxlen = 40\n\n # Pad and compute masks\n ret_X = np.zeros((maxlen, len(seqs), xdim))\n mask_X = np.zeros((maxlen, len(seqs)))\n labels_X = np.zeros((maxlen, len(seqs)))\n for k in range(len(seqs)):\n mask_X[:len(labels[k]), k] = 1\n ret_X[:len(labels[k]), k] = np.asarray(seqs[k])\n labels_X[:len(labels[k]), k] = labels[k]\n\n return ret_X, mask_X, labels_X","def load_mask(self, image_id):\n\n # If not a balloon dataset image, delegate to parent class.\n image_info = self.image_info[image_id]\n if image_info[\"source\"] != \"dsb\":\n return super(self.__class__, self).load_mask(image_id)\n\n path = image_info[\"dir\"]\n\n mascara = next(os.walk(path + '/masks/'))[2]\n masc = skimage.io.imread(path + '/masks/' + mascara[0])\n height, width = masc.shape\n\n mask = np.zeros((height, width, len(mascara)), dtype=np.uint8)\n\n for i, mask_file in enumerate(mascara):\n mask[:,:,i] = skimage.io.imread(path + '/masks/' + mask_file)\n\n # Return mask, and array of class IDs of each instance. Since we have\n # one class ID only, we return an array of 1s\n return mask, np.ones([mask.shape[-1]], dtype=np.int32)","def generate_mask(data, tps, length, tp_union):\n tp_map = {tp_union[i].item(): i for i in range(len(tp_union))}\n\n mask = np.zeros((data.shape[0], tp_union.shape[0]))\n e_data = torch.zeros((data.shape[0], tp_union.shape[0], data.shape[2]))\n e_data = e_data.to(data.device)\n r_arr = []\n\n for i in range(len(mask)):\n inds = [tp_map[tps[i][j].item()] for j in range(length[i])]\n mask[i, inds] = 1\n e_data[i, inds] = data[i, :length[i]]\n r_arr.append(np.where(mask[i] == 1)[0])\n\n return mask, e_data, r_arr","def Expand_Mask(mask, feature_dict):\n new_mask = np.zeros(mask.shape + (len(feature_dict),))\n for i in feature_dict.keys():\n ni = int(i)\n new_mask[mask == ni,ni] = 1 \n return new_mask","def load_mask(self, image_id):\n global iter_num\n print(\"image_id\",image_id)\n info = self.image_info[image_id]\n count = 1 # number of object\n img = Image.open(info['mask_path'])\n num_obj = self.get_obj_index(img)\n mask = np.zeros([info['height'], info['width'], num_obj], dtype=np.uint8)\n mask = self.draw_mask(num_obj, mask, img,image_id)\n occlusion = np.logical_not(mask[:, :, -1]).astype(np.uint8)\n for i in range(count - 2, -1, -1):\n mask[:, :, i] = mask[:, :, i] * occlusion\n \n occlusion = np.logical_and(occlusion, np.logical_not(mask[:, :, i]))\n labels = []\n labels = self.from_yaml_get_class(image_id)\n labels_form = []\n for i in range(len(labels)):\n if labels[i].find(\"bird\") != -1:\n # print \"bird\"\n labels_form.append(\"bird\")\n class_ids = np.array([self.class_names.index(s) for s in labels_form])\n return mask, class_ids.astype(np.int32)","def make_pad_mask(seq_lens, device_id=-1):\n bs = seq_lens.size(0)\n max_time = max(seq_lens)\n\n seq_range = torch.arange(0, max_time, dtype=torch.int32)\n seq_range_expand = seq_range.unsqueeze(0).expand(bs, max_time)\n seq_length_expand = seq_range_expand.new(seq_lens).unsqueeze(-1)\n mask = seq_range_expand < seq_length_expand\n\n if device_id >= 0:\n mask = mask.cuda(device_id)\n\n return mask","def seqs_to_ids(seqs, char_to_id, max_len=20):\n all_seqs = []\n\n # Turn a list of names into a 2d padded array of token ids\n for text in seqs:\n if len(text) != 0:\n all_text = []\n for word in text:\n all_text.append(char_to_id.get(word))\n\n all_seqs.append(all_text)\n final_all_seqs = np.zeros((len(all_seqs), max_len))\n\n for idx, row in enumerate(all_seqs):\n if len(row) >= max_len:\n final_all_seqs[idx, :max_len] += row[:max_len]\n else:\n final_all_seqs[idx, :len(row)] += row\n print('Shape of data tensor:', final_all_seqs.shape)\n\n return final_all_seqs","def generate_direction_masks(cols):\n return list(product('01', repeat=cols))","def load_mask(self, image_id):\r\n info = self.image_info[image_id]\r\n mask = self.masks[image_id]\r\n count = int(mask.max())\r\n mask_new = np.zeros([info['height'], info['width'], count+1], dtype=np.uint8) # one more for background\r\n for i in range(count+1):\r\n #mask_new[:, :, i:i+1] = (mask == i).transpose(1, 2, 0)\r\n mask_new[:, :, i:i + 1] = (mask==i).reshape(mask.shape[0], mask.shape[1], -1)\r\n # mask_new[:, :, i:i+1] = (mask==i).transpose(1,2,0)\r\n # Map class names to class IDs.\r\n class_ids = np.ones(count+1) # one more fore background\r\n\r\n #add Background\r\n #class_ids[count] = 0 # add Background\r\n #mask_new[:, :, count:count + 1] = (mask == 0).transpose(1, 2, 0)\r\n #class_ids[count] = 0 # add Background\r\n class_ids[0] = 0 # add Background\r\n # End add Background\r\n\r\n return mask_new, class_ids.astype(np.int32)","def create_position_ids_from_input_ids(self, x):\r\n mask = x.ne(self.padding_idx).long()\r\n incremental_indicies = torch.cumsum(mask, dim=1) * mask\r\n return incremental_indicies + self.padding_idx","def _get_token_mask(input_ids: Tensor, pad_token_id: int, sep_token_id: int, cls_token_id: int) ->Tensor:\n token_mask = input_ids.eq(pad_token_id) | input_ids.eq(sep_token_id) | input_ids.eq(cls_token_id)\n return ~token_mask","def _make_masks(ilens, olens):\n # (B, T_in)\n in_masks = make_non_pad_mask(ilens)\n # (B, T_out)\n out_masks = make_non_pad_mask(olens)\n # (B, T_out, T_in)\n\n return paddle.logical_and(\n out_masks.unsqueeze(-1), in_masks.unsqueeze(-2))","def mask(self):\n mask = np.zeros((self.height, self.width))\n pts = [\n np.array(anno).reshape(-1, 2).round().astype(int)\n for anno in self.segmentation\n ]\n mask = cv2.fillPoly(mask, pts, 1)\n return mask","def load_mask(self, image_id):\n info = self.image_info[image_id]\n # Get mask directory from image path\n mask_dir = os.path.join(\n os.path.dirname(os.path.dirname(info['path'])), 'masks')\n\n # Read mask files from .png image\n masks = []\n for file in next(os.walk(mask_dir))[2]:\n if file.endswith('.png'):\n mask = imread(os.path.join(mask_dir, file),\n as_gray=True).astype(np.bool)\n masks.append(mask)\n masks = np.stack(masks, axis=-1)\n # Return masks, and array of class IDs of each instance. Since we have\n # one class ID, we return an array of ones\n return masks, np.ones([masks.shape[-1]], dtype=np.int32)","def make_mask(data, pad):\n def subsequent_mask(size):\n \"\"\" helper function for creating the masks. \"\"\"\n attn_shape = (1, size, size)\n subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')\n return torch.from_numpy(subsequent_mask) == 0\n\n mask = (data != pad).unsqueeze(-2)\n mask = mask & Variable(\n subsequent_mask(data.size(-1)).type_as(mask.data))\n return mask","def encode_segmap(self, mask):\n mask = mask.astype(int)\n label_mask = np.zeros((mask.shape[0], mask.shape[1]), dtype=np.int16)\n for ii, label in enumerate(self.get_pascal_labels()):\n label_mask[np.where(np.all(mask == label, axis=-1))[:2]] = ii\n label_mask = label_mask.astype(int)\n return label_mask","def __generate_mask(self):\n mask = np.concatenate([np.ones(len(self.fixed[0])),\n np.zeros(self.num_points),\n np.ones(len(self.fixed[1]))])\n return mask","def make_padding_mask(input_ids, padding_idx=1):\r\n padding_mask = input_ids.eq(padding_idx)\r\n if not padding_mask.any():\r\n padding_mask = None\r\n return padding_mask","def load_mask(self, image_id):\n\n image_info = self.image_info[image_id]\n if image_info[\"source\"] != \"pcb\":\n return super(self.__class__, self).load_mask(image_id)\n\n # convert polygons to a bitmap mask of shape\n # [height, width, instance_count]\n info = self.image_info[image_id]\n \n mask = np.zeros([info[\"height\"], info[\"width\"], len(info[\"polygons\"])],\n dtype=np.uint8)\n \n for i, p in enumerate(info[\"polygons\"]):\n # get indexes of pixels inside the polygon and set them to 1\n rr, cc = skimage.draw.polygon(p['all_points_y'], p['all_points_x'])\n mask[rr, cc, i] = 1\n\n # return mask, and array of class IDs of each instance.\n # since we have one class ID only, we return an array of 1s\n return mask.astype(np.bool), info[\"class_ids\"]","def _idx_pair_to_mask(beg_indices, end_indices, inputs, tgt_len, num_predict):\n non_func_mask = tf.not_equal(inputs, FLAGS.eos_id)\n all_indices = tf.where(\n non_func_mask,\n tf.range(tgt_len, dtype=tf.int64),\n tf.constant(-1, shape=[tgt_len], dtype=tf.int64))\n candidate_matrix = tf.cast(\n tf.logical_and(\n all_indices[None, :] >= beg_indices[:, None],\n all_indices[None, :] < end_indices[:, None]),\n tf.float32)\n cumsum_matrix = tf.reshape(\n tf.cumsum(tf.reshape(candidate_matrix, [-1])),\n [-1, tgt_len])\n masked_matrix = (tf.cast(cumsum_matrix <= num_predict, tf.float32)\n * candidate_matrix)\n target_mask = tf.reduce_sum(masked_matrix, axis=0)\n is_masked = tf.cast(target_mask, tf.bool)\n\n segment_range = tf.cast(tf.range(1, tf.shape(candidate_matrix)[0] + 1),\n dtype=candidate_matrix.dtype)\n segment_matrix = segment_range[:, None] * candidate_matrix\n segment_ids = tf.reduce_sum(segment_matrix * masked_matrix, axis=0)\n segment_ids = tf.cast(segment_ids, dtype=inputs.dtype)\n\n pos_mat = tf.cumsum(candidate_matrix, axis=1, exclusive=True)\n pos_seq = tf.reduce_sum(pos_mat * masked_matrix, axis=0)\n\n return is_masked, segment_ids, pos_seq","def damage_masks_np(labels, shift=True, scale=True, rotate=True, dilate=True):\n unique_labels = np.unique(labels)\n unique_labels = np.setdiff1d(unique_labels, [0])\n # Shuffle to get random depth ordering when combining together.\n np.random.shuffle(unique_labels)\n damaged_labels = np.zeros_like(labels)\n for l in unique_labels:\n obj_mask = (labels == l)\n damaged_obj_mask = _damage_single_object_mask(obj_mask, shift, scale,\n rotate, dilate)\n damaged_labels[damaged_obj_mask] = l\n return damaged_labels","def make_mask(data, pad):\n\n def subsequent_mask(size):\n \"\"\" helper function for creating the masks. \"\"\"\n attn_shape = (1, size, size)\n subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')\n return torch.from_numpy(subsequent_mask) == 0\n\n mask = (data != pad).unsqueeze(-2)\n mask = mask & Variable(\n subsequent_mask(data.size(-1)).type_as(mask.data))\n return mask","def encode_segmap(self, mask):\n for voidc in self.void_labels:\n mask[mask == voidc] = self.ignore_index\n for validc in self.valid_labels:\n mask[mask == validc] = self.class_map[validc]\n # remove extra idxs from updated dataset\n mask[mask > 33] = self.ignore_index\n return mask","def trim_input_ids(input_ids: torch.tensor, pad_token_id, mask_token_id, num_masks: int):\n assert input_ids.shape[0] == 1\n input_ids_without_pad = [x for x in input_ids[0] if x != pad_token_id]\n\n trimmed_input_ids = []\n mask_count = 0\n for input_id in input_ids_without_pad:\n if input_id == mask_token_id:\n if mask_count >= num_masks:\n continue\n mask_count += 1\n trimmed_input_ids.append(input_id)\n\n return torch.tensor([trimmed_input_ids], dtype=torch.long, device=input_ids.device)","def load_mask(self, image_id):\n # TODO: build dict **self.image_info** in this form\n # self.image_info.keys() = ['objects', 'imgWidth', 'imgHeight']\n # objects is a list which contains label and polygon (same as annotations form below)\n # imgHeight and imgWidth are numbers (usually 1024, 2048)\n annotations = self.image_info[image_id][\"objects\"]\n # annotations form: [{'label': label, 'polygon': [[x1,y1], [x2,y2] ...]}, ...]\n height = self.image_info[image_id]['imgHeight']\n width = self.image_info[image_id]['imgWidth']\n instance_masks = []\n class_ids = []\n for ann in annotations:\n m = self.annToMask(ann, height, width)\n \n label_tmp = ann['label']\n if ( not label_tmp in list(self.class_labels.keys()) ) and label_tmp.endswith('group'):\n label_tmp = label_tmp[:-len('group')]\n \n class_id = self.class_labels[label_tmp]\n instance_masks.append(m)\n class_ids.append(class_id)\n \n mask = np.stack(instance_masks, axis=2)\n class_ids = np.array(class_ids)\n \n return mask, class_ids","def trim_batch(\n input_ids,\n pad_token_id,\n attention_mask=None,\n):\n keep_column_mask = input_ids.ne(pad_token_id).any(dim=0)\n if attention_mask is None:\n return input_ids[:, keep_column_mask]\n else:\n return (input_ids[:, keep_column_mask], attention_mask[:, keep_column_mask])","def mask_tokens(self, sequence):\n n_tokens = len(sequence)\n n_masked_tokens = int(self.masking_proportion*n_tokens/100)\n indexes = [random.randint(0, n_tokens-1) for i in range(n_masked_tokens)]\n while len(set(indexes))!=n_masked_tokens:\n indexes = [random.randint(0, n_tokens-1) for i in range(n_masked_tokens)]\n sequence = np.array(sequence)\n sequence[indexes] = 4\n return list(sequence)","def getMask(label, scribble, class_id, class_ids):\n # Dense Mask\n fg_mask = torch.where(label == class_id,\n torch.ones_like(label), torch.zeros_like(label))\n bg_mask = torch.where(label != class_id,\n torch.ones_like(label), torch.zeros_like(label))\n for class_id in class_ids:\n bg_mask[label == class_id] = 0\n\n # Scribble Mask\n bg_scribble = scribble == 0\n fg_scribble = torch.where((fg_mask == 1)\n & (scribble != 0)\n & (scribble != 255),\n scribble, torch.zeros_like(fg_mask))\n scribble_cls_list = list(set(np.unique(fg_scribble)) - set([0,]))\n if scribble_cls_list: # Still need investigation\n fg_scribble = fg_scribble == random.choice(scribble_cls_list).item()\n else:\n fg_scribble[:] = 0\n\n return {'fg_mask': fg_mask,\n 'bg_mask': bg_mask,\n 'fg_scribble': fg_scribble.long(),\n 'bg_scribble': bg_scribble.long()}","def signal_masks(simulatedata_cbma):\n _, (ground_truth_foci, dataset) = simulatedata_cbma\n ground_truth_foci_ijks = [\n tuple(mm2vox(focus, dataset.masker.mask_img.affine)) for focus in ground_truth_foci\n ]\n return _create_signal_mask(np.array(ground_truth_foci_ijks), dataset.masker.mask_img)","def load_mask(self, image_id):\n # If not a pedestrian dataset image, delegate to parent class.\n image_info = self.image_info[image_id]\n if image_info[\"source\"] != \"pedestrian\":\n return super(self.__class__, self).load_mask(image_id)\n\n # Convert polygons to a bitmap mask of shape\n # [height, width, instance_count]\n info = self.image_info[image_id]\n mask = np.zeros([info[\"height\"], info[\"width\"], len(info[\"polygons\"])],\n dtype=np.uint8)\n for i, p in enumerate(info[\"polygons\"]):\n # Get indexes of pixels inside the polygon and set them to 1\n rr, cc = skimage.draw.polygon(p['all_points_y'], p['all_points_x'])\n mask[rr, cc, i] = 1\n\n # Return mask, and array of class IDs of each instance. Since we have\n # one class ID only, we return an array of 1s\n return mask.astype(np.bool), np.ones([mask.shape[-1]], dtype=np.int32)","def make_attn_mask(inp, inp_len, dtype=tf.float32):\n with tf.name_scope(\"encoder_mask\"):\n mask = tf.sequence_mask(inp_len, dtype=dtype, maxlen=tf.shape(inp)[1])\n return mask[:, None, None, :]","def get_regions_mask(self, input):","def create_attention_mask_from_input_mask(from_tensor, to_mask):\n from_shape = get_shape_list(from_tensor, expected_rank=[2, 3])\n batch_size = from_shape[0]\n from_seq_length = from_shape[1]\n \n to_shape = get_shape_list(to_mask, expected_rank=2)\n to_seq_length = to_shape[1]\n \n to_mask = tf.cast(\n tf.reshape(to_mask, [batch_size, 1, to_seq_length]), tf.float32)\n \n # We don't assume that `from_tensor` is a mask (although it could be). We\n # don't actually care if we attend *from* padding tokens (only *to* padding)\n # tokens so we create a tensor of all ones.\n #\n # `broadcast_ones` = [batch_size, from_seq_length, 1]\n broadcast_ones = tf.ones(\n shape=[batch_size, from_seq_length, 1], dtype=tf.float32)\n \n # Here we broadcast along two dimensions to create the mask.\n mask = broadcast_ones * to_mask\n \n return mask","def mask(mask_key, data):\r\n _m = array.array(\"B\", mask_key)\r\n _d = array.array(\"B\", data)\r\n for i in xrange(len(_d)):\r\n _d[i] ^= _m[i % 4]\r\n return _d.tostring()","def load_mask(self, image_id):\n info = self.image_info[image_id]\n label_path = info['path']\n\n # 读取json文件\n with open(os.path.join(self.DATA_ROOT_DIR, label_path), encoding='utf-8') as json_file:\n labelmeJson = json.load(json_file)\n height = labelmeJson['imageHeight']\n width = labelmeJson['imageWidth']\n shapes = labelmeJson['shapes']\n\n count = len(shapes)\n mask = np.zeros([height, width, count], dtype=np.uint8)\n\n for i, shape in enumerate(shapes):\n mask[:, :, i] = self.shape_to_mask(mask.shape, shape['points'], shape['shape_type'])\n\n # Map class names to class IDs.\n class_ids = np.array([self.class_names.index(shape['label']) if shape['label'] in self.class_names else self.class_names.index('undefined') for shape in shapes])\n #print('class_ids:', class_ids)\n #input()\n return mask.astype(np.bool), class_ids.astype(np.int32)","def load_mask(self, image_id):\n image_info = self.image_info[image_id]\n if image_info[\"source\"] != \"self_annotation\":\n super(CarsAndVehiclesDataset, self).load_mask(image_id)\n\n instance_masks = []\n class_ids = []\n annotations = self.image_info[image_id][\"annotations\"]\n # Build mask of shape [height, width, instance_count] and list\n # of class IDs that correspond to each channel of the mask.\n for annotation in annotations:\n class_id = self.map_source_class_id(\"self_annotation.{}\".format(annotation[\"category_id\"]))\n\n if class_id:\n m = self.annToMask(annotation, image_info[\"height\"], image_info[\"width\"])\n\n # Some objects are so small that they're less than 1 pixel area\n # and end up rounded out. Skip those objects.\n if m.max() < 1:\n continue\n # Is it a crowd? If so, use a negative class ID\n if annotation[\"iscrowd\"]:\n # Use negative class ID for crowds\n class_id *= -1\n # For crowd masks, annToMask() sometimes returns a mask\n # smaller than the given dimensions. If so, resize it.\n if m.shape[0] != image_info[\"height\"] or m.shape[1] != image_info[\"width\"]:\n m = np.ones(image_info[\"height\"], image_info[\"width\"], dtype=bool)\n instance_masks.append(m)\n class_ids.append(class_id)\n\n # Pack instance masks into an array\n if class_ids:\n mask = np.stack(instance_masks, axis=2).astype(np.bool)\n class_ids = np.array(class_ids, dtype=np.int32)\n return mask, class_ids\n else:\n # Call super class to return an empty mask\n return super(CarsAndVehiclesDataset, self).load_mask(image_id)","def test_mask_along_axis_iid_preserve(self, mask_param, mask_value, axis):\n for _ in range(5):\n specgrams = torch.randn(4, 2, 1025, 400, dtype=self.dtype, device=self.device)\n specgrams_copy = specgrams.clone()\n F.mask_along_axis_iid(specgrams, mask_param, mask_value, axis)\n\n self.assertEqual(specgrams, specgrams_copy)","def load_mask(self, image_id):\n info = self.image_info[image_id]\n# logger.info(\"mask {}\".format(image_id))\n if info[\"mask\"] is None:\n craters = info['craters']\n count = len(craters)\n mask = np.zeros([info['height'], info['width'], count], dtype=np.uint8)\n for i, dims in enumerate(craters):\n mask[:, :, i:i+1] = self.draw_shape(mask[:, :, i:i+1].copy(),\n \"circle\", dims, 1)\n # Handle occlusions\n occlusion = np.logical_not(mask[:, :, -1]).astype(np.uint8)\n for i in range(count-2, -1, -1):\n mask[:, :, i] = mask[:, :, i] * occlusion\n occlusion = np.logical_and(occlusion, np.logical_not(mask[:, :, i]))\n # Map class names to class IDs.\n class_ids = np.array([self.class_names.index(s) for s in info[\"shapes\"]])\n info[\"mask\"] = mask.astype(np.bool)\n info[\"class_ids\"] = class_ids.astype(np.int32)\n else:\n mask, class_ids = info[\"mask\"], info[\"class_ids\"]\n return mask, class_ids","def _generate_masks(self, data, batch_size):\n\n height, width = data.shape[2], data.shape[3]\n\n mask_size = (self._down_sample_size, self._down_sample_size)\n\n up_size = (height + mask_size[0], width + mask_size[1])\n mask = np.random.random((batch_size, 1) + mask_size) < self._mask_probability\n upsample = resize(op.Tensor(mask, data.dtype), up_size,\n self._resize_mode).asnumpy()\n shift_x = np.random.randint(0, mask_size[0] + 1, size=batch_size)\n shift_y = np.random.randint(0, mask_size[1] + 1, size=batch_size)\n\n masks = [sample[:, x_i: x_i + height, y_i: y_i + width] for sample, x_i, y_i\n in zip(upsample, shift_x, shift_y)]\n masks = Tensor(np.array(masks), data.dtype)\n return masks","def generate_mask(input_tensor: torch.Tensor, sequence_lengths: torch.LongTensor) -> torch.Tensor:\n assert input_tensor.size()[0] == sequence_lengths.size()[0], \\\n f\"Batch size {input_tensor.size()[0]} != number of provided lengths {sequence_lengths.size()[0]}.\"\n\n mask = torch.ones_like(input_tensor, dtype = torch.bool)\n for i, length in enumerate(sequence_lengths):\n mask[i][:, length:] = False\n\n return mask","def get_mask_from_lengths(memory, memory_lengths):\n mask = memory.data.new(memory.size(0), memory.size(1)).byte().zero_()\n for idx, l in enumerate(memory_lengths):\n mask[idx][:l] = 1\n return ~mask","def infer_mask(seq, eos_ix, time_major=False, dtype=tf.float32):\n axis = 0 if time_major else 1\n lengths = infer_length(seq, eos_ix, time_major=time_major)\n mask = tf.sequence_mask(lengths, maxlen=tf.shape(seq)[axis], dtype=dtype)\n if time_major: mask = tf.transpose(mask)\n return mask","def convertMaskToWeights(mask):\n vals = np.unique(mask)\n for i in range(len(vals)):\n mask[mask==vals[i]]=i\n mask = mask.astype(int)\n w = mask.ravel() \n return w","def int_to_smile(self, array):\n all_smi = []\n for seq in array:\n new_mol = [self.indices_token[int(x)] for x in seq]\n all_smi.append(''.join(new_mol).replace(self.pad_char, ''))\n return all_smi","def load_mask_pre(self, image_id, mask_path):\n img = Image.open(mask_path)\n colors = img.getcolors()\n n_dim = np.shape(colors)\n num_obj = n_dim[0]-1 #not include the background\n\n mask = np.zeros([np.shape(img)[0], np.shape(img)[1], num_obj], dtype=np.uint8)\n mask = self.draw_mask(num_obj, mask, img, colors)\n\n # Map class names to class IDs.\n class_ids = []\n for i in range(num_obj):\n class_ids.append(colors[i+1][1])\n\n return mask.astype(np.bool), np.array(class_ids, dtype=np.int32) #mask.astype(np.bool)","def create_all_mask(mask, num, stride):\n scale_factor = 1.0 / stride\n small_mask = cv2.resize(mask, (0, 0), fx=scale_factor, fy=scale_factor, interpolation=cv2.INTER_CUBIC)\n small_mask = small_mask[:, :, np.newaxis]\n return np.repeat(small_mask, num, axis=2)","def mtid_matrix(self, mtids):\n output = np.zeros((len(mtids), self.matrix.shape[1]))\n for i, mtid in enumerate(mtids):\n output[i] = self.matrix[self.mtid_lookup[mtid]]\n return output","def createMaskDictionary(self):\n try:\n self.maskMap = dict(list(zip(self.inds,list(range(len(self.inds))))))\n self.maskSet = set(self.inds)\n except Exception as error:\n print(\"failed in createMaskDictionary\", error)","def generate_mask(sequence_length):\n if FLAGS.mask_strategy == 'random':\n mask = []\n for seq in range(FLAGS.batch_size):\n p = np.random.choice(\n [True, False],\n size=[sequence_length[seq]],\n p=[FLAGS.is_present_rate, 1. - FLAGS.is_present_rate])\n while p.size<FLAGS.sequence_length:\n p = np.append(p, np.array([True]))\n mask.append(p)\n p = np.array(mask)\n\n elif FLAGS.mask_strategy == 'contiguous':\n mask = []\n for seq in range(FLAGS.batch_size):\n masked_length = int((1 - FLAGS.is_present_rate) * sequence_length[seq]) - 1\n # Determine location to start masking.\n start_mask = np.random.randint(\n 1, sequence_length[seq] - masked_length + 1, size=None)\n p = np.full([sequence_length[seq]], True, dtype=bool)\n #print(masked_length)\n # Create contiguous masked section to be False.\n p[start_mask:start_mask + masked_length] = False\n #print(p)\n\n while p.size<FLAGS.sequence_length:\n #print(p.size, FLAGS.sequence_length)\n #input('maskk')\n p = np.append(p, np.array([True]))\n #print(p)\n mask.append(p)\n p = np.array(mask) \n else:\n raise NotImplementedError\n\n return p","def batches2IDs(batches):\n l = [ np.array( [ char2id(x) for x in characters(b) ] ) for b in batches ]\n return l","def mask_to_positions(maskstring):\r\n return nonzero(array(map(int, maskstring)))[0]","def scan(self, mask):","def gen_all_arms_ids(\n self,\n ) -> None:\n num_all_arms = (\n self.num_unique_batches * self.batch_size * self.num_arms_per_episode\n )\n all_arms_ids = torch.randperm(num_all_arms)\n self.all_unique_arm_ids = all_arms_ids.reshape(\n [self.num_unique_batches, self.batch_size, self.num_arms_per_episode]\n )\n assert self.all_unique_arm_ids.ndim == 3\n return","def isolate_key_ponits(mask, keypoints):\n new_mask = np.zeros(mask.shape) * 255\n for y, x in keypoints[0].convert(keypoints):\n x = int(x)\n y = int(y)\n print(x, y)\n new_mask[x - 100: x + 100, y - 100: y + 100] = mask[x - 100: x + 100, y - 100: y + 100]\n return new_mask","def load_mask(self, image_id):\n # If not a balloon dataset image, delegate to parent class.\n image_info = self.image_info[image_id]\n if image_info[\"source\"] != \"glomerulus\":\n return super(self.__class__, self).load_mask(image_id)\n\n # Convert polygons to a bitmap mask of shape\n # [height, width, instance_count]\n info = self.image_info[image_id]\n mask = np.zeros([info[\"height\"], info[\"width\"], len(info[\"polygons\"])],\n dtype=np.uint8)\n for i, p in enumerate(info[\"polygons\"]):\n # Get indexes of pixels inside the polygon and set them to 1\n rr, cc = skimage.draw.polygon(p['all_points_y'], p['all_points_x'])\n mask[rr, cc, i] = 1\n\n # Return mask, and array of class IDs of each instance. Since we have\n # one class ID only, we return an array of 1s\n return mask, np.ones([mask.shape[-1]], dtype=np.int32)","def create_mask(neurons: list):\n\n return np.zeros_like(neurons[0])","def create_masked_lm_predictions_based_given(tokens, max_predictions_per_seq, segment_ids):\n\n tokens_len = len(tokens)\n\n output_tokens = []\n masked_lm_positions = []\n masked_lm_labels = []\n segment_ids_new = []\n i=0\n idx=0\n num_masks = 0\n while i < tokens_len:\n tok = tokens[i]\n if tok==u'01':\n masked_token = \"[MASK]\"\n output_tokens.append(masked_token)\n masked_lm_positions.append(idx)\n i+=1\n num_masks += 1\n masked_lm_labels.append(tokens[i])\n segment_ids_new.append(segment_ids[i])\n idx+=1\n else:\n output_tokens.append(tok)\n segment_ids_new.append(segment_ids[i])\n idx+=1\n i+=1\n if num_masks>max_predictions_per_seq:\n print ('too many masks')\n # print (tokens)\n # print (output_tokens)\n # print (masked_lm_positions)\n # print (masked_lm_labels)\n # abc\n\n return (output_tokens, masked_lm_positions, masked_lm_labels, segment_ids_new)","def load_mask(self, image_id):\r\n mask_path = self.mask_path[self.ids[image_id]]\r\n file_pattern = os.path.join(mask_path, \"*.png\")\r\n info = self.image_info[image_id]\r\n mask_files = glob.glob(file_pattern)\r\n #mask_tmp = cv2.imread(mask_files[0])\r\n mask_new = np.zeros([info['height'], info['width'], mask_files.__len__()+1], dtype=np.uint8) # one more for background\r\n count = 1\r\n mask_total = 0\r\n for i in mask_files:\r\n mask = cv2.imread(i)\r\n mask = mask[:, :, 1] / 255.0\r\n #mask = ski_transform.resize(mask, (info['height'], info['width']), mode='reflect')\r\n mask_new[:, :, count] = (mask)\r\n mask_total = mask_total + (mask>0) * count\r\n count = count + 1\r\n # Map class names to class IDs.\r\n class_ids = np.ones(count) # one more fore background\r\n #add Background\r\n class_ids[0] = 0; # Background\r\n mask_new[:, :, 0] = np.invert(mask_total.astype(np.bool))\r\n # End add Background\r\n\r\n return mask_new, class_ids.astype(np.int32)","def action_arr2id(arr):\n ids = []\n for a in arr:\n id = np.where(np.all(actions==a, axis=1))\n ids.append(id[0][0])\n return np.array(ids)","def get_subject_sequence(img_itk, img_size, img_spacing, img_origin, mask_direction): \n n_sequence = img_size[-1]\n img_array = itk.GetArrayFromImage(img_itk)\n itk_sequences = []\n for item in range(n_sequence):\n img_sequence = img_array[item]\n itk_img_sequence = itk.GetImageFromArray(img_sequence)\n itk_img_sequence.SetOrigin(img_origin[:3])\n itk_img_sequence.SetSpacing(img_spacing[:3])\n itk_img_sequence.SetDirection(mask_direction)\n itk_sequences.append(itk_img_sequence)\n \n return itk_sequences","def load_mask(self, image_id):\n info = self.image_info[image_id]\n mask_image_path = info['path'].replace(\"images\", \"masks\")\n mask = cv2.imread(mask_image_path)\n mask = (np.max(mask, axis=2) if len(mask.shape) > 2 else mask).reshape((128,128,1))\n \n return mask, np.array([1,])","def get_idxes_from_mask(mask):\n if len(mask) > 1:\n return torch.nonzero(mask.squeeze(), as_tuple=False).reshape(1, -1)[0]\n elif len(mask) == 1:\n return torch.tensor([0], dtype=torch.int64) if mask.sum() == 1 else torch.tensor([], dtype=torch.int64)\n return torch.tensor([], dtype=torch.int64)","def masktoregions(in_mask):\n regions = []\n for i in [0,1]: # do the thing for the first and second strands\n current_strand = in_mask[i].copy().astype(float)\n current_strand[-1] = np.nan # set final position to np.nan to avoid overlap issues\n transitions = current_strand - np.roll(current_strand,1)\n true_start = np.where(transitions == 1)[0]\n true_end = np.where(transitions == -1)[0] - 1\n if current_strand[0] == 1: # if starts on True, add True start to front end\n true_start = np.r_[0,true_start]\n if in_mask[i][-1] == True: # if ends on True, add True end to back end\n true_end = np.r_[true_end, len(current_strand)-1]\n if in_mask[i][-2] == False: # if the one before is False, it's a single point True\n true_start = np.r_[true_start,len(current_strand)-1]\n if np.all(in_mask[i][-2:] == [True, False]):\n true_end = np.r_[true_end, len(current_strand)-2]\n regions.append(np.asarray([np.zeros(len(true_start))+i,true_start,true_end]).T)\n out_regions = np.concatenate(regions,axis=0).astype(int)\n return out_regions","def generate_MLmask(self):\r\n self.MLmask = np.zeros((self.MLtargetedImg.shape[0], self.MLtargetedImg.shape[1]))\r\n \r\n if len(self.selected_ML_Index) > 0:\r\n for selected_index in self.selected_ML_Index:\r\n self.MLmask = np.add(self.MLmask, self.Mask[:,:,selected_index])\r\n \r\n self.intergrate_into_final_mask()\r\n \r\n self.add_rois_of_selected()\r\n \r\n else:\r\n self.intergrate_into_final_mask()","def build_segment_ids(input_ids): \n segment_ids = [] \n for seq in input_ids: \n segment_id = []\n id_ = 0\n for token_id in seq: \n segment_id.append(id_)\n # 102 : [SEP]\n if token_id == 102: \n id_ +=1 \n id_ %= 2 \n segment_ids.append(segment_id)\n return segment_ids","def createMaks(self):\n mask = np.zeros((self.height, self.width)) # (H, W)\n center = self.width // 2\n\n for lat in range(self.height):\n count = int(self.counts[lat])\n # print(lat, count)\n # print(center - count, center, center + count)\n mask[lat][center: center + count] = 1\n mask[lat][center - count: center] = 1\n\n return mask # (H, W)"],"string":"[\n \"def build_attention_mask(input_ids): \\n attention_masks = [] \\n\\n # 1 for input and 0 for pad\\n for seq in input_ids: \\n attention_masks.append([float(i>0) for i in seq])\\n\\n return attention_masks\",\n \"def mask_id(self):\\n m = 2 * self.mask_full()\\n m[0:self.size, 0:self.size] = self.id * self.mask()\\n return m.astype(np.int16)\",\n \"def _prepare_mask_file(mask):\\n result = np.ndarray((mask.shape[0], mask.shape[1]), dtype=np.uint8)\\n for i in range(mask.shape[0]):\\n for j in range(mask.shape[1]):\\n\\n if mask[i][j] > 0:\\n result[i][j] = 1\\n else:\\n result[i][j] = 0\\n \\n return result\",\n \"def load_mask(self, image_id):\\n # Override this function to load a mask from your dataset.\\n # Otherwise, it returns an empty mask.\\n mask = np.empty([0, 0, 0])\\n class_ids = np.empty([0], np.int32)\\n return mask, class_ids\",\n \"def load_mask(self, window_id):\\n streams = self.load_streams(window_id)\\n info=self.window_info[window_id]\\n shape=info[\\\"shape\\\"]\\n\\n mask = np.zeros([shape[0], shape[1], 1], dtype=np.uint8)\\n\\n for stream_id,stream in enumerate(streams):\\n\\n for trace in stream:\\n if trace.stats.channel==\\\"U\\\":\\n start=int(round(trace.stats.sac[\\\"a\\\"]*100))\\n end=int(round(trace.stats.sac[\\\"t0\\\"]*100))\\n else:\\n continue\\n\\n mask[stream_id,start:end+1,0]= 1\\n\\n class_ids = np.ones([1])\\n\\n if self.shuffle:\\n random.seed(window_id)\\n random_index=random.sample(range(shape[0]),shape[0])\\n mask[:,:,0]=mask[:,:,0][random_index]\\n\\n streams=[streams[i] for i in random_index]\\n\\n\\n\\n station=np.zeros([shape[0],shape[0],2])\\n for i,j in itertools.product(range(shape[0]),range(shape[0])):\\n station[i,j]=[streams[j][0].stats.sac[\\\"stla\\\"]/streams[i][0].stats.sac[\\\"stla\\\"],streams[j][0].stats.sac[\\\"stlo\\\"]/streams[i][0].stats.sac[\\\"stlo\\\"]]\\n\\n\\n return mask.astype(np.bool), class_ids.astype(np.int32),station.astype(np.float32)\",\n \"def label_to_mask(labels):\\n # get the image size\\n h, w = labels.shape\\n\\n # build a color to label map\\n idx_to_color = {}\\n for label in class_info:\\n idx_to_color[class_info[label].id] = class_info[label].color\\n\\n # generate label matrix\\n mask = np.zeros((h, w, 3), dtype=np.uint8)\\n for y in range(h):\\n for x in range(w):\\n id = labels[y, x]\\n r, g, b = idx_to_color[id]\\n mask[y, x] = np.array([b, g, r])\\n\\n return mask\",\n \"def load_mask(self, image_id):\\n # Override this function to load a mask from your dataset.\\n # Otherwise, it returns an empty mask.\\n logging.warning(\\\"You are using the default load_mask(), maybe you need to define your own one.\\\")\\n mask = np.empty([0, 0, 0])\\n class_ids = np.empty([0], np.int32)\\n return mask, class_ids\",\n \"def create_mask_list(self, seg_img, K):\\n all_ids = np.unique(seg_img)\\n chosen_ids = np.random.choice(all_ids, K)\\n\\n return [(seg_img == ID).astype(np.float32) for ID in chosen_ids]\",\n \"def get_ids(self, tensor=False):\\n array = self.array\\n id_mask = np.zeros(array.shape, dtype=np.uint8)\\n for c, val in enumerate(self.class_values):\\n id_mask[array == val] = c\\n \\n if tensor:\\n id_mask = torch.from_numpy(id_mask) # takes numpy dtype, not float\\n\\n return id_mask\",\n \"def load_mask(self, image_id):\\n info = self.image_info[image_id]\\n image_name = str(info['id']).zfill(6) + \\\"_10.png\\\"\\n gt_image = imageio.imread(\\\"./training/instance/\\\" + image_name)\\n instance_gt = np.array(gt_image) % 256\\n semantic_gt = np.array(gt_image) // 256\\n instance_gt = cv2.resize(instance_gt, (self.width, self.height), interpolation=cv2.INTER_NEAREST)\\n semantic_gt = cv2.resize(semantic_gt, (self.width, self.height), interpolation=cv2.INTER_NEAREST)\\n labels = [26, 24]\\n masks = []\\n class_ids = []\\n for l in labels:\\n mask_sem = (semantic_gt == [l]).astype(np.int_) * 255\\n mask_ins = instance_gt & mask_sem\\n num_ins = np.max(mask_ins)\\n if(num_ins > 30):\\n print(\\\"WARNING: num ins %d for label l %d\\\" % (num_ins, l))\\n\\n for i in range(1, num_ins + 1):\\n mask_obj = (mask_ins == [i]).astype(np.int_) * 255\\n masks.append(mask_obj)\\n if l == 24:\\n class_ids.append(2)\\n else:\\n class_ids.append(1)\\n masks = np.array(masks)\\n masks = np.moveaxis(masks, 0, -1)\\n class_ids = np.array(class_ids)\\n return masks, class_ids\",\n \"def transform_targets_to_boolean(dataset, img_id, img_size):\\n ann_ids = dataset.getAnnIds(img_id)\\n anns = dataset.loadAnns(ann_ids)\\n out_mask = np.zeros(img_size, dtype=bool)\\n adder = np.array([0., 1., 0., 1.])\\n\\n for ann in anns:\\n bbox = (np.array(ann['bbox']) + adder).astype(int)\\n bbox[3] = bbox[1] + bbox[3]\\n bbox[2] = bbox[0] + bbox[2]\\n out_mask[bbox[1]:bbox[3], bbox[0]:bbox[2]] = True\\n\\n return out_mask\",\n \"def _source_mask(self, ilens):\\n x_masks = make_non_pad_mask(ilens)\\n return x_masks.unsqueeze(-2)\",\n \"def generate_mask_aligned(data, length, tp_union):\\n mask = np.zeros((data.shape[0], tp_union.shape[0]))\\n e_data = torch.zeros((data.shape[0], tp_union.shape[0], data.shape[2]))\\n e_data = e_data.to(data.device)\\n r_arr = []\\n\\n for i, l in enumerate(length):\\n mask[i, :l] = 1\\n e_data[i, :l] = data[i, :l]\\n r_arr.append(np.where(mask[i] == 1)[0])\\n\\n return mask, e_data, r_arr\",\n \"def test_get_mask(self):\\n\\n spine_data_loader = SpineDataLoader(dirpath_data=self.dirpath,\\n batch_size=4)\\n\\n for idx in range(4):\\n mask = spine_data_loader.get_mask(str(idx))\\n assert mask.shape == (256, 256, 1)\\n assert mask.dtype == 'int64'\",\n \"def mod_mask(self):\\n # Check the *_masq values\\n self.__log.debug(\\\"Checking the *_masq arrays\\\")\\n # Retrieve the kid boxes\\n masq_names = np.unique([\\\"{}_masq\\\".format(item[1]) for item in self.list_detector])\\n self.__check_attributes(masq_names, read_missing=False)\\n # Check that they are all the same\\n warnings.warn(\\\"Temporary fix to int8\\\")\\n masqs = [getattr(self, masq).astype(np.int8) for masq in masq_names]\\n\\n if np.any(np.std(masqs, axis=0) != 0):\\n self.__log.error(\\\"*_masq is varying -- Please check : {}\\\".format(pprint_list(masq_names, \\\"_masq\\\")))\\n\\n # AB private comm) main_flag should be the bitwise_or of all boxes\\n # Well not exactly....\\n # cast into 8 bit, is more than enough, only 3 bits used anyway...\\n masq = np.bitwise_or.reduce(masqs, axis=0).astype(np.int8)\\n\\n # AB (#CONCERTO_DAQ January 11 13:02)\\n # _flag_balayage_en_cours & _flag_blanking_synthe\\n # Ainsi on aura la modulation en bit0 et 1 et le flag blanking en bit\\n # AB (#CONCERTO_DAQ February 11 11:07)\\n # bit 1 & 2 code the modulation as a signed integer -1 0 1 : 11 00 01 ie 3 0 1\\n # bit 3 is a blanking bit, which does not exist for KISS, but should not be taken into account for CONCERTO\\n\\n # Thus as a temporary fix, let's clear the 3rd bit, actually a bad idea...\\n # self.__log.warning(\\\"Temporary fix : clearing the 3rd bit of masq\\\")\\n # masq = masq & ~(1 << 2)\\n\\n return masq\",\n \"def load_mask(self, image_id):\\r\\n info = self.image_info[image_id]\\r\\n mask = tifffile.imread(self.mask_path[self.ids[image_id]])\\r\\n\\r\\n if np.unique(mask).__len__() > 1:\\r\\n count = np.unique(mask).__len__()-1 # one less because of 0\\r\\n\\r\\n mask_new = np.zeros([info['height'], info['width'], count], dtype=np.uint8) # one more for background\\r\\n running = 0\\r\\n for i in np.unique(mask): #range(1, count):\\r\\n if ((i > 0) & ((mask == i).sum() > 0)):\\r\\n mask_new[:, :, running] = (mask == i)\\r\\n running = running + 1\\r\\n # Map class names to class IDs.\\r\\n class_ids = np.ones(count)\\r\\n else:\\r\\n mask_new = np.zeros([info['height'], info['width'], 1], dtype=np.uint8)\\r\\n class_ids = np.zeros([1])\\r\\n return mask_new, class_ids.astype(np.int32)\",\n \"def get_labels(self) -> np.array:\\n nb_samples = len(self.list_IDs)\\n M = np.empty((nb_samples, *self.dim[:-1], 3))\\n\\n for i, ID in enumerate(self.list_IDs):\\n M[i,] = np.load(self.mask_data_path + ID, allow_pickle=True)\\n\\n return M\",\n \"def load_mask(self, image_id):\\n info = self.image_info[image_id]\\n # Get mask directory from image path\\n mask_dir = os.path.join(os.path.dirname(os.path.dirname(info['path'])), \\\"masks\\\")\\n\\n # Read mask files from .png image\\n mask = []\\n # for f in next(os.walk(mask_dir))[2]:\\n m = skimage.io.imread(os.path.join(mask_dir, info['id']+'.png')).astype(np.bool)\\n mask.append(m)\\n # print(mask)\\n mask = np.stack(mask, axis=-1)\\n # Return mask, and array of class IDs of each instance. Since we have\\n # one class ID, we return an array of ones\\n return mask, np.ones([mask.shape[-1]], dtype=np.int32)\",\n \"def load_mask(self, image_id):\\n info = self.image_info[image_id]['mask_info']\\n mask_, id_ = info\\n\\n return mask_, id_ #mask.astype(np.bool)\",\n \"def load_mask(self, image_id):\\n image_info = self.image_info[image_id]\\n annotations = image_info['annotations']\\n instance_masks = []\\n class_ids = []\\n \\n for annotation in annotations:\\n class_id = annotation['category_id']\\n mask = Image.new('1', (image_info['width'], image_info['height']))\\n mask_draw = ImageDraw.ImageDraw(mask, '1')\\n for segmentation in annotation['segmentation']:\\n mask_draw.polygon(segmentation, fill=1)\\n bool_array = np.array(mask) > 0\\n instance_masks.append(bool_array)\\n class_ids.append(class_id)\\n\\n mask = np.dstack(instance_masks)\\n class_ids = np.array(class_ids, dtype=np.int32)\\n \\n return mask, class_ids\",\n \"def load_mask(self, image_id):\\n info = self.image_info[image_id]\\n mask_paths = glob.glob(info['path'].replace('images', 'masks').replace('.png', '*.png'))\\n masks = []\\n class_ids = []\\n for mask_path in mask_paths:\\n# print(mask_path)\\n mask = cv2.imread(mask_path,cv2.IMREAD_GRAYSCALE) \\n masks.append(mask)\\n if 'normal' in mask_path:\\n class_ids.append(0)\\n if 'benign' in mask_path:\\n class_ids.append(1)\\n if 'malignant' in mask_path:\\n class_ids.append(2)\\n masks = np.moveaxis(masks,0,-1)\\n class_ids = np.array(class_ids)\\n return masks, class_ids\",\n \"def create_padding_mask(seq):\\r\\n seq = tf.cast(tf.math.equal(seq, 0), tf.float32)\\r\\n return seq[:, tf.newaxis, tf.newaxis, :] # (batch_size, 1, 1, seq_len)\\r\",\n \"def _load_mask(self, image_id):\\n\\n mask_pattern = os.path.join(self.directory, image_id, \\\"masks/*.png\\\")\\n ic = ImageCollection(mask_pattern)\\n\\n mask = np.zeros(self.imsize, dtype='uint8')\\n for lbl, indiv_mask in enumerate(ic):\\n mask += ((\\n 1 + lbl) * self._process(indiv_mask, True).astype('uint8'))\\n\\n return mask\",\n \"def mask(self):\",\n \"def seqs_to_toks(self,id_array,remove_pads=True):\\n return [self.ids_to_toks(seq,remove_pads)\\n for seq in id_array]\",\n \"def get_sample_mask(self):\",\n \"def load_mask(self, image_id):\\n info = self.image_info[image_id]\\n num_cards = info['cards']\\n # count = len(num_cards)\\n count = 1 # there will only ever be 1 card per image (for simplicity) TODO: do multiple documents?\\n mask = np.zeros([info['height'], info['width'], count], dtype=np.uint8)\\n # for i, _ in enumerate(info['cards']):\\n mask[:, :, 0] = self.draw_quadrilateral(mask[:, :, 0].copy(), info['cornerpoints'], 1)\\n\\n # Handle occlusions\\n occlusion = np.logical_not(mask[:, :, -1]).astype(np.uint8)\\n for i in range(count-2, -1, -1):\\n mask[:, :, i] = mask[:, :, i] * occlusion\\n occlusion = np.logical_and(occlusion, np.logical_not(mask[:, :, i]))\\n # Map class names to class IDs.\\n # class_ids = np.array([self.class_names.index(s[0]) for s in num_categories])\\n\\n # Return mask, and array of class IDs of each instance. Since we have\\n # one class ID only, we return an array of 1s\\n return mask.astype(np.bool), np.ones([mask.shape[-1]], dtype=np.int32)\",\n \"def maskArr(arrIn, segMap, maskID):\\n return np.logical_and(segMap != maskID, segMap != 0)\",\n \"def mask(self):\\n return list(self._mask_generator())\",\n \"def load_mask(self, image_id):\\n info = self.image_info[image_id]\\n ships = info['ships']\\n count = len(ships)\\n mask = np.zeros([info['height'], info['width'], count], dtype=np.uint8)\\n for i, (ship, dims) in enumerate(info['ships']):\\n mask[:, :, i:i + 1] = self.draw_mask(mask[:, :, i:i + 1].copy(),\\n ship, dims)\\n # Handle occlusions\\n occlusion = np.logical_not(mask[:, :, -1]).astype(np.uint8)\\n for i in range(count - 2, -1, -1):\\n mask[:, :, i] = mask[:, :, i] * occlusion\\n occlusion = np.logical_and(\\n occlusion, np.logical_not(mask[:, :, i]))\\n # Map class names to class IDs.\\n class_ids = np.array([self.class_names.index(s[0]) for s in ships])\\n return mask, class_ids.astype(np.int32)\",\n \"def get_masks(data):\\n return [patient[0] for i, patient in enumerate(data) if i in good_patients]\",\n \"def generate_mask(self):\\n\\n polymer_length = len(self.sequence)\\n protein_length = len(self.particle_order) - polymer_length\\n\\n if self.filter_specification == 'type':\\n mask = np.in1d(self.particle_order, self.monomer_id)\\n elif self.filter_specification == 'id':\\n if self.molecule == 'polymer':\\n offset = protein_length\\n else:\\n offset = 0\\n mask = np.array([False] * (polymer_length + protein_length))\\n absolute_id = [x+offset for x in self.monomer_id]\\n mask[absolute_id] = True\\n else:\\n raise NotImplementedError(\\\"Filter is unknown. Use 'type' or 'id'!\\\")\\n\\n # if molecule == 'full', nothing needs to be done\\n if self.molecule == 'polymer':\\n mask[:protein_length] = [False] * protein_length\\n elif self.molecule == 'protein':\\n mask[protein_length:] = [False] * polymer_length\\n\\n return mask\",\n \"def _compute_masked_targets(self, item_ids: tf.Tensor, training: bool = False) -> MaskingInfo:\\n\\n labels = tf.cast(tf.fill(item_ids.shape, self.padding_idx), dtype=item_ids.dtype)\\n non_padded_mask = tf.cast(item_ids != self.padding_idx, labels.dtype)\\n rows_ids = tf.range(labels.shape[0], dtype=tf.int64)\\n # During training, masks labels to be predicted according to a probability, ensuring that\\n # each session has at least one label to predict\\n if training:\\n # Selects a percentage of items to be masked (selected as labels)\\n probability_matrix = tf.cast(\\n backend.random_bernoulli(array_ops.shape(labels), p=self.mlm_probability),\\n labels.dtype,\\n )\\n\\n mask_labels = probability_matrix * non_padded_mask\\n labels = tf.where(\\n tf.cast(mask_labels, tf.bool),\\n item_ids,\\n tf.cast(tf.fill(item_ids.shape, self.padding_idx), dtype=item_ids.dtype),\\n )\\n\\n # Set at least one item in the sequence to mask, so that the network\\n # can learn something with this session\\n one_random_index_by_session = tf.random.categorical(\\n tf.math.log(tf.cast(non_padded_mask, tf.float32)), num_samples=1\\n )\\n indices = tf.concat([tf.expand_dims(rows_ids, 1), one_random_index_by_session], axis=1)\\n labels = tf.tensor_scatter_nd_update(\\n labels, indices=indices, updates=tf.gather_nd(item_ids, indices)\\n )\\n mask_labels = tf.cast(labels != self.padding_idx, labels.dtype)\\n\\n # If a sequence has only masked labels, unmask one of the labels\\n sequences_with_only_labels = tf.reduce_sum(mask_labels, axis=1) == tf.reduce_sum(\\n non_padded_mask, axis=1\\n )\\n sampled_labels_to_unmask = tf.random.categorical(\\n tf.math.log(tf.cast(mask_labels, tf.float32)), num_samples=1\\n )\\n\\n labels_to_unmask = tf.boolean_mask(sampled_labels_to_unmask, sequences_with_only_labels)\\n rows_to_unmask = tf.boolean_mask(rows_ids, sequences_with_only_labels)\\n indices = tf.concat([tf.expand_dims(rows_to_unmask, 1), labels_to_unmask], axis=1)\\n num_updates, _ = indices.shape.as_list()\\n labels = tf.tensor_scatter_nd_update(\\n labels, indices, tf.cast(tf.fill(num_updates, self.padding_idx), labels.dtype)\\n )\\n mask_labels = labels != self.padding_idx\\n\\n else:\\n if self.eval_on_last_item_seq_only:\\n last_item_sessions = tf.reduce_sum(non_padded_mask, axis=1) - 1\\n\\n indices = tf.concat(\\n [\\n tf.expand_dims(rows_ids, 1),\\n tf.cast(tf.expand_dims(last_item_sessions, 1), tf.int64),\\n ],\\n axis=1,\\n )\\n labels = tf.tensor_scatter_nd_update(\\n labels, indices=indices, updates=tf.gather_nd(item_ids, indices)\\n )\\n mask_labels = labels != self.padding_idx\\n else:\\n masking_info = self.predict_all(item_ids)\\n mask_labels, labels = masking_info.schema, masking_info.targets\\n\\n return MaskingInfo(mask_labels, labels)\",\n \"def _make_causal_mask(\\n input_ids_shape: torch.Size, dtype: torch.dtype, device: torch.device, past_key_values_length: int = 0\\n):\\n bsz, tgt_len = input_ids_shape\\n mask = torch.full((tgt_len, tgt_len), torch.finfo(dtype).min, device=device)\\n mask_cond = torch.arange(mask.size(-1), device=device)\\n mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0)\\n mask = mask.to(dtype)\\n\\n if past_key_values_length > 0:\\n mask = torch.cat([torch.zeros(tgt_len, past_key_values_length, dtype=dtype, device=device), mask], dim=-1)\\n return mask[None, None, :, :].expand(bsz, 1, tgt_len, tgt_len + past_key_values_length)\",\n \"def prepare_data(seqs, labels, maxlen=None, xdim=3):\\n # Trim all output seqs to have only maxlen steps\\n if maxlen is not None:\\n Iseqs = []\\n Oseqs = []\\n for i_seq, o_seq in zip(seqs, labels):\\n if len(o_seq) < maxlen:\\n Iseqs.append(i_seq)\\n Oseqs.append(o_seq)\\n seqs = Iseqs\\n labels = Oseqs\\n else:\\n maxlen = 40\\n\\n # Pad and compute masks\\n ret_X = np.zeros((maxlen, len(seqs), xdim))\\n mask_X = np.zeros((maxlen, len(seqs)))\\n labels_X = np.zeros((maxlen, len(seqs)))\\n for k in range(len(seqs)):\\n mask_X[:len(labels[k]), k] = 1\\n ret_X[:len(labels[k]), k] = np.asarray(seqs[k])\\n labels_X[:len(labels[k]), k] = labels[k]\\n\\n return ret_X, mask_X, labels_X\",\n \"def load_mask(self, image_id):\\n\\n # If not a balloon dataset image, delegate to parent class.\\n image_info = self.image_info[image_id]\\n if image_info[\\\"source\\\"] != \\\"dsb\\\":\\n return super(self.__class__, self).load_mask(image_id)\\n\\n path = image_info[\\\"dir\\\"]\\n\\n mascara = next(os.walk(path + '/masks/'))[2]\\n masc = skimage.io.imread(path + '/masks/' + mascara[0])\\n height, width = masc.shape\\n\\n mask = np.zeros((height, width, len(mascara)), dtype=np.uint8)\\n\\n for i, mask_file in enumerate(mascara):\\n mask[:,:,i] = skimage.io.imread(path + '/masks/' + mask_file)\\n\\n # Return mask, and array of class IDs of each instance. Since we have\\n # one class ID only, we return an array of 1s\\n return mask, np.ones([mask.shape[-1]], dtype=np.int32)\",\n \"def generate_mask(data, tps, length, tp_union):\\n tp_map = {tp_union[i].item(): i for i in range(len(tp_union))}\\n\\n mask = np.zeros((data.shape[0], tp_union.shape[0]))\\n e_data = torch.zeros((data.shape[0], tp_union.shape[0], data.shape[2]))\\n e_data = e_data.to(data.device)\\n r_arr = []\\n\\n for i in range(len(mask)):\\n inds = [tp_map[tps[i][j].item()] for j in range(length[i])]\\n mask[i, inds] = 1\\n e_data[i, inds] = data[i, :length[i]]\\n r_arr.append(np.where(mask[i] == 1)[0])\\n\\n return mask, e_data, r_arr\",\n \"def Expand_Mask(mask, feature_dict):\\n new_mask = np.zeros(mask.shape + (len(feature_dict),))\\n for i in feature_dict.keys():\\n ni = int(i)\\n new_mask[mask == ni,ni] = 1 \\n return new_mask\",\n \"def load_mask(self, image_id):\\n global iter_num\\n print(\\\"image_id\\\",image_id)\\n info = self.image_info[image_id]\\n count = 1 # number of object\\n img = Image.open(info['mask_path'])\\n num_obj = self.get_obj_index(img)\\n mask = np.zeros([info['height'], info['width'], num_obj], dtype=np.uint8)\\n mask = self.draw_mask(num_obj, mask, img,image_id)\\n occlusion = np.logical_not(mask[:, :, -1]).astype(np.uint8)\\n for i in range(count - 2, -1, -1):\\n mask[:, :, i] = mask[:, :, i] * occlusion\\n \\n occlusion = np.logical_and(occlusion, np.logical_not(mask[:, :, i]))\\n labels = []\\n labels = self.from_yaml_get_class(image_id)\\n labels_form = []\\n for i in range(len(labels)):\\n if labels[i].find(\\\"bird\\\") != -1:\\n # print \\\"bird\\\"\\n labels_form.append(\\\"bird\\\")\\n class_ids = np.array([self.class_names.index(s) for s in labels_form])\\n return mask, class_ids.astype(np.int32)\",\n \"def make_pad_mask(seq_lens, device_id=-1):\\n bs = seq_lens.size(0)\\n max_time = max(seq_lens)\\n\\n seq_range = torch.arange(0, max_time, dtype=torch.int32)\\n seq_range_expand = seq_range.unsqueeze(0).expand(bs, max_time)\\n seq_length_expand = seq_range_expand.new(seq_lens).unsqueeze(-1)\\n mask = seq_range_expand < seq_length_expand\\n\\n if device_id >= 0:\\n mask = mask.cuda(device_id)\\n\\n return mask\",\n \"def seqs_to_ids(seqs, char_to_id, max_len=20):\\n all_seqs = []\\n\\n # Turn a list of names into a 2d padded array of token ids\\n for text in seqs:\\n if len(text) != 0:\\n all_text = []\\n for word in text:\\n all_text.append(char_to_id.get(word))\\n\\n all_seqs.append(all_text)\\n final_all_seqs = np.zeros((len(all_seqs), max_len))\\n\\n for idx, row in enumerate(all_seqs):\\n if len(row) >= max_len:\\n final_all_seqs[idx, :max_len] += row[:max_len]\\n else:\\n final_all_seqs[idx, :len(row)] += row\\n print('Shape of data tensor:', final_all_seqs.shape)\\n\\n return final_all_seqs\",\n \"def generate_direction_masks(cols):\\n return list(product('01', repeat=cols))\",\n \"def load_mask(self, image_id):\\r\\n info = self.image_info[image_id]\\r\\n mask = self.masks[image_id]\\r\\n count = int(mask.max())\\r\\n mask_new = np.zeros([info['height'], info['width'], count+1], dtype=np.uint8) # one more for background\\r\\n for i in range(count+1):\\r\\n #mask_new[:, :, i:i+1] = (mask == i).transpose(1, 2, 0)\\r\\n mask_new[:, :, i:i + 1] = (mask==i).reshape(mask.shape[0], mask.shape[1], -1)\\r\\n # mask_new[:, :, i:i+1] = (mask==i).transpose(1,2,0)\\r\\n # Map class names to class IDs.\\r\\n class_ids = np.ones(count+1) # one more fore background\\r\\n\\r\\n #add Background\\r\\n #class_ids[count] = 0 # add Background\\r\\n #mask_new[:, :, count:count + 1] = (mask == 0).transpose(1, 2, 0)\\r\\n #class_ids[count] = 0 # add Background\\r\\n class_ids[0] = 0 # add Background\\r\\n # End add Background\\r\\n\\r\\n return mask_new, class_ids.astype(np.int32)\",\n \"def create_position_ids_from_input_ids(self, x):\\r\\n mask = x.ne(self.padding_idx).long()\\r\\n incremental_indicies = torch.cumsum(mask, dim=1) * mask\\r\\n return incremental_indicies + self.padding_idx\",\n \"def _get_token_mask(input_ids: Tensor, pad_token_id: int, sep_token_id: int, cls_token_id: int) ->Tensor:\\n token_mask = input_ids.eq(pad_token_id) | input_ids.eq(sep_token_id) | input_ids.eq(cls_token_id)\\n return ~token_mask\",\n \"def _make_masks(ilens, olens):\\n # (B, T_in)\\n in_masks = make_non_pad_mask(ilens)\\n # (B, T_out)\\n out_masks = make_non_pad_mask(olens)\\n # (B, T_out, T_in)\\n\\n return paddle.logical_and(\\n out_masks.unsqueeze(-1), in_masks.unsqueeze(-2))\",\n \"def mask(self):\\n mask = np.zeros((self.height, self.width))\\n pts = [\\n np.array(anno).reshape(-1, 2).round().astype(int)\\n for anno in self.segmentation\\n ]\\n mask = cv2.fillPoly(mask, pts, 1)\\n return mask\",\n \"def load_mask(self, image_id):\\n info = self.image_info[image_id]\\n # Get mask directory from image path\\n mask_dir = os.path.join(\\n os.path.dirname(os.path.dirname(info['path'])), 'masks')\\n\\n # Read mask files from .png image\\n masks = []\\n for file in next(os.walk(mask_dir))[2]:\\n if file.endswith('.png'):\\n mask = imread(os.path.join(mask_dir, file),\\n as_gray=True).astype(np.bool)\\n masks.append(mask)\\n masks = np.stack(masks, axis=-1)\\n # Return masks, and array of class IDs of each instance. Since we have\\n # one class ID, we return an array of ones\\n return masks, np.ones([masks.shape[-1]], dtype=np.int32)\",\n \"def make_mask(data, pad):\\n def subsequent_mask(size):\\n \\\"\\\"\\\" helper function for creating the masks. \\\"\\\"\\\"\\n attn_shape = (1, size, size)\\n subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')\\n return torch.from_numpy(subsequent_mask) == 0\\n\\n mask = (data != pad).unsqueeze(-2)\\n mask = mask & Variable(\\n subsequent_mask(data.size(-1)).type_as(mask.data))\\n return mask\",\n \"def encode_segmap(self, mask):\\n mask = mask.astype(int)\\n label_mask = np.zeros((mask.shape[0], mask.shape[1]), dtype=np.int16)\\n for ii, label in enumerate(self.get_pascal_labels()):\\n label_mask[np.where(np.all(mask == label, axis=-1))[:2]] = ii\\n label_mask = label_mask.astype(int)\\n return label_mask\",\n \"def __generate_mask(self):\\n mask = np.concatenate([np.ones(len(self.fixed[0])),\\n np.zeros(self.num_points),\\n np.ones(len(self.fixed[1]))])\\n return mask\",\n \"def make_padding_mask(input_ids, padding_idx=1):\\r\\n padding_mask = input_ids.eq(padding_idx)\\r\\n if not padding_mask.any():\\r\\n padding_mask = None\\r\\n return padding_mask\",\n \"def load_mask(self, image_id):\\n\\n image_info = self.image_info[image_id]\\n if image_info[\\\"source\\\"] != \\\"pcb\\\":\\n return super(self.__class__, self).load_mask(image_id)\\n\\n # convert polygons to a bitmap mask of shape\\n # [height, width, instance_count]\\n info = self.image_info[image_id]\\n \\n mask = np.zeros([info[\\\"height\\\"], info[\\\"width\\\"], len(info[\\\"polygons\\\"])],\\n dtype=np.uint8)\\n \\n for i, p in enumerate(info[\\\"polygons\\\"]):\\n # get indexes of pixels inside the polygon and set them to 1\\n rr, cc = skimage.draw.polygon(p['all_points_y'], p['all_points_x'])\\n mask[rr, cc, i] = 1\\n\\n # return mask, and array of class IDs of each instance.\\n # since we have one class ID only, we return an array of 1s\\n return mask.astype(np.bool), info[\\\"class_ids\\\"]\",\n \"def _idx_pair_to_mask(beg_indices, end_indices, inputs, tgt_len, num_predict):\\n non_func_mask = tf.not_equal(inputs, FLAGS.eos_id)\\n all_indices = tf.where(\\n non_func_mask,\\n tf.range(tgt_len, dtype=tf.int64),\\n tf.constant(-1, shape=[tgt_len], dtype=tf.int64))\\n candidate_matrix = tf.cast(\\n tf.logical_and(\\n all_indices[None, :] >= beg_indices[:, None],\\n all_indices[None, :] < end_indices[:, None]),\\n tf.float32)\\n cumsum_matrix = tf.reshape(\\n tf.cumsum(tf.reshape(candidate_matrix, [-1])),\\n [-1, tgt_len])\\n masked_matrix = (tf.cast(cumsum_matrix <= num_predict, tf.float32)\\n * candidate_matrix)\\n target_mask = tf.reduce_sum(masked_matrix, axis=0)\\n is_masked = tf.cast(target_mask, tf.bool)\\n\\n segment_range = tf.cast(tf.range(1, tf.shape(candidate_matrix)[0] + 1),\\n dtype=candidate_matrix.dtype)\\n segment_matrix = segment_range[:, None] * candidate_matrix\\n segment_ids = tf.reduce_sum(segment_matrix * masked_matrix, axis=0)\\n segment_ids = tf.cast(segment_ids, dtype=inputs.dtype)\\n\\n pos_mat = tf.cumsum(candidate_matrix, axis=1, exclusive=True)\\n pos_seq = tf.reduce_sum(pos_mat * masked_matrix, axis=0)\\n\\n return is_masked, segment_ids, pos_seq\",\n \"def damage_masks_np(labels, shift=True, scale=True, rotate=True, dilate=True):\\n unique_labels = np.unique(labels)\\n unique_labels = np.setdiff1d(unique_labels, [0])\\n # Shuffle to get random depth ordering when combining together.\\n np.random.shuffle(unique_labels)\\n damaged_labels = np.zeros_like(labels)\\n for l in unique_labels:\\n obj_mask = (labels == l)\\n damaged_obj_mask = _damage_single_object_mask(obj_mask, shift, scale,\\n rotate, dilate)\\n damaged_labels[damaged_obj_mask] = l\\n return damaged_labels\",\n \"def make_mask(data, pad):\\n\\n def subsequent_mask(size):\\n \\\"\\\"\\\" helper function for creating the masks. \\\"\\\"\\\"\\n attn_shape = (1, size, size)\\n subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')\\n return torch.from_numpy(subsequent_mask) == 0\\n\\n mask = (data != pad).unsqueeze(-2)\\n mask = mask & Variable(\\n subsequent_mask(data.size(-1)).type_as(mask.data))\\n return mask\",\n \"def encode_segmap(self, mask):\\n for voidc in self.void_labels:\\n mask[mask == voidc] = self.ignore_index\\n for validc in self.valid_labels:\\n mask[mask == validc] = self.class_map[validc]\\n # remove extra idxs from updated dataset\\n mask[mask > 33] = self.ignore_index\\n return mask\",\n \"def trim_input_ids(input_ids: torch.tensor, pad_token_id, mask_token_id, num_masks: int):\\n assert input_ids.shape[0] == 1\\n input_ids_without_pad = [x for x in input_ids[0] if x != pad_token_id]\\n\\n trimmed_input_ids = []\\n mask_count = 0\\n for input_id in input_ids_without_pad:\\n if input_id == mask_token_id:\\n if mask_count >= num_masks:\\n continue\\n mask_count += 1\\n trimmed_input_ids.append(input_id)\\n\\n return torch.tensor([trimmed_input_ids], dtype=torch.long, device=input_ids.device)\",\n \"def load_mask(self, image_id):\\n # TODO: build dict **self.image_info** in this form\\n # self.image_info.keys() = ['objects', 'imgWidth', 'imgHeight']\\n # objects is a list which contains label and polygon (same as annotations form below)\\n # imgHeight and imgWidth are numbers (usually 1024, 2048)\\n annotations = self.image_info[image_id][\\\"objects\\\"]\\n # annotations form: [{'label': label, 'polygon': [[x1,y1], [x2,y2] ...]}, ...]\\n height = self.image_info[image_id]['imgHeight']\\n width = self.image_info[image_id]['imgWidth']\\n instance_masks = []\\n class_ids = []\\n for ann in annotations:\\n m = self.annToMask(ann, height, width)\\n \\n label_tmp = ann['label']\\n if ( not label_tmp in list(self.class_labels.keys()) ) and label_tmp.endswith('group'):\\n label_tmp = label_tmp[:-len('group')]\\n \\n class_id = self.class_labels[label_tmp]\\n instance_masks.append(m)\\n class_ids.append(class_id)\\n \\n mask = np.stack(instance_masks, axis=2)\\n class_ids = np.array(class_ids)\\n \\n return mask, class_ids\",\n \"def trim_batch(\\n input_ids,\\n pad_token_id,\\n attention_mask=None,\\n):\\n keep_column_mask = input_ids.ne(pad_token_id).any(dim=0)\\n if attention_mask is None:\\n return input_ids[:, keep_column_mask]\\n else:\\n return (input_ids[:, keep_column_mask], attention_mask[:, keep_column_mask])\",\n \"def mask_tokens(self, sequence):\\n n_tokens = len(sequence)\\n n_masked_tokens = int(self.masking_proportion*n_tokens/100)\\n indexes = [random.randint(0, n_tokens-1) for i in range(n_masked_tokens)]\\n while len(set(indexes))!=n_masked_tokens:\\n indexes = [random.randint(0, n_tokens-1) for i in range(n_masked_tokens)]\\n sequence = np.array(sequence)\\n sequence[indexes] = 4\\n return list(sequence)\",\n \"def getMask(label, scribble, class_id, class_ids):\\n # Dense Mask\\n fg_mask = torch.where(label == class_id,\\n torch.ones_like(label), torch.zeros_like(label))\\n bg_mask = torch.where(label != class_id,\\n torch.ones_like(label), torch.zeros_like(label))\\n for class_id in class_ids:\\n bg_mask[label == class_id] = 0\\n\\n # Scribble Mask\\n bg_scribble = scribble == 0\\n fg_scribble = torch.where((fg_mask == 1)\\n & (scribble != 0)\\n & (scribble != 255),\\n scribble, torch.zeros_like(fg_mask))\\n scribble_cls_list = list(set(np.unique(fg_scribble)) - set([0,]))\\n if scribble_cls_list: # Still need investigation\\n fg_scribble = fg_scribble == random.choice(scribble_cls_list).item()\\n else:\\n fg_scribble[:] = 0\\n\\n return {'fg_mask': fg_mask,\\n 'bg_mask': bg_mask,\\n 'fg_scribble': fg_scribble.long(),\\n 'bg_scribble': bg_scribble.long()}\",\n \"def signal_masks(simulatedata_cbma):\\n _, (ground_truth_foci, dataset) = simulatedata_cbma\\n ground_truth_foci_ijks = [\\n tuple(mm2vox(focus, dataset.masker.mask_img.affine)) for focus in ground_truth_foci\\n ]\\n return _create_signal_mask(np.array(ground_truth_foci_ijks), dataset.masker.mask_img)\",\n \"def load_mask(self, image_id):\\n # If not a pedestrian dataset image, delegate to parent class.\\n image_info = self.image_info[image_id]\\n if image_info[\\\"source\\\"] != \\\"pedestrian\\\":\\n return super(self.__class__, self).load_mask(image_id)\\n\\n # Convert polygons to a bitmap mask of shape\\n # [height, width, instance_count]\\n info = self.image_info[image_id]\\n mask = np.zeros([info[\\\"height\\\"], info[\\\"width\\\"], len(info[\\\"polygons\\\"])],\\n dtype=np.uint8)\\n for i, p in enumerate(info[\\\"polygons\\\"]):\\n # Get indexes of pixels inside the polygon and set them to 1\\n rr, cc = skimage.draw.polygon(p['all_points_y'], p['all_points_x'])\\n mask[rr, cc, i] = 1\\n\\n # Return mask, and array of class IDs of each instance. Since we have\\n # one class ID only, we return an array of 1s\\n return mask.astype(np.bool), np.ones([mask.shape[-1]], dtype=np.int32)\",\n \"def make_attn_mask(inp, inp_len, dtype=tf.float32):\\n with tf.name_scope(\\\"encoder_mask\\\"):\\n mask = tf.sequence_mask(inp_len, dtype=dtype, maxlen=tf.shape(inp)[1])\\n return mask[:, None, None, :]\",\n \"def get_regions_mask(self, input):\",\n \"def create_attention_mask_from_input_mask(from_tensor, to_mask):\\n from_shape = get_shape_list(from_tensor, expected_rank=[2, 3])\\n batch_size = from_shape[0]\\n from_seq_length = from_shape[1]\\n \\n to_shape = get_shape_list(to_mask, expected_rank=2)\\n to_seq_length = to_shape[1]\\n \\n to_mask = tf.cast(\\n tf.reshape(to_mask, [batch_size, 1, to_seq_length]), tf.float32)\\n \\n # We don't assume that `from_tensor` is a mask (although it could be). We\\n # don't actually care if we attend *from* padding tokens (only *to* padding)\\n # tokens so we create a tensor of all ones.\\n #\\n # `broadcast_ones` = [batch_size, from_seq_length, 1]\\n broadcast_ones = tf.ones(\\n shape=[batch_size, from_seq_length, 1], dtype=tf.float32)\\n \\n # Here we broadcast along two dimensions to create the mask.\\n mask = broadcast_ones * to_mask\\n \\n return mask\",\n \"def mask(mask_key, data):\\r\\n _m = array.array(\\\"B\\\", mask_key)\\r\\n _d = array.array(\\\"B\\\", data)\\r\\n for i in xrange(len(_d)):\\r\\n _d[i] ^= _m[i % 4]\\r\\n return _d.tostring()\",\n \"def load_mask(self, image_id):\\n info = self.image_info[image_id]\\n label_path = info['path']\\n\\n # 读取json文件\\n with open(os.path.join(self.DATA_ROOT_DIR, label_path), encoding='utf-8') as json_file:\\n labelmeJson = json.load(json_file)\\n height = labelmeJson['imageHeight']\\n width = labelmeJson['imageWidth']\\n shapes = labelmeJson['shapes']\\n\\n count = len(shapes)\\n mask = np.zeros([height, width, count], dtype=np.uint8)\\n\\n for i, shape in enumerate(shapes):\\n mask[:, :, i] = self.shape_to_mask(mask.shape, shape['points'], shape['shape_type'])\\n\\n # Map class names to class IDs.\\n class_ids = np.array([self.class_names.index(shape['label']) if shape['label'] in self.class_names else self.class_names.index('undefined') for shape in shapes])\\n #print('class_ids:', class_ids)\\n #input()\\n return mask.astype(np.bool), class_ids.astype(np.int32)\",\n \"def load_mask(self, image_id):\\n image_info = self.image_info[image_id]\\n if image_info[\\\"source\\\"] != \\\"self_annotation\\\":\\n super(CarsAndVehiclesDataset, self).load_mask(image_id)\\n\\n instance_masks = []\\n class_ids = []\\n annotations = self.image_info[image_id][\\\"annotations\\\"]\\n # Build mask of shape [height, width, instance_count] and list\\n # of class IDs that correspond to each channel of the mask.\\n for annotation in annotations:\\n class_id = self.map_source_class_id(\\\"self_annotation.{}\\\".format(annotation[\\\"category_id\\\"]))\\n\\n if class_id:\\n m = self.annToMask(annotation, image_info[\\\"height\\\"], image_info[\\\"width\\\"])\\n\\n # Some objects are so small that they're less than 1 pixel area\\n # and end up rounded out. Skip those objects.\\n if m.max() < 1:\\n continue\\n # Is it a crowd? If so, use a negative class ID\\n if annotation[\\\"iscrowd\\\"]:\\n # Use negative class ID for crowds\\n class_id *= -1\\n # For crowd masks, annToMask() sometimes returns a mask\\n # smaller than the given dimensions. If so, resize it.\\n if m.shape[0] != image_info[\\\"height\\\"] or m.shape[1] != image_info[\\\"width\\\"]:\\n m = np.ones(image_info[\\\"height\\\"], image_info[\\\"width\\\"], dtype=bool)\\n instance_masks.append(m)\\n class_ids.append(class_id)\\n\\n # Pack instance masks into an array\\n if class_ids:\\n mask = np.stack(instance_masks, axis=2).astype(np.bool)\\n class_ids = np.array(class_ids, dtype=np.int32)\\n return mask, class_ids\\n else:\\n # Call super class to return an empty mask\\n return super(CarsAndVehiclesDataset, self).load_mask(image_id)\",\n \"def test_mask_along_axis_iid_preserve(self, mask_param, mask_value, axis):\\n for _ in range(5):\\n specgrams = torch.randn(4, 2, 1025, 400, dtype=self.dtype, device=self.device)\\n specgrams_copy = specgrams.clone()\\n F.mask_along_axis_iid(specgrams, mask_param, mask_value, axis)\\n\\n self.assertEqual(specgrams, specgrams_copy)\",\n \"def load_mask(self, image_id):\\n info = self.image_info[image_id]\\n# logger.info(\\\"mask {}\\\".format(image_id))\\n if info[\\\"mask\\\"] is None:\\n craters = info['craters']\\n count = len(craters)\\n mask = np.zeros([info['height'], info['width'], count], dtype=np.uint8)\\n for i, dims in enumerate(craters):\\n mask[:, :, i:i+1] = self.draw_shape(mask[:, :, i:i+1].copy(),\\n \\\"circle\\\", dims, 1)\\n # Handle occlusions\\n occlusion = np.logical_not(mask[:, :, -1]).astype(np.uint8)\\n for i in range(count-2, -1, -1):\\n mask[:, :, i] = mask[:, :, i] * occlusion\\n occlusion = np.logical_and(occlusion, np.logical_not(mask[:, :, i]))\\n # Map class names to class IDs.\\n class_ids = np.array([self.class_names.index(s) for s in info[\\\"shapes\\\"]])\\n info[\\\"mask\\\"] = mask.astype(np.bool)\\n info[\\\"class_ids\\\"] = class_ids.astype(np.int32)\\n else:\\n mask, class_ids = info[\\\"mask\\\"], info[\\\"class_ids\\\"]\\n return mask, class_ids\",\n \"def _generate_masks(self, data, batch_size):\\n\\n height, width = data.shape[2], data.shape[3]\\n\\n mask_size = (self._down_sample_size, self._down_sample_size)\\n\\n up_size = (height + mask_size[0], width + mask_size[1])\\n mask = np.random.random((batch_size, 1) + mask_size) < self._mask_probability\\n upsample = resize(op.Tensor(mask, data.dtype), up_size,\\n self._resize_mode).asnumpy()\\n shift_x = np.random.randint(0, mask_size[0] + 1, size=batch_size)\\n shift_y = np.random.randint(0, mask_size[1] + 1, size=batch_size)\\n\\n masks = [sample[:, x_i: x_i + height, y_i: y_i + width] for sample, x_i, y_i\\n in zip(upsample, shift_x, shift_y)]\\n masks = Tensor(np.array(masks), data.dtype)\\n return masks\",\n \"def generate_mask(input_tensor: torch.Tensor, sequence_lengths: torch.LongTensor) -> torch.Tensor:\\n assert input_tensor.size()[0] == sequence_lengths.size()[0], \\\\\\n f\\\"Batch size {input_tensor.size()[0]} != number of provided lengths {sequence_lengths.size()[0]}.\\\"\\n\\n mask = torch.ones_like(input_tensor, dtype = torch.bool)\\n for i, length in enumerate(sequence_lengths):\\n mask[i][:, length:] = False\\n\\n return mask\",\n \"def get_mask_from_lengths(memory, memory_lengths):\\n mask = memory.data.new(memory.size(0), memory.size(1)).byte().zero_()\\n for idx, l in enumerate(memory_lengths):\\n mask[idx][:l] = 1\\n return ~mask\",\n \"def infer_mask(seq, eos_ix, time_major=False, dtype=tf.float32):\\n axis = 0 if time_major else 1\\n lengths = infer_length(seq, eos_ix, time_major=time_major)\\n mask = tf.sequence_mask(lengths, maxlen=tf.shape(seq)[axis], dtype=dtype)\\n if time_major: mask = tf.transpose(mask)\\n return mask\",\n \"def convertMaskToWeights(mask):\\n vals = np.unique(mask)\\n for i in range(len(vals)):\\n mask[mask==vals[i]]=i\\n mask = mask.astype(int)\\n w = mask.ravel() \\n return w\",\n \"def int_to_smile(self, array):\\n all_smi = []\\n for seq in array:\\n new_mol = [self.indices_token[int(x)] for x in seq]\\n all_smi.append(''.join(new_mol).replace(self.pad_char, ''))\\n return all_smi\",\n \"def load_mask_pre(self, image_id, mask_path):\\n img = Image.open(mask_path)\\n colors = img.getcolors()\\n n_dim = np.shape(colors)\\n num_obj = n_dim[0]-1 #not include the background\\n\\n mask = np.zeros([np.shape(img)[0], np.shape(img)[1], num_obj], dtype=np.uint8)\\n mask = self.draw_mask(num_obj, mask, img, colors)\\n\\n # Map class names to class IDs.\\n class_ids = []\\n for i in range(num_obj):\\n class_ids.append(colors[i+1][1])\\n\\n return mask.astype(np.bool), np.array(class_ids, dtype=np.int32) #mask.astype(np.bool)\",\n \"def create_all_mask(mask, num, stride):\\n scale_factor = 1.0 / stride\\n small_mask = cv2.resize(mask, (0, 0), fx=scale_factor, fy=scale_factor, interpolation=cv2.INTER_CUBIC)\\n small_mask = small_mask[:, :, np.newaxis]\\n return np.repeat(small_mask, num, axis=2)\",\n \"def mtid_matrix(self, mtids):\\n output = np.zeros((len(mtids), self.matrix.shape[1]))\\n for i, mtid in enumerate(mtids):\\n output[i] = self.matrix[self.mtid_lookup[mtid]]\\n return output\",\n \"def createMaskDictionary(self):\\n try:\\n self.maskMap = dict(list(zip(self.inds,list(range(len(self.inds))))))\\n self.maskSet = set(self.inds)\\n except Exception as error:\\n print(\\\"failed in createMaskDictionary\\\", error)\",\n \"def generate_mask(sequence_length):\\n if FLAGS.mask_strategy == 'random':\\n mask = []\\n for seq in range(FLAGS.batch_size):\\n p = np.random.choice(\\n [True, False],\\n size=[sequence_length[seq]],\\n p=[FLAGS.is_present_rate, 1. - FLAGS.is_present_rate])\\n while p.size<FLAGS.sequence_length:\\n p = np.append(p, np.array([True]))\\n mask.append(p)\\n p = np.array(mask)\\n\\n elif FLAGS.mask_strategy == 'contiguous':\\n mask = []\\n for seq in range(FLAGS.batch_size):\\n masked_length = int((1 - FLAGS.is_present_rate) * sequence_length[seq]) - 1\\n # Determine location to start masking.\\n start_mask = np.random.randint(\\n 1, sequence_length[seq] - masked_length + 1, size=None)\\n p = np.full([sequence_length[seq]], True, dtype=bool)\\n #print(masked_length)\\n # Create contiguous masked section to be False.\\n p[start_mask:start_mask + masked_length] = False\\n #print(p)\\n\\n while p.size<FLAGS.sequence_length:\\n #print(p.size, FLAGS.sequence_length)\\n #input('maskk')\\n p = np.append(p, np.array([True]))\\n #print(p)\\n mask.append(p)\\n p = np.array(mask) \\n else:\\n raise NotImplementedError\\n\\n return p\",\n \"def batches2IDs(batches):\\n l = [ np.array( [ char2id(x) for x in characters(b) ] ) for b in batches ]\\n return l\",\n \"def mask_to_positions(maskstring):\\r\\n return nonzero(array(map(int, maskstring)))[0]\",\n \"def scan(self, mask):\",\n \"def gen_all_arms_ids(\\n self,\\n ) -> None:\\n num_all_arms = (\\n self.num_unique_batches * self.batch_size * self.num_arms_per_episode\\n )\\n all_arms_ids = torch.randperm(num_all_arms)\\n self.all_unique_arm_ids = all_arms_ids.reshape(\\n [self.num_unique_batches, self.batch_size, self.num_arms_per_episode]\\n )\\n assert self.all_unique_arm_ids.ndim == 3\\n return\",\n \"def isolate_key_ponits(mask, keypoints):\\n new_mask = np.zeros(mask.shape) * 255\\n for y, x in keypoints[0].convert(keypoints):\\n x = int(x)\\n y = int(y)\\n print(x, y)\\n new_mask[x - 100: x + 100, y - 100: y + 100] = mask[x - 100: x + 100, y - 100: y + 100]\\n return new_mask\",\n \"def load_mask(self, image_id):\\n # If not a balloon dataset image, delegate to parent class.\\n image_info = self.image_info[image_id]\\n if image_info[\\\"source\\\"] != \\\"glomerulus\\\":\\n return super(self.__class__, self).load_mask(image_id)\\n\\n # Convert polygons to a bitmap mask of shape\\n # [height, width, instance_count]\\n info = self.image_info[image_id]\\n mask = np.zeros([info[\\\"height\\\"], info[\\\"width\\\"], len(info[\\\"polygons\\\"])],\\n dtype=np.uint8)\\n for i, p in enumerate(info[\\\"polygons\\\"]):\\n # Get indexes of pixels inside the polygon and set them to 1\\n rr, cc = skimage.draw.polygon(p['all_points_y'], p['all_points_x'])\\n mask[rr, cc, i] = 1\\n\\n # Return mask, and array of class IDs of each instance. Since we have\\n # one class ID only, we return an array of 1s\\n return mask, np.ones([mask.shape[-1]], dtype=np.int32)\",\n \"def create_mask(neurons: list):\\n\\n return np.zeros_like(neurons[0])\",\n \"def create_masked_lm_predictions_based_given(tokens, max_predictions_per_seq, segment_ids):\\n\\n tokens_len = len(tokens)\\n\\n output_tokens = []\\n masked_lm_positions = []\\n masked_lm_labels = []\\n segment_ids_new = []\\n i=0\\n idx=0\\n num_masks = 0\\n while i < tokens_len:\\n tok = tokens[i]\\n if tok==u'01':\\n masked_token = \\\"[MASK]\\\"\\n output_tokens.append(masked_token)\\n masked_lm_positions.append(idx)\\n i+=1\\n num_masks += 1\\n masked_lm_labels.append(tokens[i])\\n segment_ids_new.append(segment_ids[i])\\n idx+=1\\n else:\\n output_tokens.append(tok)\\n segment_ids_new.append(segment_ids[i])\\n idx+=1\\n i+=1\\n if num_masks>max_predictions_per_seq:\\n print ('too many masks')\\n # print (tokens)\\n # print (output_tokens)\\n # print (masked_lm_positions)\\n # print (masked_lm_labels)\\n # abc\\n\\n return (output_tokens, masked_lm_positions, masked_lm_labels, segment_ids_new)\",\n \"def load_mask(self, image_id):\\r\\n mask_path = self.mask_path[self.ids[image_id]]\\r\\n file_pattern = os.path.join(mask_path, \\\"*.png\\\")\\r\\n info = self.image_info[image_id]\\r\\n mask_files = glob.glob(file_pattern)\\r\\n #mask_tmp = cv2.imread(mask_files[0])\\r\\n mask_new = np.zeros([info['height'], info['width'], mask_files.__len__()+1], dtype=np.uint8) # one more for background\\r\\n count = 1\\r\\n mask_total = 0\\r\\n for i in mask_files:\\r\\n mask = cv2.imread(i)\\r\\n mask = mask[:, :, 1] / 255.0\\r\\n #mask = ski_transform.resize(mask, (info['height'], info['width']), mode='reflect')\\r\\n mask_new[:, :, count] = (mask)\\r\\n mask_total = mask_total + (mask>0) * count\\r\\n count = count + 1\\r\\n # Map class names to class IDs.\\r\\n class_ids = np.ones(count) # one more fore background\\r\\n #add Background\\r\\n class_ids[0] = 0; # Background\\r\\n mask_new[:, :, 0] = np.invert(mask_total.astype(np.bool))\\r\\n # End add Background\\r\\n\\r\\n return mask_new, class_ids.astype(np.int32)\",\n \"def action_arr2id(arr):\\n ids = []\\n for a in arr:\\n id = np.where(np.all(actions==a, axis=1))\\n ids.append(id[0][0])\\n return np.array(ids)\",\n \"def get_subject_sequence(img_itk, img_size, img_spacing, img_origin, mask_direction): \\n n_sequence = img_size[-1]\\n img_array = itk.GetArrayFromImage(img_itk)\\n itk_sequences = []\\n for item in range(n_sequence):\\n img_sequence = img_array[item]\\n itk_img_sequence = itk.GetImageFromArray(img_sequence)\\n itk_img_sequence.SetOrigin(img_origin[:3])\\n itk_img_sequence.SetSpacing(img_spacing[:3])\\n itk_img_sequence.SetDirection(mask_direction)\\n itk_sequences.append(itk_img_sequence)\\n \\n return itk_sequences\",\n \"def load_mask(self, image_id):\\n info = self.image_info[image_id]\\n mask_image_path = info['path'].replace(\\\"images\\\", \\\"masks\\\")\\n mask = cv2.imread(mask_image_path)\\n mask = (np.max(mask, axis=2) if len(mask.shape) > 2 else mask).reshape((128,128,1))\\n \\n return mask, np.array([1,])\",\n \"def get_idxes_from_mask(mask):\\n if len(mask) > 1:\\n return torch.nonzero(mask.squeeze(), as_tuple=False).reshape(1, -1)[0]\\n elif len(mask) == 1:\\n return torch.tensor([0], dtype=torch.int64) if mask.sum() == 1 else torch.tensor([], dtype=torch.int64)\\n return torch.tensor([], dtype=torch.int64)\",\n \"def masktoregions(in_mask):\\n regions = []\\n for i in [0,1]: # do the thing for the first and second strands\\n current_strand = in_mask[i].copy().astype(float)\\n current_strand[-1] = np.nan # set final position to np.nan to avoid overlap issues\\n transitions = current_strand - np.roll(current_strand,1)\\n true_start = np.where(transitions == 1)[0]\\n true_end = np.where(transitions == -1)[0] - 1\\n if current_strand[0] == 1: # if starts on True, add True start to front end\\n true_start = np.r_[0,true_start]\\n if in_mask[i][-1] == True: # if ends on True, add True end to back end\\n true_end = np.r_[true_end, len(current_strand)-1]\\n if in_mask[i][-2] == False: # if the one before is False, it's a single point True\\n true_start = np.r_[true_start,len(current_strand)-1]\\n if np.all(in_mask[i][-2:] == [True, False]):\\n true_end = np.r_[true_end, len(current_strand)-2]\\n regions.append(np.asarray([np.zeros(len(true_start))+i,true_start,true_end]).T)\\n out_regions = np.concatenate(regions,axis=0).astype(int)\\n return out_regions\",\n \"def generate_MLmask(self):\\r\\n self.MLmask = np.zeros((self.MLtargetedImg.shape[0], self.MLtargetedImg.shape[1]))\\r\\n \\r\\n if len(self.selected_ML_Index) > 0:\\r\\n for selected_index in self.selected_ML_Index:\\r\\n self.MLmask = np.add(self.MLmask, self.Mask[:,:,selected_index])\\r\\n \\r\\n self.intergrate_into_final_mask()\\r\\n \\r\\n self.add_rois_of_selected()\\r\\n \\r\\n else:\\r\\n self.intergrate_into_final_mask()\",\n \"def build_segment_ids(input_ids): \\n segment_ids = [] \\n for seq in input_ids: \\n segment_id = []\\n id_ = 0\\n for token_id in seq: \\n segment_id.append(id_)\\n # 102 : [SEP]\\n if token_id == 102: \\n id_ +=1 \\n id_ %= 2 \\n segment_ids.append(segment_id)\\n return segment_ids\",\n \"def createMaks(self):\\n mask = np.zeros((self.height, self.width)) # (H, W)\\n center = self.width // 2\\n\\n for lat in range(self.height):\\n count = int(self.counts[lat])\\n # print(lat, count)\\n # print(center - count, center, center + count)\\n mask[lat][center: center + count] = 1\\n mask[lat][center - count: center] = 1\\n\\n return mask # (H, W)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68125015","0.6421516","0.59341574","0.59032476","0.583509","0.5829133","0.5744523","0.5729663","0.5697411","0.56960577","0.5669003","0.5659483","0.56362015","0.5635536","0.5617417","0.5606554","0.5605875","0.5604915","0.5577015","0.5563572","0.55454534","0.55451393","0.5544787","0.55413604","0.5525184","0.5524756","0.5523094","0.55151427","0.5513484","0.5508207","0.54871565","0.5485405","0.54829425","0.5449005","0.54442686","0.5443883","0.54433036","0.54357177","0.54336935","0.54313034","0.5430171","0.54218435","0.5414591","0.541306","0.54076296","0.53888077","0.53854704","0.5383858","0.5379398","0.53775954","0.5375495","0.5371404","0.5355911","0.53536594","0.5352859","0.53454065","0.53442484","0.5326135","0.53256804","0.53236705","0.5321396","0.5316545","0.53157943","0.5314896","0.5312544","0.53058803","0.5304335","0.5301911","0.52997535","0.5295051","0.5294954","0.52947706","0.52925164","0.52893674","0.5288538","0.52881885","0.52736545","0.5270254","0.5268764","0.52662325","0.5264904","0.5263541","0.5263134","0.5262466","0.5261833","0.5257788","0.5253012","0.5250981","0.5247395","0.5247348","0.524534","0.52450323","0.5236873","0.52347606","0.52342147","0.5233438","0.5233035","0.523206","0.5231576","0.52264124"],"string":"[\n \"0.68125015\",\n \"0.6421516\",\n \"0.59341574\",\n \"0.59032476\",\n \"0.583509\",\n \"0.5829133\",\n \"0.5744523\",\n \"0.5729663\",\n \"0.5697411\",\n \"0.56960577\",\n \"0.5669003\",\n \"0.5659483\",\n \"0.56362015\",\n \"0.5635536\",\n \"0.5617417\",\n \"0.5606554\",\n \"0.5605875\",\n \"0.5604915\",\n \"0.5577015\",\n \"0.5563572\",\n \"0.55454534\",\n \"0.55451393\",\n \"0.5544787\",\n \"0.55413604\",\n \"0.5525184\",\n \"0.5524756\",\n \"0.5523094\",\n \"0.55151427\",\n \"0.5513484\",\n \"0.5508207\",\n \"0.54871565\",\n \"0.5485405\",\n \"0.54829425\",\n \"0.5449005\",\n \"0.54442686\",\n \"0.5443883\",\n \"0.54433036\",\n \"0.54357177\",\n \"0.54336935\",\n \"0.54313034\",\n \"0.5430171\",\n \"0.54218435\",\n \"0.5414591\",\n \"0.541306\",\n \"0.54076296\",\n \"0.53888077\",\n \"0.53854704\",\n \"0.5383858\",\n \"0.5379398\",\n \"0.53775954\",\n \"0.5375495\",\n \"0.5371404\",\n \"0.5355911\",\n \"0.53536594\",\n \"0.5352859\",\n \"0.53454065\",\n \"0.53442484\",\n \"0.5326135\",\n \"0.53256804\",\n \"0.53236705\",\n \"0.5321396\",\n \"0.5316545\",\n \"0.53157943\",\n \"0.5314896\",\n \"0.5312544\",\n \"0.53058803\",\n \"0.5304335\",\n \"0.5301911\",\n \"0.52997535\",\n \"0.5295051\",\n \"0.5294954\",\n \"0.52947706\",\n \"0.52925164\",\n \"0.52893674\",\n \"0.5288538\",\n \"0.52881885\",\n \"0.52736545\",\n \"0.5270254\",\n \"0.5268764\",\n \"0.52662325\",\n \"0.5264904\",\n \"0.5263541\",\n \"0.5263134\",\n \"0.5262466\",\n \"0.5261833\",\n \"0.5257788\",\n \"0.5253012\",\n \"0.5250981\",\n \"0.5247395\",\n \"0.5247348\",\n \"0.524534\",\n \"0.52450323\",\n \"0.5236873\",\n \"0.52347606\",\n \"0.52342147\",\n \"0.5233438\",\n \"0.5233035\",\n \"0.523206\",\n \"0.5231576\",\n \"0.52264124\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6793221"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":83168,"cells":{"query":{"kind":"string","value":"Finds the solution of the cubic equation involved in the computation of the proximity operator of the"},"document":{"kind":"string","value":"def forward(ctx,gamma_mu,xtilde,mode_training=True):\n # Device CPU/GPU\n # if device == \"cuda\":\n # dtype = torch.cuda.FloatTensor\n # else :\n dtype = torch.FloatTensor\n #initialize variables\n n,_,nx = xtilde.size()\n x1,x2,x3 = torch.zeros(n,1,1).type(dtype),torch.zeros(n,1,1).type(dtype),torch.zeros(n,1,1).type(dtype) \n crit,crit_compare = torch.zeros(n,1,1).type(dtype),torch.zeros(n,1,1).type(dtype)\n sol = torch.zeros(n,1,nx).type(dtype)\n kappa = torch.zeros(n,1,1).type(dtype)\n xmin = 0\n xmax = 1\n u = 1/nx**2*torch.linspace(1,nx,nx)\n norm_u = torch.norm(u)**2\n uTx = torch.matmul(xtilde,u).view(n,1,1)\n torch_u = u.view(1,1,-1)+torch.zeros(n,1,nx).type(dtype)#broadcast\n torch_one = torch.ones(n,1,1).type(dtype)\n #set coefficients\n a = -(xmin+xmax+uTx)\n b = xmin*xmax + uTx*(xmin+xmax) - 2*gamma_mu*norm_u\n c = gamma_mu*(xmin+xmax)*norm_u - uTx*xmin*xmax\n p = b - (a**2)/3\n q = c - a*b/3 + 2*(a**3)/27\n delta = (p/3)**3 + (q/2)**2\n #three cases depending on the sign of delta\n #########################################################################\n #when delta is positive\n ind = delta>0\n z1 = -q[ind]/2\n z2 = torch.sqrt(delta[ind])\n w = (z1+z2).sign() * torch.pow((z1+z2).abs(),1/3)\n v = (z1-z2).sign() * torch.pow((z1-z2).abs(),1/3) \n x1[ind] = w + v \n x2[ind] = -(w + v)/2 ; #real part of the complex solution\n x3[ind] = -(w + v)/2 ; #real part of the complex solution\n #########################################################################\n #when delta is 0\n ind = delta==0\n x1[ind] = 3 *q[ind] / p[ind]\n x2[ind] = -1.5 * q[ind] / p[ind]\n x3[ind] = -1.5 * q[ind] / p[ind]\n #########################################################################\n #when delta is negative\n ind = delta<0\n cos = (-q[ind]/2) * ((27 / torch.pow(p[ind],3)).abs()).sqrt() \n cos[cos<-1] = 0*cos[cos<-1]-1\n cos[cos>1] = 0*cos[cos>1]+1\n phi = torch.acos(cos)\n tau = 2 * ((p[ind]/3).abs()).sqrt() \n x1[ind] = tau * torch.cos(phi/3) \n x2[ind] = -tau * torch.cos((phi + np.pi)/3)\n x3[ind] = -tau * torch.cos((phi - np.pi)/3)\n #########################################################################\n x1 = x1-a/3\n x2 = x2-a/3\n x3 = x3-a/3\n # when gamma_mu is very small there might be some numerical instabilities\n # in case there are nan values, we set the corresponding pixels equal to 2*xmax\n # these values will be replaced by valid values at least once\n if (x1!=x1).any():\n x1[x1!=x1]=2*xmax\n if (x2!=x2).any():\n x2[x2!=x2]=2*xmax\n if (x3!=x3).any():\n x3[x3!=x3]=2*xmax\n #########################################################################\n #\n sol = xtilde + (x1 - uTx)/norm_u*torch_u\n kappa = x1\n #########################################################################\n #take x1\n p1 = sol\n uTp1 = torch.matmul(p1,u).view(n,1,1)\n ind = (uTp1>xmin)&(uTp1<xmax)\n crit[~ind] = np.inf\n crit[ind] = -(torch.log(uTp1[ind]-xmin)+torch.log(xmax-uTp1[ind]))\n crit = 0.5*torch.norm(p1-xtilde,dim=2).view(n,1,1)**2+gamma_mu*crit \n #########################################################################\n #test x2\n p2 = xtilde + (x2 - uTx)/norm_u*torch_u\n uTp2 = torch.matmul(p2,u).view(n,1,1) \n ind = (uTp2 >xmin)&(uTp2 <xmax)\n crit_compare[~ind] = np.inf\n crit_compare[ind] = -(torch.log(uTp2[ind]-xmin)+torch.log(xmax-uTp2[ind]))\n crit_compare = 0.5*torch.norm(p2-xtilde,dim=2).view(n,1,1)**2+gamma_mu*crit_compare\n # Select solution between p1 and p2\n ind = (crit_compare<=crit) + torch.zeros(n,1,nx)#broadcasting\n ind = ind>0\n sol[ind] = p2[ind]\n kappa[crit_compare<=crit]= x2[crit_compare<=crit]\n crit[crit_compare<=crit] = crit_compare[crit_compare<=crit]\n #########################################################################\n #test x3\n p3 = xtilde + (x3 - uTx)/norm_u*torch_u\n uTp3 = torch.matmul(p3,u).view(n,1,1)\n ind = (uTp3>xmin)&(uTp3<xmax)\n crit_compare[~ind] = np.inf\n crit_compare[ind] = -(torch.log(uTp3[ind]-xmin)+torch.log(xmax-uTp3[ind]))\n crit_compare = 0.5*torch.norm(p3-xtilde,dim=2).view(n,1,1)**2+gamma_mu*crit_compare\n # Select solution between p3 and (p2,p1)\n ind = (crit_compare<=crit)+ torch.zeros(n,1,nx)#broadcasting\n ind = ind>0\n sol[ind] = p3[ind]\n kappa[crit_compare<=crit]= x3[crit_compare<=crit]\n crit[crit_compare<=crit] = crit_compare[crit_compare<=crit]\n #########################################################################\n #test xmin+1e-10\n crit_compare = 0.5*torch.norm(xtilde-xmin-1e-10,dim=2).view(n,1,1)**2-gamma_mu*(\n torch.log(1e-10*torch_one)+torch.log((xmax-xmin-1e-10)*torch_one))\n ind = (crit_compare<=crit)+ torch.zeros(n,1,nx)#broadcasting \n ind = ind>0 \n sol[ind] = 0*sol[ind]+(xmin+1e-10)\n kappa[crit_compare<=crit]= uTx\n crit[crit_compare<=crit] = crit_compare[crit_compare<=crit]\n #########################################################################\n #test xmax-1e-10\n crit_compare = 0.5*torch.norm(xtilde-xmax+1e-10,dim=2).view(n,1,1)**2-gamma_mu*(\n torch.log(1e-10*torch_one)+torch.log((xmax-xmin-1e-10)*torch_one))\n ind = (crit_compare<=crit)+ torch.zeros(n,1,nx)#broadcasting\n ind = ind>0\n sol[ind] = 0*sol[ind]+(xmax-1e-10)\n kappa[crit_compare<=crit]= uTx[crit_compare<=crit]\n crit[crit_compare<=crit] = crit_compare[crit_compare<=crit]\n #########################################################################\n # when gamma_mu is very small and uTx is very close to one of the bounds,\n # the solution of the cubic equation is not very well estimated -> test xtilde\n #denom = (sol-xmin)*(sol-xmax)-2*gamma_mu -(sol-xtilde)*(xmin+xmax-2*sol)\n uTx_ok = (uTx>xmin)&(uTx<xmax)\n crit_compare[~uTx_ok] = np.inf\n crit_compare[uTx_ok] = -(torch.log(xmax-uTx[uTx_ok])+torch.log(uTx[uTx_ok]-xmin))\n crit_compare = gamma_mu*crit_compare\n ind = (crit_compare<crit)+ torch.zeros(n,1,nx)#broadcasting\n ind = ind>0\n sol[ind] = xtilde[ind]\n kappa[crit_compare<=crit]= uTx[crit_compare<=crit]\n \n if mode_training==True:\n ctx.save_for_backward(gamma_mu,kappa,uTx,sol)\n return sol"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def solve(n=5000,C=-6*10**11,a=900,b=3):\n coeffs = np.zeros(n+2)\n coeffs[0] = a-b*n\n coeffs[1] = b*(n+1) - a\n coeffs[-3] = -C\n coeffs[-2] = 2*C - a\n coeffs[-1] = a+b-C\n mp.dps = 27\n roots = polyroots(coeffs)\n for root in roots:\n print root","def exactsolution(x, t, u):\n if 0 <= (x - u*t) and (x - u*t) <= 0.2:\n temp = 1 - (10 * (x - u*t) -1)**2\n else:\n temp = 0\n return temp","def solve(self):","def prob3():\n # Define the nonlinear system, its Jacobian, and the initial guess.\n def f(X):\n x,y,z = X\n return np.array([ -x + y + z,\n 1 + x**3 -y**2 + z**3,\n -2 -x**2 + y**2 + z**2 ])\n def jacobian(X):\n x,y,z = X\n return np.array([ [ -1, 1, 1 ],\n [3*x**2, -2*y, 3*z**2],\n [ -2*x, 2*y, 2*z ] ])\n x0 = np.array([0,0,0])\n\n # Calculate the solution, check that it is a root, and return it.\n sol = opt.root(f, x0, jac=jacobian, method='hybr')\n assert np.allclose(np.zeros_like(sol.x), f(sol.x)), \"FAILURE\"\n return sol.x","def get_sol(self):","def solve():\n # the amount of lattice paths from (0, 0) to (n, k) is (n+k) over n (according to Wikipedia)\n return binomial_coefficient(20 + 20, 20)","def analyticSol (x):\n\treturn x*(1-x);","def func_exact_sol(x, case):\n TB, TA, L, q, k = get_valdict(case, 'TB,TA,L,q,k')\n return ((TB-TA)/L + (q/(2*k)*(L-x)))*x + TA","def test_solve_quadratic_fixed(self):\n iden1 = Identity()\n iden2 = Identity()\n iden3 = Identity()\n iden1.x.val = 4\n iden2.x.val = 5\n iden3.x.val = 6\n iden1.x.name = 'x1'\n iden2.x.name = 'x2'\n iden3.x.name = 'x3'\n iden2.x.fixed = False\n term1 = LeastSquaresTerm(iden1.target, 1, 1)\n term2 = LeastSquaresTerm(iden2.target, 2, 2)\n term3 = LeastSquaresTerm(iden3.target, 3, 3)\n prob = LeastSquaresProblem([term1, term2, term3])\n prob.solve()\n self.assertAlmostEqual(prob.objective, 10)\n self.assertAlmostEqual(iden1.x.val, 4)\n self.assertAlmostEqual(iden2.x.val, 2)\n self.assertAlmostEqual(iden3.x.val, 6)","def solve_i():\r\n x = np.array([ -2.1, -1.45, -1.3, -0.2, 0.1, 0.15, 0.8, 1.1, 1.5, 2.8, 3.8 ])\r\n y = np.array([0.012155, 0.122151, 0.184520, 0.960789, 0.990050, 0.977751,\r\n 0.527292, 0.298197, 0.105399, 3.936690E-4, 5.355348E-7])\r\n # find and plot both interpolations and the oiginal points\r\n plt.figure(1)\r\n cubic_interpol(x,y)\r\n lin_interpol(x,y)\r\n plt.plot(x, y, 'rx', ms = 10, label = 'Points')\r\n # plot settings\r\n plt.title('Cubic & Linear Interpolation Given Points')\r\n plt.xlabel('x',fontsize = 14)\r\n plt.ylabel('y',fontsize = 14)\r\n plt.legend()","def work_dos():\n #potential = 2x**2+x**2y+y**2\n x1,y1 = (2, -3)\n x2,y2 = (-1, 2)\n p1 = (2*(x1**2)) + ((x1**2)*y1) + (y1**2)\n p2 = (2*(x2**2)) + ((x2**2)*y2) + (y2**2)\n sol = p1 - p2\n sol = abs(sol)\n print(f'The vector field F=(4x+2xy,x2+2y) \\n'\n 'along the curve C parametrized by r(t)=(3t−1,−5t+2) \\n '\n f'for 0 ≤ t ≤ 1 is: {sol}')","def monotonic_contractor(self, *args, **kwargs):\n vertices = copy.deepcopy(args[0])\n nrange = len(vertices[0])\n xpts = []\n ypts = []\n for i in range(nrange):\n xpts.append(vertices[0][i].value)\n xpts.append(vertices[1][i].value)\n constraint = copy.deepcopy(args[1])\n \n \n # compute automatic differentiated curvature:\n qxdot = np.dot(xpts,self.localBasis[1,:])\n qxddot = np.dot(xpts,self.localBasis[2,:])\n qydot = np.dot(ypts,self.localBasis[1,:])\n qyddot = np.dot(ypts,self.localBasis[2,:]) \n #computation of doubledots is expanded below\n \n \n ## the all important computation split (need to abstract this kind of thing)\n ##lhs = ((np.sqrt(qxdot*qxdot + qydot*qydot) )**3. )*constraint\n lhs = (np.sqrt(qxdot**2 + qydot**2)**3.) *constraint\n \n # check2 = qxdot*qyddot\n # if check2.width() < 1.e-2:\n # check2.min.value = check2.real.value\n # check2.max.value = check2.real.value\n # t1 = (lhs - check2)/qydot\n \n #\n # qyddot\n #\n check2 = qydot*qxddot\n #if check2.width() < 1.e-2:\n # check2.min.value = check2.real.value\n # check2.max.value = check2.real.value\n if qxdot.contains(0.):\n print 'qxdot = ',qxdot\n print 'qxdot not invertable, implement other logic please'\n else:\n print 'invert qxdot'\n print 'qxdot = ', qxdot\n t1 = (lhs + qydot*qxddot)/(qxdot)#*(qxdot**-1.)\n t1 = t1 & qyddot # go ahead and shrink t1 to qyddot - they are logically equivalent\n total_ans = []\n useful_indices = []\n bad_indices = []\n for i in range(len(ypts)): \n min_ans = 0.\n for j in range(len(ypts)):\n if j==i:\n pass\n else:\n min_ans = (t1 - ypts[j]*float(self.localBasis[2,j])) + min_ans\n if (abs(float(self.localBasis[2,i])) > 0.0):\n min_ans = min_ans/float(self.localBasis[2,i])\n useful_indices.append(i)\n else:\n bad_indices.append(i)\n total_ans.append(min_ans)\n new_ans = vector_AND_(ypts, total_ans)\n for i in useful_indices:\n if not new_ans[i].isempty: # abs( new_ans[i].width() ) > 0.:\n ypts[i] = ypts[i] & new_ans[i]\n \n ## \n ## qxdot\n ##\n \n if qyddot.contains(0.):\n print 'qyddot = ',qyddot\n print 'qyddot not invertable, implement other logic please'\n else:\n print 'invert qyddot'\n print 'qyddot = ',qyddot\n fix = (lhs + qydot*qxddot)/(qyddot)#*(qyddot**-1.)\n fix = fix & qxdot # go ahead and shrink fix to qxdot - they are logically equivalent\n total_ans = []\n useful_indices = []\n bad_indices = []\n \n for i in range(len(xpts)): #contract on x[i]\n min_ans = 0.\n for j in range(len(xpts)): # add up all jth pieces of the dot product except i\n if j==i:\n pass\n else:\n \n min_ans = (fix - xpts[j]*float(self.localBasis[1,j] ) ) + min_ans\n if (abs(float(self.localBasis[1,i]) ) >0.0 ):\n min_ans = min_ans/float(self.localBasis[1,i])\n useful_indices.append(i)\n else:\n bad_indices.append(i)\n total_ans.append(min_ans)\n \n new_ans = vector_AND_(xpts, total_ans)\n for i in useful_indices:\n if not new_ans[i].isempty: # abs( new_ans[i].width() ) > 0.:\n xpts[i] = xpts[i] & new_ans[i]\n \n \n ## switch to the other side\n \n ##\n ## contract on qydot\n ##\n check2 = qxdot*qyddot\n #if check2.width() < 1.e-2:\n # check2.min.value = check2.real.value\n # check2.max.value = check2.real.value\n if qxddot.contains(0.):\n print 'qxddot = ',qxddot\n print 'qxddot not invertable, implement other logic please'\n else:\n print 'invert qxddot'\n print 'qxddot = ',qxddot\n t1 = (lhs - qxdot*qyddot)/(-qxddot)#*(-qxddot**-1)\n t1 = t1 & qydot\n total_ans = []\n useful_indices = []\n bad_indices = []\n for i in range(len(ypts)): \n min_ans = 0.\n for j in range(len(ypts)):\n if j==i:\n pass\n else:\n #print 't1 = ',t1\n #print 'ypts[{}] = {}'.format(i,ypts[i])\n #print 'localbasis[{},{}] = {}'.format(1,i,self.localBasis[1,j])\n min_ans = (t1 - ypts[j]*float(self.localBasis[1,j])) + min_ans\n if (abs(float(self.localBasis[1,i])) > 0.0):\n min_ans = min_ans/float(self.localBasis[1,i])\n useful_indices.append(i)\n else:\n bad_indices.append(i)\n total_ans.append(min_ans)\n \n new_ans = vector_AND_(ypts, total_ans)\n for i in useful_indices:\n if not new_ans[i].isempty: # abs( new_ans[i].width() ) > 0.:\n ypts[i] = ypts[i] & new_ans[i]\n \n ##contract on qxdot\n \n \n #contract on qxddot\n if qydot.contains(0.):\n print 'qydot = ',qxddot\n print 'qydot not invertable, implement other logic please'\n else:\n print 'invert qydot'\n print 'qydot = ',qydot\n fix = (lhs - qxdot*qyddot)/(-qydot)#*(-qydot**-1)\n fix = fix & qxddot # go ahead and shrink t1 to quddot - they are logically equivalent\n total_ans = []\n useful_indices = []\n bad_indices = []\n for i in range(len(xpts)):\n min_ans = 0.\n for j in range(len(xpts)):\n if j==i:\n pass\n else:\n \n min_ans = (fix - xpts[j]*float(self.localBasis[2,j] ) ) + min_ans\n if (abs(float(self.localBasis[2,i]) ) >0.0 ):\n min_ans = min_ans/float(self.localBasis[2,i])\n useful_indices.append(i)\n else:\n bad_indices.append(i)\n total_ans.append(min_ans)\n \n new_ans = vector_AND_(xpts, total_ans)\n for i in useful_indices:\n if not new_ans[i].isempty: # abs( new_ans[i].width() ) > 0.:\n xpts[i] = xpts[i] & new_ans[i]\n \n \n for i in range(nrange):\n vertices[0][i].value = xpts[i]\n vertices[1][i].value = ypts[i]\n \n return vertices","def test_solve_quadratic(self):\n iden1 = Identity()\n iden2 = Identity()\n iden3 = Identity()\n iden1.x.fixed = False\n iden2.x.fixed = False\n iden3.x.fixed = False\n term1 = LeastSquaresTerm(iden1.target, 1, 1)\n term2 = LeastSquaresTerm(iden2.target, 2, 2)\n term3 = LeastSquaresTerm(iden3.target, 3, 3)\n prob = LeastSquaresProblem([term1, term2, term3])\n prob.solve()\n self.assertAlmostEqual(prob.objective, 0)\n self.assertAlmostEqual(iden1.x.val, 1)\n self.assertAlmostEqual(iden2.x.val, 2)\n self.assertAlmostEqual(iden3.x.val, 3)","def solve_part1(input, verbose=False):\n equations = parse(input)\n\n result = []\n for eq in equations:\n result.append(solve_equation_same_precedence(eq, verbose))\n\n if verbose:\n print(f\"results: {result}\")\n\n return sum(result)","def optimizeposition(areas, omegas, x0, x1, z0, z1):\n\n # initial position of each quadpoint is at the center\n # of the edge connecting the midpoint and a corner point\n rhos = 0.5 * ones(4)\n a = 1 / sqrt(3)\n deltarhos = 0.25 * ones(4) # delta for finite differences\n\n while True: # while method has not converged\n # print(\"################## new iteration #############\")\n rhs = f(rhos, omegas, a, x0, x1, z0, z1, areas)\n print(\"##\")\n print(rhs)\n print(rhos)\n if norm(rhs) < 1e-5:\n break\n mat = df(rhos, omegas, a, x0, x1, z0, z1, areas, deltarhos)\n update = solve(mat, rhs)\n\n rhos += update\n # for i in range(4):\n # rhos[i] = max(0,min(1,rhos[i]))\n \"\"\"\n print(\"the norm of the rhs is \")\n print(norm(rhs))\n print(mat)\n print(\"rhs\")\n print(rhs)\n print(update)\n print(\"rhos\")\n print(rhos)\n \"\"\"\n # print(alpha)\n return rhos","def find_coefficients(self):\n self.make_matrix()\n self.coeffs = np.linalg.solve(self.global_matrix,self.global_vector)\n self.coeffs = np.append(self.coeffs, self.D) #Initial condition","def solve_quadratic_equation(a, b, c):\n if a != 0:\n d = b**2 - 4*a*c\n # d = discriminant\n if d > 0:\n first_root = (-b + math.sqrt(d)) / (2 * a)\n second_root = (-b - math.sqrt(d)) / (2 * a)\n return first_root, second_root\n elif d == 0:\n root = -(b / (2 * a))\n return root, None\n elif d < 0:\n return None, None\n else:\n print(\"Variable 'a' can`t be equal 0\")","def sp_solve ( fun , xmin , xmax , C = 0 , args = () ) :\n ##\n if iszero ( C ) :\n return findroot ( fun , xmin , xmax , args = args )\n ##\n func = lambda x , *a : fun(x,*a)-C\n return findroot ( func , xmin , xmax , args = args )","def root_3(a, b, c, d):\n abc = a * b * c\n bbb = b * b * b\n aad = a * a * d\n\n dd = (18. * abc * d - 4. * bbb * d\n + b * b * c * c - 4. * a * c * c * c\n - 27. * aad * d)\n d0 = b * b - 3. * a * c\n\n # second and third cubic unity roots (first is just 1)\n cu2 = -0.5 + 0.86602540378443864676j\n cu3 = -0.5 - 0.86602540378443864676j\n\n if not dd and not d0: # all real roots\n x1 = x2 = x3 = -b / (3. * a)\n elif not dd and d0: # double root, simple root\n x1 = x2 = ((9. * a * d - b * c) / (2. * d0))\n x3 = (4. * abc - 9. * aad - bbb) / (a * d0)\n else:\n d1 = 2. * bbb - 9. * abc\n d1 = d1 + 27. * aad\n\n if not d0: cin = d1 + 0j # inner terms cancel\n else: cin = (d1 - sqrt(-27.0 * a * a * dd)) / 2.\n\n cc = cin ** (1. / 3.)\n p = (-1. / (3. * a))\n\n x1 = p * (b + cc + d0 / cc)\n x2 = p * (b + cu2 * cc + d0 / (cu2 * cc))\n x3 = p * (b + cu3 * cc + d0 / (cu3 * cc))\n\n return x1, x2, x3","def coefficient(self) -> float:\n ...","def solve(a, b, c):\n discriminant = b ** 2 - 4 * a * c\n if discriminant >= 0:\n x1 = (-b + math.sqrt(discriminant)) / 2 / a\n x2 = (-b - math.sqrt(discriminant)) / 2 / a\n else:\n x1 = complex(-b / 2 / a, math.sqrt(-discriminant) / 2 / a)\n x2 = complex(-b / 2 / a, -math.sqrt(-discriminant) / 2 / a)\n return x1, x2","def _solve_scalar_quadratic_equation(z, d):\n a = d.T @ d\n b = 2 * z.T @ d\n c = z.T @ z - 1\n sqrt_discriminant = np.sqrt(b * b - 4 * a * c)\n\n aux = b + np.copysign(sqrt_discriminant, b)\n ta = -aux / (2 * a)\n tb = -2 * c / aux\n\n return sorted([ta, tb])","def test_solver():\n # Choice of nonlinear coefficient\n m = 2\n\n def q(u):\n return (1+u)**m\n\n def Dq(u):\n return m*(1+u)**(m-1)\n\n u_exact = Expression(\n 'pow((pow(2, m+1)-1)*x[0] + 1, 1.0/(m+1)) - 1', m=m)\n linear_solver = 'direct'\n errors = []\n for method in 'alg_Newton', 'pde_Newton':\n for J_comp in 'manual', 'automatic':\n for degree in 1, 2, 3:\n error_prev = -1\n for divisions in [(10, 10), (20, 20), (40, 40)]:\n u = solver(\n q, Dq, f, divisions, degree,\n method, J_comp,\n linear_solver,\n abs_tol_Krylov=1E-10,\n rel_tol_Krylov=1E-10,\n abs_tol_Newton=1E-10,\n rel_tol_Newton=1E-10)\n\n # Find max error\n u_e = interpolate(u_exact, u.function_space())\n import numpy as np\n error = np.abs(u_e.vector().array() -\n u.vector().array()).max()\n # Expect convergence as h**(degree+1)\n if error_prev > 0:\n frac = abs(error - error_prev/2**(degree+1))\n errors.append(frac)\n error_prev = error\n tol = 4E-5\n for error_reduction in errors:\n assert error_reduction < tol, error_reduction","def solve2(a, b, c):\n import gmpy2\n from gmpy2 import mpz\n\n x = (-b + gmpy2.isqrt(mpz(b**2 - 4*a*c))) / (2*a) \n y = (-b - gmpy2.isqrt(mpz(b**2 - 4*a*c))) / (2*a) \n return (x, y)","def calc_cubic(self,mw,A0,A1,A2,A3): \n return (A0 + A1 * mw + A2 * mw**2 + A3 * mw**3)","def solve_quadratic_equation(a,b,c):\r\n delta = b**2 - 4 * a * c\r\n if delta < 0:\r\n raise ValueError(\"No real solution...that shouldn't happen!\")\r\n return (-b + math.sqrt(delta)) / (2*a)","def contractor(self, *args, **kwargs):\n vertices = copy.deepcopy(args[0])\n nrange = len(vertices[0])\n xpts = []\n ypts = []\n for i in range(nrange):\n xpts.append(vertices[0][i].value)\n ypts.append(vertices[1][i].value)\n constraint = copy.deepcopy(args[1])\n \n \n \n \n qxdot,qxddot,qydot,qyddot = self.update_allq(xpts,ypts)\n \n ## the all important computation split (need to abstract this kind of thing)\n ##lhs = (np.sqrt(qxdot*qxdot + qydot*qydot)**3.) *constraint\n lhs = ( ( np.sqrt(qxdot**2 + qydot**2) )**3 )*constraint\n \n # check2 = qxdot*qyddot\n # if check2.width() < 1.e-2:\n # check2.min.value = check2.real.value\n # check2.max.value = check2.real.value\n # t1 = (lhs - check2)/qydot\n \n #\n # qyddot\n #\n check2 = qydot*qxddot\n if check2.width() < 1.e-2 and check2.contains(0.):\n check2.inf = 0.\n check2.sup = 0.\n #if qxdot.contains(0.) and abs(qxdot.min.value)>1.e-6:\n # print 'qxdot = ',qxdot\n # print 'qxdot not invertable, implement other logic please'\n if abs(float(qxdot.inf))<1.e-6:\n qxdot.inf = 1.e-10\n print 'invert qxdot'\n print 'qxdot = ', qxdot\n \n #t1 = (lhs + qydot*qxddot)/(qxdot)\n t1 = (lhs + check2)/(qxdot)\n \n t1 = t1 & qyddot # go ahead and shrink t1 to qyddot - they are logically equivalent\n total_ans = []\n useful_indices = []\n bad_indices = []\n for i in range(len(ypts)): \n min_ans = 0.\n for j in range(len(ypts)):\n if j==i:\n pass\n else:\n min_ans = (ypts[j]*float(self.localBasis[2,j])) + min_ans\n min_ans = t1 - min_ans\n if (abs(float(self.localBasis[2,i])) > 0.0):\n min_ans = min_ans/float(self.localBasis[2,i])\n useful_indices.append(i)\n else:\n bad_indices.append(i)\n total_ans.append(min_ans)\n \n new_ans = vector_AND_(ypts, total_ans)\n for i in useful_indices:\n if new_ans[i].isempty == False: # abs( new_ans[i].width() ) > 0.:\n ypts[i] = ypts[i] & new_ans[i]\n qxdot,qxddot,qydot,qyddot = self.update_allq(xpts,ypts)\n else:\n print 'warning, possible constraint violation, curvature 1'\n \n ## \n ## qxdot\n ##\n check2 = qydot*qxddot\n if check2.width() < 1.e-2 and check2.contains(0.):\n check2.inf = 0.\n check2.sup = 0.\n #if qyddot.contains(0.):\n # print 'qyddot = ',qyddot\n # print 'qyddot not invertable, implement other logic please'\n \n if qyddot.contains(0.) and qyddot.width()<1.e-6:\n qxdot.inf = 0.#1.e-10\n print 'invert qyddot'\n print 'qyddot = ',qyddot\n fix = (lhs + check2)*(1./qyddot)#*(qyddot**-1.)\n fix = fix & qxdot # go ahead and shrink fix to qxdot - they are logically equivalent\n total_ans = []\n useful_indices = []\n bad_indices = []\n \n for i in range(len(xpts)): #contract on x[i]\n min_ans = 0.\n for j in range(len(xpts)): # add up all jth pieces of the dot product except i\n if j==i:\n pass\n else:\n \n min_ans = (xpts[j]*float(self.localBasis[1,j] ) ) + min_ans\n min_ans = fix - min_ans\n if (abs(float(self.localBasis[1,i]) ) >0.0 ):\n min_ans = min_ans/float(self.localBasis[1,i])\n useful_indices.append(i)\n else:\n bad_indices.append(i)\n total_ans.append(min_ans)\n \n new_ans = vector_AND_(xpts, total_ans)\n for i in useful_indices:\n if not new_ans[i].isempty: # abs( new_ans[i].width() ) > 0.:\n xpts[i] = xpts[i] & new_ans[i]\n qxdot,qxddot,qydot,qyddot = self.update_allq(xpts,ypts)\n else:\n print 'warning, possible constraint violation, curvature 2'\n \n \n ## switch to the other side\n \n ##\n ## contract on qydot\n ##\n check2 = qxdot*qyddot\n if check2.width() < 1.e-2 and check2.contains(0.):\n check2.inf = 0.\n check2.sup = 0.\n# if qxddot.contains(0.):\n# print 'qxddot = ',qxddot\n# print 'qxddot not invertable, implement other logic please'\n# qxddot.min.value = 0.\n if qxddot.contains(0.):\n qxddot.inf = 0.\n \n print 'invert qxddot'\n print 'qxddot = ',qxddot\n t1 = (lhs - check2)/(-qxddot)#*(-qxddot**-1)\n t1 = t1 & qydot\n total_ans = []\n useful_indices = []\n bad_indices = []\n for i in range(len(ypts)): \n min_ans = 0.\n for j in range(len(ypts)):\n if j==i:\n pass\n else:\n #print 't1 = ',t1\n #print 'ypts[{}] = {}'.format(i,ypts[i])\n #print 'localbasis[{},{}] = {}'.format(1,i,self.localBasis[1,j])\n min_ans = (ypts[j]*float(self.localBasis[1,j])) + min_ans\n min_ans = t1 - min_ans\n if (abs(float(self.localBasis[1,i])) > 0.0):\n min_ans = min_ans/float(self.localBasis[1,i])\n useful_indices.append(i)\n else:\n bad_indices.append(i)\n total_ans.append(min_ans)\n \n new_ans = vector_AND_(ypts, total_ans)\n for i in useful_indices:\n if not new_ans[i].isempty: # abs( new_ans[i].width() ) > 0.:\n ypts[i] = ypts[i] & new_ans[i]\n else:\n print 'warning, possible constraint violation, curvature 3'\n \n ##contract on qxdot\n \n check2 = qxdot*qyddot\n if check2.width() < 1.e-2 and check2.contains(0.):\n check2.inf = 0.\n check2.sup = 0.\n #contract on qxddot\n# if qydot.contains(0.):\n# print 'qydot = ',qxddot\n# print 'qydot not invertable, implement other logic please'\n if qydot.contains(0.):\n qydot.inf = 0.\n print 'invert qydot'\n print 'qydot = ',qydot\n fix = (lhs - qxdot*qyddot)/(-qydot)#*(-qydot**-1)\n fix = fix & qxddot # go ahead and shrink t1 to quddot - they are logically equivalent\n total_ans = []\n useful_indices = []\n bad_indices = []\n for i in range(len(xpts)):\n min_ans = 0.\n for j in range(len(xpts)):\n if j==i:\n pass\n else:\n min_ans = (xpts[j]*float(self.localBasis[2,j] ) ) + min_ans\n min_ans = fix - min_ans\n if (abs(float(self.localBasis[2,i]) ) >0.0 ):\n min_ans = min_ans/float(self.localBasis[2,i])\n useful_indices.append(i)\n else:\n bad_indices.append(i)\n total_ans.append(min_ans)\n \n new_ans = vector_AND_(xpts, total_ans)\n for i in useful_indices:\n if not new_ans[i].isempty: # abs( new_ans[i].width() ) > 0.:\n xpts[i] = xpts[i] & new_ans[i]\n else:\n print 'warning, possible constraint violation, curvature 4'\n \n for i in range(nrange):\n vertices[0][i].value = xpts[i]\n vertices[1][i].value = ypts[i]\n return vertices","def rewofzs3(x,y):\n\n z=x+y*(1j)\n a=1.0/(2.0*z*z)\n q=(1j)/(z*jnp.sqrt(jnp.pi))*(1.0 + a*(1.0 + a*(3.0 + a*(15.0+a*105.0))))\n return jnp.real(q)","def solve(self):\n ...","def cubic_roots(a0, a1, a2, a3=None):\n\n N = len(a0)\n out = np.full([N, 3], np.nan)\n\n # Calculate the normalized form x^3 + a2 * x^2 + a1 * x + a0 = 0\n b_a = a2 if a3 is None else a2 / a3\n b_a2 = b_a * b_a\n c_a = a1 if a3 is None else a1 / a3\n d_a = a0 if a3 is None else a0 / a3\n\n # Solve the cubic equation\n Q = (3 * c_a - b_a2) / 9\n R = (9 * b_a * c_a - 27 * d_a - 2 * b_a * b_a2) / 54\n Q3 = Q * Q * Q\n D = Q3 + R * R\n b_a_3 = (1.0 / 3.0) * b_a\n\n sel = Q == 0.0\n if np.any(sel):\n o = out[sel, 0]\n\n sel2 = R == 0.0\n if np.any(sel2):\n o[sel2] = -b_a_3[sel][sel2]\n\n if np.any(~sel2):\n o[~sel2] = np.pow(2 * R[sel][~sel2], 1 / 3.0) - b_a_3[sel][~sel2]\n\n out[sel, 0] = o\n\n sel = D <= 0.0\n if np.any(sel):\n # Three real roots\n theta = np.arccos(R[sel] / np.sqrt(-Q3[sel]))\n sqrt_Q = np.sqrt(-Q[sel])\n\n out[sel, 0] = 2 * sqrt_Q * np.cos(theta / 3.0) - b_a_3[sel]\n out[sel, 1] = 2 * sqrt_Q * np.cos((theta + 2 * np.pi) / 3.0) - b_a_3[sel]\n out[sel, 2] = 2 * sqrt_Q * np.cos((theta + 4 * np.pi) / 3.0) - b_a_3[sel]\n\n return out","def get_exact_classical_binary_solution(qubit_operator, offset):\n result = get_classical_solver_result(qubit_operator, offset)\n return result.x","def algorithm_1_1(p, c, t, x):\n\n q = np.array(c, dtype=np.float64)\n\n for k in range(1, p + 1):\n for j in range(0, p - k + 1):\n q[j] = (t[j + k] - x) / (t[j + k] - t[j]) * q[j] + (x - t[j]) / (\n t[j + k] - t[j]) * q[j + 1]\n return q[0]","def solve(self):\n pass","def solve(self):\n pass","def problem():\n for a in range(1, 380):\n for b in range(a):\n if a + b + (a**2 + b**2)**0.5 == 1000:\n return int(a * b * (a**2 + b**2)**0.5)","def solve_part2(input, verbose=False):\n equations = parse(input)\n\n result = []\n for eq in equations:\n result.append(solve_equation_addition_precendence(eq, verbose))\n\n if verbose:\n print(f\"results: {result}\")\n\n return sum(result)","def quartic_potential(x):\n k1=1\n k2=10\n return (k1*x**4)-(k2*x**2)","def solve(self):\n \n raise NotImplementedError(\"not implemented!\")","def solve_quadratic(a, b, c):\n assert a != 0\n d = b * b - 4 * a * c\n if d < 0:\n return []\n elif d == 0:\n return -b / (2 * a)\n else:\n return [\n (-b - math.sqrt(d)) / (2 * a),\n (-b + math.sqrt(d)) / (2 * a)\n ]","def pm3d_formula(x,formula):\n \n if(formula<0):\t\t\n\tx=1.0-x\n\tformula=-formula\n\n if(formula==0): return 0\n elif(formula==1): return 0.5\n elif(formula==2): return 1\n elif(formula==3): return x\n elif(formula==4): return(x * x)\n elif(formula==5): return(x * x * x)\n elif(formula==6): return(x * x * x * x)\n elif(formula==7): return(Numeric.sqrt(x))\n elif(formula==8): return(x**0.25)\n elif(formula==9): return(Numeric.sin(90.0 * x * DEG2RAD))\n elif(formula==10): return(Numeric.cos(90 * x * DEG2RAD))\n elif(formula==11): return(Numeric.fabs(x - 0.5))\n elif(formula==12): return((2 * x - 1) * (2.0 * x - 1))\n elif(formula==13): return(Numeric.sin(180 * x * DEG2RAD))\n elif(formula==14): return(Numeric.fabs(cos(180 * x * DEG2RAD)))\n elif(formula==15): return(Numeric.sin(360 * x * DEG2RAD))\n elif(formula==16): return(Numeric.cos(360 * x * DEG2RAD))\n elif(formula==17): return(Numeric.fabs(Numeric.sin(360 * x * DEG2RAD)))\n elif(formula==18): return(Numeric.fabs(Numeric.cos(360 * x * DEG2RAD)))\n elif(formula==19): return(Numeric.fabs(Numeric.sin(720 * x * DEG2RAD)))\n elif(formula==20): return(Numeric.fabs(Numeric.cos(720 * x * DEG2RAD)))\n elif(formula==21): return(3 * x) # ???????\n elif(formula==22): return(3 * x - 1)\n elif(formula==23): return(3 * x - 2)\n elif(formula==24): return(Numeric.fabs(3 * x - 1))\n elif(formula==25): return(Numeric.fabs(3 * x - 2))\n elif(formula==26): return((1.5 * x - 0.5))\n elif(formula==27): return((1.5 * x - 1))\n elif(formula==28): return(Numeric.fabs(1.5 * x - 0.5))\n elif(formula==29): return(Numeric.fabs(1.5 * x - 1))\n elif(formula==30):\n if (x <= 0.25): return 0.0\n if (x >= 0.57): return 1.0\n\treturn(x / 0.32 - 0.78125)\n elif(formula==31):\n if (x <= 0.42): return 0.0\n if (x >= 0.92): return 1.0\n\treturn(2 * x - 0.84)\n elif(formula==32):\n if (x <= 0.42): return(4*x)\n if (x <= 0.92): return(-2 * x + 1.84)\n return(x / 0.08 - 11.5)\n elif(formula==33): return(Numeric.fabs(2 * x - 0.5))\n elif(formula==34): return(2 * x)\n elif(formula==35): return(2 * x - 0.5)\n elif(formula==36): return(2 * x - 1)\n return(0)","def algorithm_1_2(p, c, x):\n\n q = np.array(c, dtype=np.float64)\n\n for k in range(1, p + 1):\n for j in range(0, p - k + 1):\n q[j] = (1 - x) * q[j] + x * q[j + 1]\n return q[0]","def get_classical_solver_result(qubit_operator, offset):\n qp = QuadraticProgram()\n qp.from_ising(qubit_operator, offset)\n exact = MinimumEigenOptimizer(NumPyMinimumEigensolver())\n return exact.solve(qp)","def reaction_forces(Ca, la, x1, x2, x3, xa, h, d1, d3, theta, P, q, E, I):\r\n \r\n equation_matrix = np.array([[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], \r\n [1, 0, 0, 1, 0, 1, 0, np.sin(theta), 0, 0, 0, 0, (P*np.sin(theta)+q*la*np.cos(theta))], \r\n [0, 1, 0, 0, 1, 0, 1, np.cos(theta), 0, 0, 0, 0, (P*np.cos(theta)-q*la*np.sin(theta))],\r\n \r\n [-(Ca/4-h/2), 0, 0, -(Ca/4-h/2) ,0 , -(Ca/4-h/2), 0, (np.cos(theta)*h/2-np.sin(theta)*Ca/4), 0, 0, 0, 0, (P*np.cos(theta)*h/2*-P*np.sin(theta)*Ca/4)], \r\n [0, (x2-x1), 0, 0, 0, 0, -(x3-x2), (np.cos(theta)*xa/2), 0, 0, 0, 0, (-P*np.cos(theta)*xa/2+q*la*np.sin(theta)*(la/2-x2))], \r\n [-(x2-x1), 0, 0, 0, 0, (x3-x2), 0, -np.sin(theta)*xa/2, 0, 0, 0, 0, (P*np.sin(theta)*xa/2+q*la*np.cos(theta)*(la/2-x2))], \r\n \r\n [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, x1, 1, -q*np.sin(theta)*((x1**4)/24)], \r\n [0, ((x2-x1)**3)/6, 0, 0, 0, 0, 0, ((np.cos(theta))*((xa/2)**3)/6), 0, 0, x2, 1, (-q*np.sin(theta)*((x2**4)/24))], \r\n [0, ((x3-x1)**3)/6, 0, 0, ((x3-x2)**3)/6, 0, 0, ((np.cos(theta))*((x3-x2+xa/2)**3)/6), 0, 0, x3, 1, (-q*np.sin(theta)*((x3**4)/24)+P*(np.cos(theta))*(x3-x2-xa/2)**3/6)], \r\n [0, 0, 0, 0, 0, 0, 0, 0, x1, 1, 0, 0, (-E*I*d1*+q*np.cos(theta)*(x1**4)/24)], \r\n [(((x2-x1)**3)/6), 0, 0, 0, 0, 0, 0, ((-np.sin(theta))*((xa/2)**3)/6), x2, 1, 0, 0, (q*np.cos(theta)*(x2**4)/24)], \r\n [(((x3-x1)**3)/6),0,0,(((x3-x2)**3)/6),0,0,0,((-np.sin(theta))*((x3-x2+xa/2)**3)/6),x3,1,0,0,(-E*I*d3*+q*np.cos(theta)*((x3**4)/24)+P/6*np.sin(theta)*(x3-x2-xa/2)**3)]])\r\n \r\n \r\n unknown_matrix = equation_matrix[:,:-1]\r\n constant_matrix = equation_matrix[:,-1]\r\n \r\n \r\n solution_matrix = np.linalg.solve(unknown_matrix,constant_matrix)\r\n \r\n solution_matrix = solution_matrix/1000\r\n \r\n (R1y, R1z, R2x, R2y, R2z, R3y, R3z, RI, c1, c2, c3, c4) = tuple(solution_matrix)\r\n \r\n print((R1y, R1z, R2x, R2y, R2z, R3y, R3z, RI, c1, c2, c3, c4))","def xcoeff(self):\n a, c, d, b = self.to_ccw()\n p1, q1 = a + b, c + d\n p2, q2 = a + c, b + d\n n = p1 + q1\n\n cov = self.covar()\n\n if n == 0:\n return np.nan\n elif a == n or d == n:\n return 0.5\n elif b == n or c == n:\n return -1.0\n elif cov > 0.0:\n return _div(cov, min(p1 * q2, p2 * q1))\n elif cov < 0.0:\n return _div(cov, min(n * c, n * b))\n else:\n return 0.0","def con_cieq(x,project):\n \n cons = project.con_cieq(x)\n \n if cons: cons = array(cons)\n else: cons = zeros([0])\n \n return -cons","def _solve_explicit(self, initial_conditions):\n coeff = self.a ** 2 * self.tau / self.h ** 2\n current_solution = initial_conditions\n next_solution = np.empty_like(current_solution)\n solutions = []\n\n for t in self.t_grid:\n next_solution[1:-1] = (\n current_solution[1:-1]\n + (current_solution[:-2] - 2 * current_solution[1:-1] + current_solution[2:]) * coeff\n ) + self.rhs(self.x_grid[1:-1], t) * self.tau\n\n # left bc\n if self.left_bc_type == \"DIRICHLET\":\n next_solution[0] = self.left_bc(t)\n elif self.left_bc_type == \"NEUMANN\":\n next_solution[0] = (\n 4 * next_solution[1]\n - next_solution[2]\n - 2 * self.h * self.left_bc(t)\n ) / 3.0\n\n # right bc\n if self.right_bc_type == \"DIRICHLET\":\n next_solution[-1] = self.right_bc(t)\n elif self.right_bc_type == \"NEUMANN\":\n next_solution[-1] = (\n 4 * next_solution[-2]\n - next_solution[-3]\n + 2 * self.h * self.right_bc(t)\n ) / 3.0\n if self.mode == \"VISUALIZATION\":\n solutions.append((t, next_solution.copy()))\n current_solution = next_solution\n if self.mode == \"TEST\":\n # print(\"Result: \", current_solution.tolist())\n # print(\"Right answer: \", self.anl_solution.tolist())\n self._norma(current_solution)\n elif self.mode == \"VISUALIZATION\":\n return solutions","def SolveFcn(self):\n return _hypre.HyprePCG_SolveFcn(self)","def test_cases():\r\n quadratic_roots(1,3,-21)\r\n quadratic_roots(2,-4,-6)\r\n quadratic_roots(1,4,-12)\r\n quadratic_roots(4,12,9)\r\n quadratic_roots(-2,-11,-21)\r\n quadratic_roots(4,1,4)\r\n quadratic_roots(1,1,0)\r\n quadratic_roots(1,0,-16)\r\n quadratic_roots(1,-14,-49)\r\n quadratic_roots(1,10,25)","def _solve(self) -> CasADiArrayType:\n self._solution = minimize(**self.minimize_input)\n return self._solution.x","def solve(self):\n\n if self.degree > 2:\n return \"The polynomial degree is strictly greater than 2, I can't solve.\"\n \n elif self.degree == 0:\n \"\"\"a * X^0 = 0\"\"\" \n a = self.all_terms[0].coefficient\n if a != 0:\n return \"The eqution has no solution\"\n else:\n return \"Every real number is a solution\"\n\n elif self.degree == 1:\n \"\"\"a * X^1 + b * X^0 = 0\"\"\"\n a = self.all_terms[1].coefficient\n b = self.all_terms[0].coefficient\n return formula.linear(a, b)\n\n elif self.degree == 2:\n \"\"\"a * X^2 + b * X^1 + c * X^0 = 0\"\"\"\n a = self.all_terms[2].coefficient\n b = self.all_terms[1].coefficient\n c = self.all_terms[0].coefficient\n discriminant = (b ** 2) - (4 * a * c)\n two_a = 2 * a\n if discriminant == 0:\n return formula.linear(two_a, b)\n else:\n if discriminant > 0:\n return formula.quadratic(two_a, b, discriminant)\n else:\n return formula.quadratic(two_a, b, discriminant, simple=False)","def loevinger_coeff(self):\n a, c, d, b = self.to_ccw()\n p1, q1 = a + b, c + d\n p2, q2 = a + c, b + d\n n = p1 + q1\n\n cov = self.covar()\n\n if n == 0:\n return np.nan\n elif a == n or d == n:\n # only one (diagonal) cell is non-zero\n return 0.5\n elif cov == 0.0:\n return 0.0\n else:\n return _div(cov, min(p1 * q2, p2 * q1))","def test_exact_numerical_solution():\n a = 0.2\n b = 3\n\n def f(t, u):\n return a # + (u - u_exact(t))**5\n\n def u_exact(t):\n \"\"\"Exact u(t) corresponding to f above.\"\"\"\n return a * t + b\n\n u0 = u_exact(0)\n T = 8\n N = 10\n tol = 1E-15\n #t_points = np.linspace(0, T, N)\n t_span = (0, T)\n for solver_class in registered_solver_classes:\n solver = solver_class(f)\n solver.set_initial_condition(u0)\n t, u = solver.solve(t_span, N)\n u_e = u_exact(t)\n max_error = (u_e - u).max()\n msg = f'{solver.__class__.__name__} failed with max_error={max_error}'\n assert max_error < tol, msg","def pointPotential(x,y,q,posx,posy):\n k = 8.99e9\n V = (k * q) / (sqrt(x**2 + (y - sqrt((posx**2 + posy**2)))**2))\n return V","def getExactSoln(phi_ic, c, nt):\n \n dimx = len(phi_ic) \n\n lag = int(c*nt)\n\n # phiExact stores the exact solution phi(x-ut)\n phiExact = np.roll(phi_ic, lag)\n \n #impose periodic boundary condn\n phiExact[dimx-1] = phiExact[0]\n \n return phiExact","def solve_Q(ih, jh):\n # Build A and b\n\n # Solve for c via least squares.\n\n # Form C from c\n\n # Solve for Q and return it.\n return None","def solve(self):\n\n # Assign variables to each quantity being solved.\n r_lookup, lookup, num = {}, {}, 0\n for element in self.elements:\n if is_wire(element) and element is not self.ground:\n lookup[num] = element\n r_lookup[element] = num\n num += 1\n elif not is_cs(element) and element is not self.ground:\n lookup[num] = element\n r_lookup[element] = num\n num += 1\n\n # Set up the linear algebraic equation Ax=b\n A = np.zeros((num, num))\n b = np.zeros(num)\n for row, element in lookup.items():\n if is_wire(element) and element is not self.ground:\n for two_sided in element.attached:\n if is_cs(two_sided):\n if two_sided.pos is element:\n b[row] += -1 * two_sided.current\n else:\n b[row] += two_sided.current\n else:\n if two_sided.pos is element:\n flow = 1\n else:\n flow = -1\n A[row, r_lookup[two_sided]] = flow\n elif is_vs(element):\n check_connected(element)\n if element.pos is not self.ground:\n A[row, r_lookup[element.pos]] = 1\n if element.neg is not self.ground:\n A[row, r_lookup[element.neg]] = -1\n b[row] = element.voltage\n elif is_resistor(element):\n check_connected(element)\n if element.pos is not self.ground:\n A[row, r_lookup[element.pos]] = 1\n if element.neg is not self.ground:\n A[row, r_lookup[element.neg]] = -1\n A[row, r_lookup[element]] = -1 * element.resistance\n\n b = b.reshape((num, 1))\n try:\n x = np.linalg.solve(A, b)\n except np.linalg.LinAlgError:\n raise CircuitError('Insufficient information to solve circuit')\n\n # Assign values to all circuit components\n for i in range(num):\n item = lookup[i]\n if is_wire(item):\n item.potential = x[i, 0]\n elif isinstance(item, DualSided):\n item.current = x[i, 0]\n\n # Mark circuit as solved\n self.been_solved = True","def solve(self) -> jnp.ndarray:\n pass","def run_exact(self):\n self.operator, var_form, opt = self.generate_VQE_args()\n\n exact_eigensolver = ExactEigensolver(self.operator, k=1)\n self.result = exact_eigensolver.run()\n\n solution = self.extract_solution(self.result, True)\n return solution","def coefC(x0,y0,x1,y1):\n return (x1*y0-x0*y1)/(x1-x0)","def inverse_cubic ( a , b , c , d ) :\n\n x0 , f0 = a.x , a.fx\n x1 , f1 = b.x , b.fx\n x2 , f2 = c.x , c.fx\n x3 , f3 = d.x , d.fx\n\n ## switch to inverse parabolic if some function values coincide \n if f0 == f1 or isequal ( f0 , f1 ) : return inverse_parabolic ( a , c , d ) \n if f0 == f2 or isequal ( f0 , f2 ) : return inverse_parabolic ( a , b , d )\n if f0 == f3 or isequal ( f0 , f3 ) : return inverse_parabolic ( a , b , c )\n if f1 == f2 or isequal ( f1 , f2 ) : return inverse_parabolic ( a , b , d ) \n if f1 == f3 or isequal ( f1 , f3 ) : return inverse_parabolic ( a , b , c ) \n if f2 == f3 or isequal ( f2 , f3 ) : return inverse_parabolic ( a , b , c ) \n\n f01 = 1.0 / ( f0 - f1 ) ; f10 = - f01\n f02 = 1.0 / ( f0 - f2 ) ; f20 = - f02\n f03 = 1.0 / ( f0 - f3 ) ; f30 = - f03\n f12 = 1.0 / ( f1 - f2 ) ; f21 = - f12\n f13 = 1.0 / ( f1 - f3 ) ; f31 = - f13\n f23 = 1.0 / ( f2 - f3 ) ; f32 = - f23\n\n xx = -x0 * f1 * f2 * f3 * f01 * f02 * f03 \n xx += -x1 * f0 * f2 * f3 * f10 * f12 * f13 \n xx += -x2 * f0 * f2 * f3 * f20 * f21 * f23 \n xx += -x3 * f0 * f1 * f2 * f30 * f31 * f32\n \n return xx","def l1(P, q):\n\n m, n = P.size\n\n # Solve equivalent LP \n #\n # minimize [0; 1]' * [u; v]\n # subject to [P, -I; -P, -I] * [u; v] <= [q; -q]\n #\n # maximize -[q; -q]' * z \n # subject to [P', -P']*z = 0\n # [-I, -I]*z + 1 = 0 \n # z >= 0 \n \n c = matrix(n*[0.0] + m*[1.0])\n h = matrix([q, -q])\n\n def Fi(x, y, alpha = 1.0, beta = 0.0, trans = 'N'): \n if trans == 'N':\n # y := alpha * [P, -I; -P, -I] * x + beta*y\n u = P*x[:n]\n y[:m] = alpha * ( u - x[n:]) + beta*y[:m]\n y[m:] = alpha * (-u - x[n:]) + beta*y[m:]\n\n else:\n # y := alpha * [P', -P'; -I, -I] * x + beta*y\n y[:n] = alpha * P.T * (x[:m] - x[m:]) + beta*y[:n]\n y[n:] = -alpha * (x[:m] + x[m:]) + beta*y[n:]\n\n\n def Fkkt(W): \n\n # Returns a function f(x, y, z) that solves\n #\n # [ 0 0 P' -P' ] [ x[:n] ] [ bx[:n] ]\n # [ 0 0 -I -I ] [ x[n:] ] [ bx[n:] ]\n # [ P -I -W1^2 0 ] [ z[:m] ] = [ bz[:m] ]\n # [-P -I 0 -W2 ] [ z[m:] ] [ bz[m:] ]\n #\n # On entry bx, bz are stored in x, z.\n # On exit x, z contain the solution, with z scaled (W['di'] .* z is\n # returned instead of z). \n\n d1, d2 = W['d'][:m], W['d'][m:]\n D = 4*(d1**2 + d2**2)**-1\n A = P.T * spdiag(D) * P\n lapack.potrf(A)\n\n def f(x, y, z):\n\n x[:n] += P.T * ( mul( div(d2**2 - d1**2, d1**2 + d2**2), x[n:]) \n + mul( .5*D, z[:m]-z[m:] ) )\n lapack.potrs(A, x)\n\n u = P*x[:n]\n x[n:] = div( x[n:] - div(z[:m], d1**2) - div(z[m:], d2**2) + \n mul(d1**-2 - d2**-2, u), d1**-2 + d2**-2 )\n\n z[:m] = div(u-x[n:]-z[:m], d1)\n z[m:] = div(-u-x[n:]-z[m:], d2)\n\n return f\n\n\n # Initial primal and dual points from least-squares solution.\n\n # uls minimizes ||P*u-q||_2; rls is the LS residual.\n uls = +q\n lapack.gels(+P, uls)\n rls = P*uls[:n] - q \n\n # x0 = [ uls; 1.1*abs(rls) ]; s0 = [q;-q] - [P,-I; -P,-I] * x0\n x0 = matrix( [uls[:n], 1.1*abs(rls)] ) \n s0 = +h\n Fi(x0, s0, alpha=-1, beta=1) \n\n # z0 = [ (1+w)/2; (1-w)/2 ] where w = (.9/||rls||_inf) * rls \n # if rls is nonzero and w = 0 otherwise.\n if max(abs(rls)) > 1e-10: \n w = .9/max(abs(rls)) * rls\n else: \n w = matrix(0.0, (m,1))\n z0 = matrix([.5*(1+w), .5*(1-w)])\n\n dims = {'l': 2*m, 'q': [], 's': []}\n sol = solvers.conelp(c, Fi, h, dims, kktsolver = Fkkt, \n primalstart={'x': x0, 's': s0}, dualstart={'z': z0})\n return sol['x'][:n]","def SolveFcn(self):\n return _hypre.HypreTriSolve_SolveFcn(self)","def FindClosestPointWithinRadius(self, p_float, , p_float_4):\n ...","def calc_C(h, x0, nu_C, W):\n M = len(nu_C)\n C = np.zeros((W, M), dtype=float)\n N = len(h)\n B = np.zeros((2 * N + 2, W))\n x = x0 * np.arange(0, N + 1, dtype=float) / N\n h_ext = np.concatenate(([1.0], h))\n rhs = np.r_[np.ones(N + 1, dtype=float), np.zeros(N + 1, dtype=float)]\n rhs[0] = rhs[0] / np.sqrt(2.0)\n rhs[N] = rhs[N] / np.sqrt(2.0)\n for m, nu_val in enumerate(nu_C):\n for r in range(W):\n k = r - (W / 2) + 1\n B[:N + 1, r] = h_ext * np.cos(2 * np.pi * (k - nu_val) * x)\n B[N + 1:, r] = h_ext * np.sin(2 * np.pi * (k - nu_val) * x)\n B[0, :] = B[0, :] / np.sqrt(2.0)\n B[N, :] = B[N, :] / np.sqrt(2.0)\n B[N + 1, :] = B[N + 1, :] / np.sqrt(2.0)\n B[2 * N + 1, :] = B[2 * N + 1, :] / np.sqrt(2.0)\n q, r = np.linalg.qr(B)\n C[:, m] = solve_triangular(r, np.dot(q.transpose(), rhs))\n # C[:,m] = np.linalg.lstsq(B, rhs)[0]\n return C","def compute(self, *args, **kwargs):\n vertices = args[0]\n xpts = vertices[2] # z plays the 'x' part\n ypts = vertices[0] # x plays the 'y' part\n #zpts = vertices[1]\n #********************************************\n # switcharoo: using z in place of x\n # using x in place of y\n # i.e.\n #\n # y <- x\n # x <- z\n #\n qxdot = np.dot(xpts,self.localBasis[1])\n qxddot = np.dot(xpts,self.localBasis[2])\n qydot = np.dot(ypts,self.localBasis[1])\n qyddot = np.dot(ypts,self.localBasis[2])\n store = (qxdot*qyddot - qydot*qxddot)\n temp = np.sqrt(qxdot**2 + qydot**2)\n if isinstance(temp, ia):\n if temp.inf<=0:\n temp.inf = 0.\n denom = temp*((temp)**2)#**.5## #problem foud with sqrt\n #\n curvature = store/denom#((np.sqrt(qxdot*qxdot + qydot*qydot))**3.)\n return curvature","def iroots(a, b, c):\n discriminant = b*b-4*a*c\n if discriminant == 0:\n return -b/(2*a), None\n else:\n return (-b+isqrt(discriminant))/(2*a), (-b-isqrt(discriminant))/(2*a)","def getCurvature(f,x):\n df = f.derivative(nu=1)(x)\n ddf = f.derivative(nu=2)(x)\n k = ddf/pow(1-df*df,3/2)\n return k, abs(1.0/k)","def F(x):\n soln = x - (1.0/5.0)*math.cos(10.0*x+1.0) \n return soln","def optimal_nc(f, xl: float, xr: float, n: int, tol: float, *params):\n # required local variables to return\n # S : computed value of the integral with required tolerance\n # N : number of steps for S\n # err : estimated error of S\n # iter : number of iterations (steps doubling)\n iter = 1\n N = 200\n h_old = (xr - xl) / (4*N)\n\n s1 = composite_quad(f, xl, xr, N, n, *params)\n N *= 2\n s2 = composite_quad(f, xl, xr, N, n, *params)\n N *= 2\n s3 = composite_quad(f, xl, xr, N, n, *params)\n\n L = 2\n m = aitken(s1, s2, s3, L)\n\n\n # если m далеко от теоретического значения, значит мы находимся в области,\n # где отброшенные величины не малы и нам нужно продолжать делить шаг\n while m > 4.5 or m < 2.5:\n s1 = s2\n s2 = s3\n N *= 2\n s3 = composite_quad(f, xl, xr, N, n, *params)\n m = aitken(s1, s2, s3, L)\n\n # далее предлагаем идти по оптимальному шагу\n coef = 0.95\n h_new = coef * h_old * (tol / np.abs(runge(s2, s3, L, m))) ** (1 / m)\n\n N = int((xr - xl) / h_new) + 1\n\n while iter != MAXITER + 1:\n s1 = s2\n s2 = s3\n\n s3 = composite_quad(f, xl, xr, N, n, *params)\n\n m = aitken(s1, s2, s3, L)\n\n # берём погрешность из метода рунге\n estimate = np.abs(runge(s2, s3, L, m))\n\n if estimate < tol:\n return N, s3, estimate\n\n N *= 2\n iter += 1\n\n print(\"Convergence not reached!\")\n return 0, 0, 10 * tol, -100","def solve_exact(case, nodes = 100):\n L, = get_valdict(case, 'L')\n axis = np.linspace(0, L, nodes)\n ordinat = func_exact_sol(axis, case)\n \n sol_exact = (axis, ordinat)\n \n return sol_exact","def find_x(p, c):\n if p == 0:\n x = int(math.sqrt(c)) + 1\n else:\n x = int(c / (20. * p)) + 1\n while True:\n y = (20 * p + x)*x\n if y <= c:\n return x\n else:\n x -= 1","def _lonely_coefficient(replies):\n return 1/((replies+1)**0.3)","def solve(self):\n\n constrains, bounds = self.init_constraint_list()\n result = minimize(self.objective_function,\n x0=self.init_guess,\n constraints=constrains,\n bounds=bounds,\n options={'disp': False})\n\n return result","def yule_q(self):\n a, c, d, b = self.to_ccw()\n p1, q1 = a + b, c + d\n p2, q2 = a + c, b + d\n n = a + b + c + d\n\n if n == 0:\n return np.nan\n elif p1 == n:\n # c and d are zero\n return _div(a - b, p1)\n elif p2 == n:\n # b and d are zero\n return _div(a - c, p2)\n elif q1 == n:\n # a and b are zero\n return _div(d - c, q1)\n elif q2 == n:\n # a and c are zero\n return _div(d - b, q2)\n\n return _div(self.covar(), a * d + b * c)","def estimateCs(y, inp):\n\treturn 1 -(math.tanh(getK1(inp) - (y/getY90(inp)) / (2 * getD0(inp)) + (y/getY90(inp) - 1/3.0)**3 / (3 * getD0(inp))))**2","def lowerlim(x, y, z, a, b, c):\n if x/a + y/b + z/c > 1:\n B = a + b + c - x - y - z\n C = a*b + a*c + b*c - a*y - a*z - b*x - b*z - c*x - c*y\n D = a*b*c - a*b*z - a*c*y - b*c*x\n r = np.roots([1,B,C,D])\n ll = r[~np.iscomplex(r) & (r>0.)]\n return ll[0].real\n else:\n return 0.","def solve(s):\n \n # Solve 2 eqs. for 'b' in terms of 'a'\n b = lambda a: ( s*a - s*s/2 ) / ( a - s )\n \n for a in range (1, s - 1):\n if b(a).is_integer():\n break\n \n c = s - a - b(a)\n \n return int(a*b(a)*c)","def Es_case_C(z, x, gamma, alp, lamb):\n\n if z == 0 and x == 0 and alp == 0:\n return 0\n \n beta2 = 1-1/gamma**2\n beta = sqrt(beta2)\n \n sin2a = sin(2*alp)\n cos2a = cos(2*alp) \n eta = eta_case_C(z, x, beta2, alp, lamb)\n \n kap = (2*(alp - z) + eta + lamb)/beta # kappa for case C\n #kap = sqrt( lamb**2 + eta**2 + x**2 + 4*(1+x)*sin(alp)**2 + 2*(lamb + eta*(1+x))*sin2a + 2*lamb*eta*cos2a) \n \n N = lamb + sin2a + (eta - beta*kap)*cos2a\n D = kap - beta*(eta + lamb*cos2a + (1+x)*sin2a)\n \n return N/D**3","def calculate_coefficients(self):\n for i in range(0, self.nz):\n zno = i * self.dz\n self.z[0][i] = zno\n plot_eccentricity_error = False\n position = -1\n for j in range(0, self.ntheta):\n # fmt: off\n self.gama[i][j] = j * self.dtheta + (np.pi - self.beta)\n [radius_external, self.xre[i][j], self.yre[i][j]] = \\\n self.external_radius_function(self.gama[i][j])\n [radius_internal, self.xri[i][j], self.yri[i][j]] = \\\n self.internal_radius_function(zno, self.gama[i][j])\n self.re[i][j] = radius_external\n self.ri[i][j] = radius_internal\n\n w = self.omega * self.ri[i][j]\n\n k = (self.re[i][j] ** 2 * (np.log(self.re[i][j]) - 1 / 2) - self.ri[i][j] ** 2 *\n (np.log(self.ri[i][j]) - 1 / 2)) / (self.ri[i][j] ** 2 - self.re[i][j] ** 2)\n\n self.c1[i][j] = (1 / (4 * self.viscosity)) * ((self.re[i][j] ** 2 * np.log(self.re[i][j]) -\n self.ri[i][j] ** 2 * np.log(self.ri[i][j]) +\n (self.re[i][j] ** 2 - self.ri[i][j] ** 2) *\n (k - 1)) - 2 * self.re[i][j] ** 2 * (\n (np.log(self.re[i][j]) + k - 1 / 2) * np.log(\n self.re[i][j] / self.ri[i][j])))\n\n self.c2[i][j] = (- self.ri[i][j] ** 2) / (8 * self.viscosity) * \\\n ((self.re[i][j] ** 2 - self.ri[i][j] ** 2 -\n (self.re[i][j] ** 4 - self.ri[i][j] ** 4) /\n (2 * self.ri[i][j] ** 2)) +\n ((self.re[i][j] ** 2 - self.ri[i][j] ** 2) /\n (self.ri[i][j] ** 2 *\n np.log(self.re[i][j] / self.ri[i][j]))) *\n (self.re[i][j] ** 2 * np.log(self.re[i][j] / self.ri[i][j]) -\n (self.re[i][j] ** 2 - self.ri[i][j] ** 2) / 2))\n\n self.c0w[i][j] = (- w * self.ri[i][j] *\n (np.log(self.re[i][j] / self.ri[i][j]) *\n (1 + (self.ri[i][j] ** 2) / (self.re[i][j] ** 2 - self.ri[i][j] ** 2)) - 1 / 2))\n # fmt: on\n if not plot_eccentricity_error:\n if abs(self.xri[i][j]) > abs(self.xre[i][j]) or abs(\n self.yri[i][j]\n ) > abs(self.yre[i][j]):\n plot_eccentricity_error = True\n position = i\n if plot_eccentricity_error:\n self.plot_eccentricity(position)\n sys.exit(\n \"Error: The given parameters create a rotor that is not inside the stator. \"\n \"Check the plotted figure and fix accordingly.\"\n )","def roots_cubic(f, trig=False):\n if trig:\n a, b, c, d = f.all_coeffs()\n p = (3*a*c - b**2)/(3*a**2)\n q = (2*b**3 - 9*a*b*c + 27*a**2*d)/(27*a**3)\n D = 18*a*b*c*d - 4*b**3*d + b**2*c**2 - 4*a*c**3 - 27*a**2*d**2\n if (D > 0) == True:\n rv = []\n for k in range(3):\n rv.append(2*sqrt(-p/3)*cos(acos(q/p*sqrt(-3/p)*Rational(3, 2))/3 - k*pi*Rational(2, 3)))\n return [i - b/3/a for i in rv]\n\n # a*x**3 + b*x**2 + c*x + d -> x**3 + a*x**2 + b*x + c\n _, a, b, c = f.monic().all_coeffs()\n\n if c is S.Zero:\n x1, x2 = roots([1, a, b], multiple=True)\n return [x1, S.Zero, x2]\n\n # x**3 + a*x**2 + b*x + c -> u**3 + p*u + q\n p = b - a**2/3\n q = c - a*b/3 + 2*a**3/27\n\n pon3 = p/3\n aon3 = a/3\n\n u1 = None\n if p is S.Zero:\n if q is S.Zero:\n return [-aon3]*3\n u1 = -root(q, 3) if q.is_positive else root(-q, 3)\n elif q is S.Zero:\n y1, y2 = roots([1, 0, p], multiple=True)\n return [tmp - aon3 for tmp in [y1, S.Zero, y2]]\n elif q.is_real and q.is_negative:\n u1 = -root(-q/2 + sqrt(q**2/4 + pon3**3), 3)\n\n coeff = I*sqrt(3)/2\n if u1 is None:\n u1 = S.One\n u2 = Rational(-1, 2) + coeff\n u3 = Rational(-1, 2) - coeff\n b, c, d = a, b, c # a, b, c, d = S.One, a, b, c\n D0 = b**2 - 3*c # b**2 - 3*a*c\n D1 = 2*b**3 - 9*b*c + 27*d # 2*b**3 - 9*a*b*c + 27*a**2*d\n C = root((D1 + sqrt(D1**2 - 4*D0**3))/2, 3)\n return [-(b + uk*C + D0/C/uk)/3 for uk in [u1, u2, u3]] # -(b + uk*C + D0/C/uk)/3/a\n\n u2 = u1*(Rational(-1, 2) + coeff)\n u3 = u1*(Rational(-1, 2) - coeff)\n\n if p is S.Zero:\n return [u1 - aon3, u2 - aon3, u3 - aon3]\n\n soln = [\n -u1 + pon3/u1 - aon3,\n -u2 + pon3/u2 - aon3,\n -u3 + pon3/u3 - aon3\n ]\n\n return soln","def solucaoEspacoPontoX(arq,t,x):\n \n parametros = open(arq,'r')\n lista = []\n for linha in parametros:\n valores = linha.split()\n lista.append( valores[1] )\n Ks = float(lista[0]) # Conductibilidade na fase solida\n Kl = float(lista[1]) # Conductibilidade na fase liquida\n Tf = float(lista[2]) # temperatura de mudanca de fase\n Tinf = float(lista[3]) # Temperatura inicial na fase liquida T0\n Tw = float(lista[4]) # Temperatura na fronteira no instante inicial\n L = float(lista[5]) # calor latente\n cs = float(lista[6]) # calor especifico na zona solida\n cl = float(lista[7]) # calor especifico na zona liquida\n cf = float(lista[8]) # calor especifico na zona de mudanca de fase\n p = float(lista[9]) # pho = massa especifica\n parametros.close()\n \n lam = 0.5064 # chute inicial\n xx = x\n lamb = calculaLambda(funcao,lam,Tinf,Tf,Ks,Kl,L,cs,Tw)\n frente = X_espaco(lamb,Ks,t)\n if (frente > xx):\n T = temperaturaZonaSolida_espaco(Tf,Ks,lamb,xx,t,Tw)\n elif (frente < xx):\n T = temperaturaZonaLiquida_espaco(Tinf,Tf,Ks,Kl,lamb,xx,t)\n else:\n T = Tf\n return T","def solve(grid):\n\n return search(grid_values(grid))","def solve(grid):\n\n return search(grid_values(grid))","def potentialSolver3(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def potentialSolver3(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def solve(self):\n raise NotImplementedError(\"This method needs to be implemented.\")","def test_solve_polynomial_cv_1a():\n assert solveset_real(sqrt(x) - 1, x) == FiniteSet(1)\n assert solveset_real(sqrt(x) - 2, x) == FiniteSet(4)\n assert solveset_real(x**Rational(1, 4) - 2, x) == FiniteSet(16)\n assert solveset_real(x**Rational(1, 3) - 3, x) == FiniteSet(27)\n assert solveset_real(x*(x**(S(1) / 3) - 3), x) == \\\n FiniteSet(S(0), S(27))","def cubic_interp(xi,yi):\n\n # check inputs and print error message if not valid:\n\n error_message = \"xi and yi should have type numpy.ndarray\"\n assert (type(xi) is np.ndarray) and (type(yi) is np.ndarray), error_message\n\n error_message = \"xi and yi should have length 3\"\n assert len(xi)==4 and len(yi)==4, error_message\n\n error_message = \"it is not possible to have more than one point in the with the same xi\"\n assert (len(np.unique(xi)) == len(xi)), error_message\n\n # Set up linear system to interpolate through data points:\n\n A = np.array([[1, 1, 1, 1], xi, xi**2, xi**3]).T\n b = yi\n\n c = solve(A,b)\n \n return c","def solve():\n\n s, g, e = make_lattice(21)\n stack = deque([[e]])\n vals = {s: 1}\n max_n = 0\n\n while stack:\n max_n = max(max_n, len(stack))\n n, *p = stack.pop()\n for c in g.get_connected(n):\n if c > n:\n continue\n if c in vals:\n propagate(c, [n] + p, vals)\n else:\n stack.append([c, n] + p)\n return vals[e]","def KPMO(XVal,YVal_State_1,YVal_State_2,YVal_State_3,XVal_Mean_Trans_1,XVal_Mean_Trans_2,XVal_Sig_Trans_1,XVal_Sig_Trans_2,iOpt):\n#\t1. Computations:\n\tTiny=1E-20\n\tP_Trans_1 = fCPD(XVal,XVal_Mean_Trans_1, XVal_Sig_Trans_1) # Transition of kerogen from State #1 to State #2\n\tP_Trans_2 = fCPD(XVal,XVal_Mean_Trans_2, XVal_Sig_Trans_2) # Transition of kerogen from State #2 to State #3\n\tFunVal=0\n\tif(iOpt==0):\n\t\tP_State_1=(1-P_Trans_1)*(1-P_Trans_2)\n\t\tP_State_2=P_Trans_1*(1 - P_Trans_2)\n\t\tP_State_3=1-P_State_1-P_State_2\n\t\tFunVal=(YVal_State_1*P_State_1)+(YVal_State_2*P_State_2)+(YVal_State_3*P_State_3)\n\tif(iOpt==1):\n\t\tFunVal=YVal_State_1+P_Trans_1*YVal_State_2+P_Trans_2*YVal_State_3\n\tif(FunVal==0):\n\t\tFunVal=Tiny\n\treturn FunVal","def solve(self):\n start = datetime.now()\n f = self.function\n while not self.converged():\n self.history.append(self.vertices)\n\n #step 1: sort\n self.order_vertices()\n\n #step 3: reflect\n reflected = self.get_reflected_point()\n if f(*self.vertices[0]) < f(*reflected) < f(*self.vertices[-1]):\n self.reflect()\n continue\n\n #step 4: expand\n if self.reflected_is_best():\n expanded = self.get_expanded_point()\n if f(*expanded) < f(*reflected):\n self.expand()\n else:\n self.reflect()\n continue\n\n #step 5: contract\n contracted = self.get_contracted_point()\n if f(*contracted) < f(*self.vertices[-1]):\n self.contract()\n continue\n\n #step 6: shrink\n self.shrink()\n print(\"optimization took {0}\".format(datetime.now()-start))\n return self.history, self.cache.history","def test_solve_polynomial_cv_1a():\n assert solveset_real(sqrt(x) - 1, x) == FiniteSet(1)\n assert solveset_real(sqrt(x) - 2, x) == FiniteSet(4)\n assert solveset_real(x**Rational(1, 4) - 2, x) == FiniteSet(16)\n assert solveset_real(x**Rational(1, 3) - 3, x) == FiniteSet(27)\n assert solveset_real(x*(x**(S.One / 3) - 3), x) == \\\n FiniteSet(S.Zero, S(27))","def find_root(function, point_a, point_b, step, tol, max_iterations, \n show_process = False):\n left_point , right_point = search_interval_3d(function, point_a, point_b, \n step, tol, max_iterations,\n show_process)\n \n point_where_zero = bisection_3d(function, left_point, right_point, tol, \n max_iterations, show_process)\n \n return point_where_zero","def solve(self):\n\t\t# row and column to control the selected corner\n\t\tcurrent_positions = [0, 0]\n\t\tmax_row = self.result_index[self.__ROW_INDEX]-1\n\t\tmax_col = self.result_index[self.__COLUMN_INDEX]-1\n\t\twhile self.matrix[max_row][max_col] != 0:\n\t\t\tcurrent_row = current_positions[self.__ROW_INDEX]\n\t\t\tcurrent_column = current_positions[self.__COLUMN_INDEX]\n\t\t\tmultiplier_selected = self.get_multiplier_with_index(current_row, current_column)\n\t\t\tactual_weight = self.matrix[current_row][current_column]\n\t\t\tactual_result_weight = multiplier_selected[1]\n\t\t\tself.resulting_matrix[current_row][current_column] = actual_weight * actual_result_weight\n\t\t\tself.matrix[max_row][max_col] -= actual_result_weight\n\t\t\tself.matrix[current_row][max_col] -= actual_result_weight\n\t\t\tself.matrix[max_row][current_column] -= actual_result_weight\n\t\t\tcurrent_positions[multiplier_selected[0]] += 1","def _solve(self, mu=None):\n pass","def test_inv_sphere_v3_root_find(self):\n import itertools\n\n for k in (0, -1, 1, 1.75, 0.325, 1/7, -1.75, -0.325, -1/7):\n s = space(fake_curvature=k) \n for m in itertools.chain(\n range(30),\n range(31,3000,100),\n map((1).__truediv__, range(3, 30, 2)),\n ):\n r = s.inv_sphere_v3(m)\n self.assertTrue(r >= 0)\n v = s.sphere_v3(r)\n self.assertTrue(isclose(\n m,\n v\n ))","def solve(grid):\n return search(grid_values(grid))","def solve(grid):\n return search(grid_values(grid))","def evaluate_objective(x):\n\n x_points_cartesian = x_to_cartesian(x)\n hull = ConvexHull(x_points_cartesian)\n\n # Return the negative value because the optimization is a minimization\n return -hull.volume","def RepulsionForceFromObstacle(q,q_oi):\r\n d_i = CalculateDistance(q,q_oi) # Distance to the obstacle\r\n if (d_i < d_0): # Point within obstacle influence\r\n F_oi = k_o * (1/d_i - 1/d_0) /d_i**2 \r\n if (F_oi > F_rep_MaxValue): # F_rep won't exceed set constant\r\n return F_rep_MaxValue\r\n else: # Point without obstacle influence\r\n F_oi = 0\r\n return F_oi","def rochelobe(q):\n return 0.49*q**(2./3)/(0.6*q**(2./3) + log(1+q**(1./3)))"],"string":"[\n \"def solve(n=5000,C=-6*10**11,a=900,b=3):\\n coeffs = np.zeros(n+2)\\n coeffs[0] = a-b*n\\n coeffs[1] = b*(n+1) - a\\n coeffs[-3] = -C\\n coeffs[-2] = 2*C - a\\n coeffs[-1] = a+b-C\\n mp.dps = 27\\n roots = polyroots(coeffs)\\n for root in roots:\\n print root\",\n \"def exactsolution(x, t, u):\\n if 0 <= (x - u*t) and (x - u*t) <= 0.2:\\n temp = 1 - (10 * (x - u*t) -1)**2\\n else:\\n temp = 0\\n return temp\",\n \"def solve(self):\",\n \"def prob3():\\n # Define the nonlinear system, its Jacobian, and the initial guess.\\n def f(X):\\n x,y,z = X\\n return np.array([ -x + y + z,\\n 1 + x**3 -y**2 + z**3,\\n -2 -x**2 + y**2 + z**2 ])\\n def jacobian(X):\\n x,y,z = X\\n return np.array([ [ -1, 1, 1 ],\\n [3*x**2, -2*y, 3*z**2],\\n [ -2*x, 2*y, 2*z ] ])\\n x0 = np.array([0,0,0])\\n\\n # Calculate the solution, check that it is a root, and return it.\\n sol = opt.root(f, x0, jac=jacobian, method='hybr')\\n assert np.allclose(np.zeros_like(sol.x), f(sol.x)), \\\"FAILURE\\\"\\n return sol.x\",\n \"def get_sol(self):\",\n \"def solve():\\n # the amount of lattice paths from (0, 0) to (n, k) is (n+k) over n (according to Wikipedia)\\n return binomial_coefficient(20 + 20, 20)\",\n \"def analyticSol (x):\\n\\treturn x*(1-x);\",\n \"def func_exact_sol(x, case):\\n TB, TA, L, q, k = get_valdict(case, 'TB,TA,L,q,k')\\n return ((TB-TA)/L + (q/(2*k)*(L-x)))*x + TA\",\n \"def test_solve_quadratic_fixed(self):\\n iden1 = Identity()\\n iden2 = Identity()\\n iden3 = Identity()\\n iden1.x.val = 4\\n iden2.x.val = 5\\n iden3.x.val = 6\\n iden1.x.name = 'x1'\\n iden2.x.name = 'x2'\\n iden3.x.name = 'x3'\\n iden2.x.fixed = False\\n term1 = LeastSquaresTerm(iden1.target, 1, 1)\\n term2 = LeastSquaresTerm(iden2.target, 2, 2)\\n term3 = LeastSquaresTerm(iden3.target, 3, 3)\\n prob = LeastSquaresProblem([term1, term2, term3])\\n prob.solve()\\n self.assertAlmostEqual(prob.objective, 10)\\n self.assertAlmostEqual(iden1.x.val, 4)\\n self.assertAlmostEqual(iden2.x.val, 2)\\n self.assertAlmostEqual(iden3.x.val, 6)\",\n \"def solve_i():\\r\\n x = np.array([ -2.1, -1.45, -1.3, -0.2, 0.1, 0.15, 0.8, 1.1, 1.5, 2.8, 3.8 ])\\r\\n y = np.array([0.012155, 0.122151, 0.184520, 0.960789, 0.990050, 0.977751,\\r\\n 0.527292, 0.298197, 0.105399, 3.936690E-4, 5.355348E-7])\\r\\n # find and plot both interpolations and the oiginal points\\r\\n plt.figure(1)\\r\\n cubic_interpol(x,y)\\r\\n lin_interpol(x,y)\\r\\n plt.plot(x, y, 'rx', ms = 10, label = 'Points')\\r\\n # plot settings\\r\\n plt.title('Cubic & Linear Interpolation Given Points')\\r\\n plt.xlabel('x',fontsize = 14)\\r\\n plt.ylabel('y',fontsize = 14)\\r\\n plt.legend()\",\n \"def work_dos():\\n #potential = 2x**2+x**2y+y**2\\n x1,y1 = (2, -3)\\n x2,y2 = (-1, 2)\\n p1 = (2*(x1**2)) + ((x1**2)*y1) + (y1**2)\\n p2 = (2*(x2**2)) + ((x2**2)*y2) + (y2**2)\\n sol = p1 - p2\\n sol = abs(sol)\\n print(f'The vector field F=(4x+2xy,x2+2y) \\\\n'\\n 'along the curve C parametrized by r(t)=(3t−1,−5t+2) \\\\n '\\n f'for 0 ≤ t ≤ 1 is: {sol}')\",\n \"def monotonic_contractor(self, *args, **kwargs):\\n vertices = copy.deepcopy(args[0])\\n nrange = len(vertices[0])\\n xpts = []\\n ypts = []\\n for i in range(nrange):\\n xpts.append(vertices[0][i].value)\\n xpts.append(vertices[1][i].value)\\n constraint = copy.deepcopy(args[1])\\n \\n \\n # compute automatic differentiated curvature:\\n qxdot = np.dot(xpts,self.localBasis[1,:])\\n qxddot = np.dot(xpts,self.localBasis[2,:])\\n qydot = np.dot(ypts,self.localBasis[1,:])\\n qyddot = np.dot(ypts,self.localBasis[2,:]) \\n #computation of doubledots is expanded below\\n \\n \\n ## the all important computation split (need to abstract this kind of thing)\\n ##lhs = ((np.sqrt(qxdot*qxdot + qydot*qydot) )**3. )*constraint\\n lhs = (np.sqrt(qxdot**2 + qydot**2)**3.) *constraint\\n \\n # check2 = qxdot*qyddot\\n # if check2.width() < 1.e-2:\\n # check2.min.value = check2.real.value\\n # check2.max.value = check2.real.value\\n # t1 = (lhs - check2)/qydot\\n \\n #\\n # qyddot\\n #\\n check2 = qydot*qxddot\\n #if check2.width() < 1.e-2:\\n # check2.min.value = check2.real.value\\n # check2.max.value = check2.real.value\\n if qxdot.contains(0.):\\n print 'qxdot = ',qxdot\\n print 'qxdot not invertable, implement other logic please'\\n else:\\n print 'invert qxdot'\\n print 'qxdot = ', qxdot\\n t1 = (lhs + qydot*qxddot)/(qxdot)#*(qxdot**-1.)\\n t1 = t1 & qyddot # go ahead and shrink t1 to qyddot - they are logically equivalent\\n total_ans = []\\n useful_indices = []\\n bad_indices = []\\n for i in range(len(ypts)): \\n min_ans = 0.\\n for j in range(len(ypts)):\\n if j==i:\\n pass\\n else:\\n min_ans = (t1 - ypts[j]*float(self.localBasis[2,j])) + min_ans\\n if (abs(float(self.localBasis[2,i])) > 0.0):\\n min_ans = min_ans/float(self.localBasis[2,i])\\n useful_indices.append(i)\\n else:\\n bad_indices.append(i)\\n total_ans.append(min_ans)\\n new_ans = vector_AND_(ypts, total_ans)\\n for i in useful_indices:\\n if not new_ans[i].isempty: # abs( new_ans[i].width() ) > 0.:\\n ypts[i] = ypts[i] & new_ans[i]\\n \\n ## \\n ## qxdot\\n ##\\n \\n if qyddot.contains(0.):\\n print 'qyddot = ',qyddot\\n print 'qyddot not invertable, implement other logic please'\\n else:\\n print 'invert qyddot'\\n print 'qyddot = ',qyddot\\n fix = (lhs + qydot*qxddot)/(qyddot)#*(qyddot**-1.)\\n fix = fix & qxdot # go ahead and shrink fix to qxdot - they are logically equivalent\\n total_ans = []\\n useful_indices = []\\n bad_indices = []\\n \\n for i in range(len(xpts)): #contract on x[i]\\n min_ans = 0.\\n for j in range(len(xpts)): # add up all jth pieces of the dot product except i\\n if j==i:\\n pass\\n else:\\n \\n min_ans = (fix - xpts[j]*float(self.localBasis[1,j] ) ) + min_ans\\n if (abs(float(self.localBasis[1,i]) ) >0.0 ):\\n min_ans = min_ans/float(self.localBasis[1,i])\\n useful_indices.append(i)\\n else:\\n bad_indices.append(i)\\n total_ans.append(min_ans)\\n \\n new_ans = vector_AND_(xpts, total_ans)\\n for i in useful_indices:\\n if not new_ans[i].isempty: # abs( new_ans[i].width() ) > 0.:\\n xpts[i] = xpts[i] & new_ans[i]\\n \\n \\n ## switch to the other side\\n \\n ##\\n ## contract on qydot\\n ##\\n check2 = qxdot*qyddot\\n #if check2.width() < 1.e-2:\\n # check2.min.value = check2.real.value\\n # check2.max.value = check2.real.value\\n if qxddot.contains(0.):\\n print 'qxddot = ',qxddot\\n print 'qxddot not invertable, implement other logic please'\\n else:\\n print 'invert qxddot'\\n print 'qxddot = ',qxddot\\n t1 = (lhs - qxdot*qyddot)/(-qxddot)#*(-qxddot**-1)\\n t1 = t1 & qydot\\n total_ans = []\\n useful_indices = []\\n bad_indices = []\\n for i in range(len(ypts)): \\n min_ans = 0.\\n for j in range(len(ypts)):\\n if j==i:\\n pass\\n else:\\n #print 't1 = ',t1\\n #print 'ypts[{}] = {}'.format(i,ypts[i])\\n #print 'localbasis[{},{}] = {}'.format(1,i,self.localBasis[1,j])\\n min_ans = (t1 - ypts[j]*float(self.localBasis[1,j])) + min_ans\\n if (abs(float(self.localBasis[1,i])) > 0.0):\\n min_ans = min_ans/float(self.localBasis[1,i])\\n useful_indices.append(i)\\n else:\\n bad_indices.append(i)\\n total_ans.append(min_ans)\\n \\n new_ans = vector_AND_(ypts, total_ans)\\n for i in useful_indices:\\n if not new_ans[i].isempty: # abs( new_ans[i].width() ) > 0.:\\n ypts[i] = ypts[i] & new_ans[i]\\n \\n ##contract on qxdot\\n \\n \\n #contract on qxddot\\n if qydot.contains(0.):\\n print 'qydot = ',qxddot\\n print 'qydot not invertable, implement other logic please'\\n else:\\n print 'invert qydot'\\n print 'qydot = ',qydot\\n fix = (lhs - qxdot*qyddot)/(-qydot)#*(-qydot**-1)\\n fix = fix & qxddot # go ahead and shrink t1 to quddot - they are logically equivalent\\n total_ans = []\\n useful_indices = []\\n bad_indices = []\\n for i in range(len(xpts)):\\n min_ans = 0.\\n for j in range(len(xpts)):\\n if j==i:\\n pass\\n else:\\n \\n min_ans = (fix - xpts[j]*float(self.localBasis[2,j] ) ) + min_ans\\n if (abs(float(self.localBasis[2,i]) ) >0.0 ):\\n min_ans = min_ans/float(self.localBasis[2,i])\\n useful_indices.append(i)\\n else:\\n bad_indices.append(i)\\n total_ans.append(min_ans)\\n \\n new_ans = vector_AND_(xpts, total_ans)\\n for i in useful_indices:\\n if not new_ans[i].isempty: # abs( new_ans[i].width() ) > 0.:\\n xpts[i] = xpts[i] & new_ans[i]\\n \\n \\n for i in range(nrange):\\n vertices[0][i].value = xpts[i]\\n vertices[1][i].value = ypts[i]\\n \\n return vertices\",\n \"def test_solve_quadratic(self):\\n iden1 = Identity()\\n iden2 = Identity()\\n iden3 = Identity()\\n iden1.x.fixed = False\\n iden2.x.fixed = False\\n iden3.x.fixed = False\\n term1 = LeastSquaresTerm(iden1.target, 1, 1)\\n term2 = LeastSquaresTerm(iden2.target, 2, 2)\\n term3 = LeastSquaresTerm(iden3.target, 3, 3)\\n prob = LeastSquaresProblem([term1, term2, term3])\\n prob.solve()\\n self.assertAlmostEqual(prob.objective, 0)\\n self.assertAlmostEqual(iden1.x.val, 1)\\n self.assertAlmostEqual(iden2.x.val, 2)\\n self.assertAlmostEqual(iden3.x.val, 3)\",\n \"def solve_part1(input, verbose=False):\\n equations = parse(input)\\n\\n result = []\\n for eq in equations:\\n result.append(solve_equation_same_precedence(eq, verbose))\\n\\n if verbose:\\n print(f\\\"results: {result}\\\")\\n\\n return sum(result)\",\n \"def optimizeposition(areas, omegas, x0, x1, z0, z1):\\n\\n # initial position of each quadpoint is at the center\\n # of the edge connecting the midpoint and a corner point\\n rhos = 0.5 * ones(4)\\n a = 1 / sqrt(3)\\n deltarhos = 0.25 * ones(4) # delta for finite differences\\n\\n while True: # while method has not converged\\n # print(\\\"################## new iteration #############\\\")\\n rhs = f(rhos, omegas, a, x0, x1, z0, z1, areas)\\n print(\\\"##\\\")\\n print(rhs)\\n print(rhos)\\n if norm(rhs) < 1e-5:\\n break\\n mat = df(rhos, omegas, a, x0, x1, z0, z1, areas, deltarhos)\\n update = solve(mat, rhs)\\n\\n rhos += update\\n # for i in range(4):\\n # rhos[i] = max(0,min(1,rhos[i]))\\n \\\"\\\"\\\"\\n print(\\\"the norm of the rhs is \\\")\\n print(norm(rhs))\\n print(mat)\\n print(\\\"rhs\\\")\\n print(rhs)\\n print(update)\\n print(\\\"rhos\\\")\\n print(rhos)\\n \\\"\\\"\\\"\\n # print(alpha)\\n return rhos\",\n \"def find_coefficients(self):\\n self.make_matrix()\\n self.coeffs = np.linalg.solve(self.global_matrix,self.global_vector)\\n self.coeffs = np.append(self.coeffs, self.D) #Initial condition\",\n \"def solve_quadratic_equation(a, b, c):\\n if a != 0:\\n d = b**2 - 4*a*c\\n # d = discriminant\\n if d > 0:\\n first_root = (-b + math.sqrt(d)) / (2 * a)\\n second_root = (-b - math.sqrt(d)) / (2 * a)\\n return first_root, second_root\\n elif d == 0:\\n root = -(b / (2 * a))\\n return root, None\\n elif d < 0:\\n return None, None\\n else:\\n print(\\\"Variable 'a' can`t be equal 0\\\")\",\n \"def sp_solve ( fun , xmin , xmax , C = 0 , args = () ) :\\n ##\\n if iszero ( C ) :\\n return findroot ( fun , xmin , xmax , args = args )\\n ##\\n func = lambda x , *a : fun(x,*a)-C\\n return findroot ( func , xmin , xmax , args = args )\",\n \"def root_3(a, b, c, d):\\n abc = a * b * c\\n bbb = b * b * b\\n aad = a * a * d\\n\\n dd = (18. * abc * d - 4. * bbb * d\\n + b * b * c * c - 4. * a * c * c * c\\n - 27. * aad * d)\\n d0 = b * b - 3. * a * c\\n\\n # second and third cubic unity roots (first is just 1)\\n cu2 = -0.5 + 0.86602540378443864676j\\n cu3 = -0.5 - 0.86602540378443864676j\\n\\n if not dd and not d0: # all real roots\\n x1 = x2 = x3 = -b / (3. * a)\\n elif not dd and d0: # double root, simple root\\n x1 = x2 = ((9. * a * d - b * c) / (2. * d0))\\n x3 = (4. * abc - 9. * aad - bbb) / (a * d0)\\n else:\\n d1 = 2. * bbb - 9. * abc\\n d1 = d1 + 27. * aad\\n\\n if not d0: cin = d1 + 0j # inner terms cancel\\n else: cin = (d1 - sqrt(-27.0 * a * a * dd)) / 2.\\n\\n cc = cin ** (1. / 3.)\\n p = (-1. / (3. * a))\\n\\n x1 = p * (b + cc + d0 / cc)\\n x2 = p * (b + cu2 * cc + d0 / (cu2 * cc))\\n x3 = p * (b + cu3 * cc + d0 / (cu3 * cc))\\n\\n return x1, x2, x3\",\n \"def coefficient(self) -> float:\\n ...\",\n \"def solve(a, b, c):\\n discriminant = b ** 2 - 4 * a * c\\n if discriminant >= 0:\\n x1 = (-b + math.sqrt(discriminant)) / 2 / a\\n x2 = (-b - math.sqrt(discriminant)) / 2 / a\\n else:\\n x1 = complex(-b / 2 / a, math.sqrt(-discriminant) / 2 / a)\\n x2 = complex(-b / 2 / a, -math.sqrt(-discriminant) / 2 / a)\\n return x1, x2\",\n \"def _solve_scalar_quadratic_equation(z, d):\\n a = d.T @ d\\n b = 2 * z.T @ d\\n c = z.T @ z - 1\\n sqrt_discriminant = np.sqrt(b * b - 4 * a * c)\\n\\n aux = b + np.copysign(sqrt_discriminant, b)\\n ta = -aux / (2 * a)\\n tb = -2 * c / aux\\n\\n return sorted([ta, tb])\",\n \"def test_solver():\\n # Choice of nonlinear coefficient\\n m = 2\\n\\n def q(u):\\n return (1+u)**m\\n\\n def Dq(u):\\n return m*(1+u)**(m-1)\\n\\n u_exact = Expression(\\n 'pow((pow(2, m+1)-1)*x[0] + 1, 1.0/(m+1)) - 1', m=m)\\n linear_solver = 'direct'\\n errors = []\\n for method in 'alg_Newton', 'pde_Newton':\\n for J_comp in 'manual', 'automatic':\\n for degree in 1, 2, 3:\\n error_prev = -1\\n for divisions in [(10, 10), (20, 20), (40, 40)]:\\n u = solver(\\n q, Dq, f, divisions, degree,\\n method, J_comp,\\n linear_solver,\\n abs_tol_Krylov=1E-10,\\n rel_tol_Krylov=1E-10,\\n abs_tol_Newton=1E-10,\\n rel_tol_Newton=1E-10)\\n\\n # Find max error\\n u_e = interpolate(u_exact, u.function_space())\\n import numpy as np\\n error = np.abs(u_e.vector().array() -\\n u.vector().array()).max()\\n # Expect convergence as h**(degree+1)\\n if error_prev > 0:\\n frac = abs(error - error_prev/2**(degree+1))\\n errors.append(frac)\\n error_prev = error\\n tol = 4E-5\\n for error_reduction in errors:\\n assert error_reduction < tol, error_reduction\",\n \"def solve2(a, b, c):\\n import gmpy2\\n from gmpy2 import mpz\\n\\n x = (-b + gmpy2.isqrt(mpz(b**2 - 4*a*c))) / (2*a) \\n y = (-b - gmpy2.isqrt(mpz(b**2 - 4*a*c))) / (2*a) \\n return (x, y)\",\n \"def calc_cubic(self,mw,A0,A1,A2,A3): \\n return (A0 + A1 * mw + A2 * mw**2 + A3 * mw**3)\",\n \"def solve_quadratic_equation(a,b,c):\\r\\n delta = b**2 - 4 * a * c\\r\\n if delta < 0:\\r\\n raise ValueError(\\\"No real solution...that shouldn't happen!\\\")\\r\\n return (-b + math.sqrt(delta)) / (2*a)\",\n \"def contractor(self, *args, **kwargs):\\n vertices = copy.deepcopy(args[0])\\n nrange = len(vertices[0])\\n xpts = []\\n ypts = []\\n for i in range(nrange):\\n xpts.append(vertices[0][i].value)\\n ypts.append(vertices[1][i].value)\\n constraint = copy.deepcopy(args[1])\\n \\n \\n \\n \\n qxdot,qxddot,qydot,qyddot = self.update_allq(xpts,ypts)\\n \\n ## the all important computation split (need to abstract this kind of thing)\\n ##lhs = (np.sqrt(qxdot*qxdot + qydot*qydot)**3.) *constraint\\n lhs = ( ( np.sqrt(qxdot**2 + qydot**2) )**3 )*constraint\\n \\n # check2 = qxdot*qyddot\\n # if check2.width() < 1.e-2:\\n # check2.min.value = check2.real.value\\n # check2.max.value = check2.real.value\\n # t1 = (lhs - check2)/qydot\\n \\n #\\n # qyddot\\n #\\n check2 = qydot*qxddot\\n if check2.width() < 1.e-2 and check2.contains(0.):\\n check2.inf = 0.\\n check2.sup = 0.\\n #if qxdot.contains(0.) and abs(qxdot.min.value)>1.e-6:\\n # print 'qxdot = ',qxdot\\n # print 'qxdot not invertable, implement other logic please'\\n if abs(float(qxdot.inf))<1.e-6:\\n qxdot.inf = 1.e-10\\n print 'invert qxdot'\\n print 'qxdot = ', qxdot\\n \\n #t1 = (lhs + qydot*qxddot)/(qxdot)\\n t1 = (lhs + check2)/(qxdot)\\n \\n t1 = t1 & qyddot # go ahead and shrink t1 to qyddot - they are logically equivalent\\n total_ans = []\\n useful_indices = []\\n bad_indices = []\\n for i in range(len(ypts)): \\n min_ans = 0.\\n for j in range(len(ypts)):\\n if j==i:\\n pass\\n else:\\n min_ans = (ypts[j]*float(self.localBasis[2,j])) + min_ans\\n min_ans = t1 - min_ans\\n if (abs(float(self.localBasis[2,i])) > 0.0):\\n min_ans = min_ans/float(self.localBasis[2,i])\\n useful_indices.append(i)\\n else:\\n bad_indices.append(i)\\n total_ans.append(min_ans)\\n \\n new_ans = vector_AND_(ypts, total_ans)\\n for i in useful_indices:\\n if new_ans[i].isempty == False: # abs( new_ans[i].width() ) > 0.:\\n ypts[i] = ypts[i] & new_ans[i]\\n qxdot,qxddot,qydot,qyddot = self.update_allq(xpts,ypts)\\n else:\\n print 'warning, possible constraint violation, curvature 1'\\n \\n ## \\n ## qxdot\\n ##\\n check2 = qydot*qxddot\\n if check2.width() < 1.e-2 and check2.contains(0.):\\n check2.inf = 0.\\n check2.sup = 0.\\n #if qyddot.contains(0.):\\n # print 'qyddot = ',qyddot\\n # print 'qyddot not invertable, implement other logic please'\\n \\n if qyddot.contains(0.) and qyddot.width()<1.e-6:\\n qxdot.inf = 0.#1.e-10\\n print 'invert qyddot'\\n print 'qyddot = ',qyddot\\n fix = (lhs + check2)*(1./qyddot)#*(qyddot**-1.)\\n fix = fix & qxdot # go ahead and shrink fix to qxdot - they are logically equivalent\\n total_ans = []\\n useful_indices = []\\n bad_indices = []\\n \\n for i in range(len(xpts)): #contract on x[i]\\n min_ans = 0.\\n for j in range(len(xpts)): # add up all jth pieces of the dot product except i\\n if j==i:\\n pass\\n else:\\n \\n min_ans = (xpts[j]*float(self.localBasis[1,j] ) ) + min_ans\\n min_ans = fix - min_ans\\n if (abs(float(self.localBasis[1,i]) ) >0.0 ):\\n min_ans = min_ans/float(self.localBasis[1,i])\\n useful_indices.append(i)\\n else:\\n bad_indices.append(i)\\n total_ans.append(min_ans)\\n \\n new_ans = vector_AND_(xpts, total_ans)\\n for i in useful_indices:\\n if not new_ans[i].isempty: # abs( new_ans[i].width() ) > 0.:\\n xpts[i] = xpts[i] & new_ans[i]\\n qxdot,qxddot,qydot,qyddot = self.update_allq(xpts,ypts)\\n else:\\n print 'warning, possible constraint violation, curvature 2'\\n \\n \\n ## switch to the other side\\n \\n ##\\n ## contract on qydot\\n ##\\n check2 = qxdot*qyddot\\n if check2.width() < 1.e-2 and check2.contains(0.):\\n check2.inf = 0.\\n check2.sup = 0.\\n# if qxddot.contains(0.):\\n# print 'qxddot = ',qxddot\\n# print 'qxddot not invertable, implement other logic please'\\n# qxddot.min.value = 0.\\n if qxddot.contains(0.):\\n qxddot.inf = 0.\\n \\n print 'invert qxddot'\\n print 'qxddot = ',qxddot\\n t1 = (lhs - check2)/(-qxddot)#*(-qxddot**-1)\\n t1 = t1 & qydot\\n total_ans = []\\n useful_indices = []\\n bad_indices = []\\n for i in range(len(ypts)): \\n min_ans = 0.\\n for j in range(len(ypts)):\\n if j==i:\\n pass\\n else:\\n #print 't1 = ',t1\\n #print 'ypts[{}] = {}'.format(i,ypts[i])\\n #print 'localbasis[{},{}] = {}'.format(1,i,self.localBasis[1,j])\\n min_ans = (ypts[j]*float(self.localBasis[1,j])) + min_ans\\n min_ans = t1 - min_ans\\n if (abs(float(self.localBasis[1,i])) > 0.0):\\n min_ans = min_ans/float(self.localBasis[1,i])\\n useful_indices.append(i)\\n else:\\n bad_indices.append(i)\\n total_ans.append(min_ans)\\n \\n new_ans = vector_AND_(ypts, total_ans)\\n for i in useful_indices:\\n if not new_ans[i].isempty: # abs( new_ans[i].width() ) > 0.:\\n ypts[i] = ypts[i] & new_ans[i]\\n else:\\n print 'warning, possible constraint violation, curvature 3'\\n \\n ##contract on qxdot\\n \\n check2 = qxdot*qyddot\\n if check2.width() < 1.e-2 and check2.contains(0.):\\n check2.inf = 0.\\n check2.sup = 0.\\n #contract on qxddot\\n# if qydot.contains(0.):\\n# print 'qydot = ',qxddot\\n# print 'qydot not invertable, implement other logic please'\\n if qydot.contains(0.):\\n qydot.inf = 0.\\n print 'invert qydot'\\n print 'qydot = ',qydot\\n fix = (lhs - qxdot*qyddot)/(-qydot)#*(-qydot**-1)\\n fix = fix & qxddot # go ahead and shrink t1 to quddot - they are logically equivalent\\n total_ans = []\\n useful_indices = []\\n bad_indices = []\\n for i in range(len(xpts)):\\n min_ans = 0.\\n for j in range(len(xpts)):\\n if j==i:\\n pass\\n else:\\n min_ans = (xpts[j]*float(self.localBasis[2,j] ) ) + min_ans\\n min_ans = fix - min_ans\\n if (abs(float(self.localBasis[2,i]) ) >0.0 ):\\n min_ans = min_ans/float(self.localBasis[2,i])\\n useful_indices.append(i)\\n else:\\n bad_indices.append(i)\\n total_ans.append(min_ans)\\n \\n new_ans = vector_AND_(xpts, total_ans)\\n for i in useful_indices:\\n if not new_ans[i].isempty: # abs( new_ans[i].width() ) > 0.:\\n xpts[i] = xpts[i] & new_ans[i]\\n else:\\n print 'warning, possible constraint violation, curvature 4'\\n \\n for i in range(nrange):\\n vertices[0][i].value = xpts[i]\\n vertices[1][i].value = ypts[i]\\n return vertices\",\n \"def rewofzs3(x,y):\\n\\n z=x+y*(1j)\\n a=1.0/(2.0*z*z)\\n q=(1j)/(z*jnp.sqrt(jnp.pi))*(1.0 + a*(1.0 + a*(3.0 + a*(15.0+a*105.0))))\\n return jnp.real(q)\",\n \"def solve(self):\\n ...\",\n \"def cubic_roots(a0, a1, a2, a3=None):\\n\\n N = len(a0)\\n out = np.full([N, 3], np.nan)\\n\\n # Calculate the normalized form x^3 + a2 * x^2 + a1 * x + a0 = 0\\n b_a = a2 if a3 is None else a2 / a3\\n b_a2 = b_a * b_a\\n c_a = a1 if a3 is None else a1 / a3\\n d_a = a0 if a3 is None else a0 / a3\\n\\n # Solve the cubic equation\\n Q = (3 * c_a - b_a2) / 9\\n R = (9 * b_a * c_a - 27 * d_a - 2 * b_a * b_a2) / 54\\n Q3 = Q * Q * Q\\n D = Q3 + R * R\\n b_a_3 = (1.0 / 3.0) * b_a\\n\\n sel = Q == 0.0\\n if np.any(sel):\\n o = out[sel, 0]\\n\\n sel2 = R == 0.0\\n if np.any(sel2):\\n o[sel2] = -b_a_3[sel][sel2]\\n\\n if np.any(~sel2):\\n o[~sel2] = np.pow(2 * R[sel][~sel2], 1 / 3.0) - b_a_3[sel][~sel2]\\n\\n out[sel, 0] = o\\n\\n sel = D <= 0.0\\n if np.any(sel):\\n # Three real roots\\n theta = np.arccos(R[sel] / np.sqrt(-Q3[sel]))\\n sqrt_Q = np.sqrt(-Q[sel])\\n\\n out[sel, 0] = 2 * sqrt_Q * np.cos(theta / 3.0) - b_a_3[sel]\\n out[sel, 1] = 2 * sqrt_Q * np.cos((theta + 2 * np.pi) / 3.0) - b_a_3[sel]\\n out[sel, 2] = 2 * sqrt_Q * np.cos((theta + 4 * np.pi) / 3.0) - b_a_3[sel]\\n\\n return out\",\n \"def get_exact_classical_binary_solution(qubit_operator, offset):\\n result = get_classical_solver_result(qubit_operator, offset)\\n return result.x\",\n \"def algorithm_1_1(p, c, t, x):\\n\\n q = np.array(c, dtype=np.float64)\\n\\n for k in range(1, p + 1):\\n for j in range(0, p - k + 1):\\n q[j] = (t[j + k] - x) / (t[j + k] - t[j]) * q[j] + (x - t[j]) / (\\n t[j + k] - t[j]) * q[j + 1]\\n return q[0]\",\n \"def solve(self):\\n pass\",\n \"def solve(self):\\n pass\",\n \"def problem():\\n for a in range(1, 380):\\n for b in range(a):\\n if a + b + (a**2 + b**2)**0.5 == 1000:\\n return int(a * b * (a**2 + b**2)**0.5)\",\n \"def solve_part2(input, verbose=False):\\n equations = parse(input)\\n\\n result = []\\n for eq in equations:\\n result.append(solve_equation_addition_precendence(eq, verbose))\\n\\n if verbose:\\n print(f\\\"results: {result}\\\")\\n\\n return sum(result)\",\n \"def quartic_potential(x):\\n k1=1\\n k2=10\\n return (k1*x**4)-(k2*x**2)\",\n \"def solve(self):\\n \\n raise NotImplementedError(\\\"not implemented!\\\")\",\n \"def solve_quadratic(a, b, c):\\n assert a != 0\\n d = b * b - 4 * a * c\\n if d < 0:\\n return []\\n elif d == 0:\\n return -b / (2 * a)\\n else:\\n return [\\n (-b - math.sqrt(d)) / (2 * a),\\n (-b + math.sqrt(d)) / (2 * a)\\n ]\",\n \"def pm3d_formula(x,formula):\\n \\n if(formula<0):\\t\\t\\n\\tx=1.0-x\\n\\tformula=-formula\\n\\n if(formula==0): return 0\\n elif(formula==1): return 0.5\\n elif(formula==2): return 1\\n elif(formula==3): return x\\n elif(formula==4): return(x * x)\\n elif(formula==5): return(x * x * x)\\n elif(formula==6): return(x * x * x * x)\\n elif(formula==7): return(Numeric.sqrt(x))\\n elif(formula==8): return(x**0.25)\\n elif(formula==9): return(Numeric.sin(90.0 * x * DEG2RAD))\\n elif(formula==10): return(Numeric.cos(90 * x * DEG2RAD))\\n elif(formula==11): return(Numeric.fabs(x - 0.5))\\n elif(formula==12): return((2 * x - 1) * (2.0 * x - 1))\\n elif(formula==13): return(Numeric.sin(180 * x * DEG2RAD))\\n elif(formula==14): return(Numeric.fabs(cos(180 * x * DEG2RAD)))\\n elif(formula==15): return(Numeric.sin(360 * x * DEG2RAD))\\n elif(formula==16): return(Numeric.cos(360 * x * DEG2RAD))\\n elif(formula==17): return(Numeric.fabs(Numeric.sin(360 * x * DEG2RAD)))\\n elif(formula==18): return(Numeric.fabs(Numeric.cos(360 * x * DEG2RAD)))\\n elif(formula==19): return(Numeric.fabs(Numeric.sin(720 * x * DEG2RAD)))\\n elif(formula==20): return(Numeric.fabs(Numeric.cos(720 * x * DEG2RAD)))\\n elif(formula==21): return(3 * x) # ???????\\n elif(formula==22): return(3 * x - 1)\\n elif(formula==23): return(3 * x - 2)\\n elif(formula==24): return(Numeric.fabs(3 * x - 1))\\n elif(formula==25): return(Numeric.fabs(3 * x - 2))\\n elif(formula==26): return((1.5 * x - 0.5))\\n elif(formula==27): return((1.5 * x - 1))\\n elif(formula==28): return(Numeric.fabs(1.5 * x - 0.5))\\n elif(formula==29): return(Numeric.fabs(1.5 * x - 1))\\n elif(formula==30):\\n if (x <= 0.25): return 0.0\\n if (x >= 0.57): return 1.0\\n\\treturn(x / 0.32 - 0.78125)\\n elif(formula==31):\\n if (x <= 0.42): return 0.0\\n if (x >= 0.92): return 1.0\\n\\treturn(2 * x - 0.84)\\n elif(formula==32):\\n if (x <= 0.42): return(4*x)\\n if (x <= 0.92): return(-2 * x + 1.84)\\n return(x / 0.08 - 11.5)\\n elif(formula==33): return(Numeric.fabs(2 * x - 0.5))\\n elif(formula==34): return(2 * x)\\n elif(formula==35): return(2 * x - 0.5)\\n elif(formula==36): return(2 * x - 1)\\n return(0)\",\n \"def algorithm_1_2(p, c, x):\\n\\n q = np.array(c, dtype=np.float64)\\n\\n for k in range(1, p + 1):\\n for j in range(0, p - k + 1):\\n q[j] = (1 - x) * q[j] + x * q[j + 1]\\n return q[0]\",\n \"def get_classical_solver_result(qubit_operator, offset):\\n qp = QuadraticProgram()\\n qp.from_ising(qubit_operator, offset)\\n exact = MinimumEigenOptimizer(NumPyMinimumEigensolver())\\n return exact.solve(qp)\",\n \"def reaction_forces(Ca, la, x1, x2, x3, xa, h, d1, d3, theta, P, q, E, I):\\r\\n \\r\\n equation_matrix = np.array([[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], \\r\\n [1, 0, 0, 1, 0, 1, 0, np.sin(theta), 0, 0, 0, 0, (P*np.sin(theta)+q*la*np.cos(theta))], \\r\\n [0, 1, 0, 0, 1, 0, 1, np.cos(theta), 0, 0, 0, 0, (P*np.cos(theta)-q*la*np.sin(theta))],\\r\\n \\r\\n [-(Ca/4-h/2), 0, 0, -(Ca/4-h/2) ,0 , -(Ca/4-h/2), 0, (np.cos(theta)*h/2-np.sin(theta)*Ca/4), 0, 0, 0, 0, (P*np.cos(theta)*h/2*-P*np.sin(theta)*Ca/4)], \\r\\n [0, (x2-x1), 0, 0, 0, 0, -(x3-x2), (np.cos(theta)*xa/2), 0, 0, 0, 0, (-P*np.cos(theta)*xa/2+q*la*np.sin(theta)*(la/2-x2))], \\r\\n [-(x2-x1), 0, 0, 0, 0, (x3-x2), 0, -np.sin(theta)*xa/2, 0, 0, 0, 0, (P*np.sin(theta)*xa/2+q*la*np.cos(theta)*(la/2-x2))], \\r\\n \\r\\n [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, x1, 1, -q*np.sin(theta)*((x1**4)/24)], \\r\\n [0, ((x2-x1)**3)/6, 0, 0, 0, 0, 0, ((np.cos(theta))*((xa/2)**3)/6), 0, 0, x2, 1, (-q*np.sin(theta)*((x2**4)/24))], \\r\\n [0, ((x3-x1)**3)/6, 0, 0, ((x3-x2)**3)/6, 0, 0, ((np.cos(theta))*((x3-x2+xa/2)**3)/6), 0, 0, x3, 1, (-q*np.sin(theta)*((x3**4)/24)+P*(np.cos(theta))*(x3-x2-xa/2)**3/6)], \\r\\n [0, 0, 0, 0, 0, 0, 0, 0, x1, 1, 0, 0, (-E*I*d1*+q*np.cos(theta)*(x1**4)/24)], \\r\\n [(((x2-x1)**3)/6), 0, 0, 0, 0, 0, 0, ((-np.sin(theta))*((xa/2)**3)/6), x2, 1, 0, 0, (q*np.cos(theta)*(x2**4)/24)], \\r\\n [(((x3-x1)**3)/6),0,0,(((x3-x2)**3)/6),0,0,0,((-np.sin(theta))*((x3-x2+xa/2)**3)/6),x3,1,0,0,(-E*I*d3*+q*np.cos(theta)*((x3**4)/24)+P/6*np.sin(theta)*(x3-x2-xa/2)**3)]])\\r\\n \\r\\n \\r\\n unknown_matrix = equation_matrix[:,:-1]\\r\\n constant_matrix = equation_matrix[:,-1]\\r\\n \\r\\n \\r\\n solution_matrix = np.linalg.solve(unknown_matrix,constant_matrix)\\r\\n \\r\\n solution_matrix = solution_matrix/1000\\r\\n \\r\\n (R1y, R1z, R2x, R2y, R2z, R3y, R3z, RI, c1, c2, c3, c4) = tuple(solution_matrix)\\r\\n \\r\\n print((R1y, R1z, R2x, R2y, R2z, R3y, R3z, RI, c1, c2, c3, c4))\",\n \"def xcoeff(self):\\n a, c, d, b = self.to_ccw()\\n p1, q1 = a + b, c + d\\n p2, q2 = a + c, b + d\\n n = p1 + q1\\n\\n cov = self.covar()\\n\\n if n == 0:\\n return np.nan\\n elif a == n or d == n:\\n return 0.5\\n elif b == n or c == n:\\n return -1.0\\n elif cov > 0.0:\\n return _div(cov, min(p1 * q2, p2 * q1))\\n elif cov < 0.0:\\n return _div(cov, min(n * c, n * b))\\n else:\\n return 0.0\",\n \"def con_cieq(x,project):\\n \\n cons = project.con_cieq(x)\\n \\n if cons: cons = array(cons)\\n else: cons = zeros([0])\\n \\n return -cons\",\n \"def _solve_explicit(self, initial_conditions):\\n coeff = self.a ** 2 * self.tau / self.h ** 2\\n current_solution = initial_conditions\\n next_solution = np.empty_like(current_solution)\\n solutions = []\\n\\n for t in self.t_grid:\\n next_solution[1:-1] = (\\n current_solution[1:-1]\\n + (current_solution[:-2] - 2 * current_solution[1:-1] + current_solution[2:]) * coeff\\n ) + self.rhs(self.x_grid[1:-1], t) * self.tau\\n\\n # left bc\\n if self.left_bc_type == \\\"DIRICHLET\\\":\\n next_solution[0] = self.left_bc(t)\\n elif self.left_bc_type == \\\"NEUMANN\\\":\\n next_solution[0] = (\\n 4 * next_solution[1]\\n - next_solution[2]\\n - 2 * self.h * self.left_bc(t)\\n ) / 3.0\\n\\n # right bc\\n if self.right_bc_type == \\\"DIRICHLET\\\":\\n next_solution[-1] = self.right_bc(t)\\n elif self.right_bc_type == \\\"NEUMANN\\\":\\n next_solution[-1] = (\\n 4 * next_solution[-2]\\n - next_solution[-3]\\n + 2 * self.h * self.right_bc(t)\\n ) / 3.0\\n if self.mode == \\\"VISUALIZATION\\\":\\n solutions.append((t, next_solution.copy()))\\n current_solution = next_solution\\n if self.mode == \\\"TEST\\\":\\n # print(\\\"Result: \\\", current_solution.tolist())\\n # print(\\\"Right answer: \\\", self.anl_solution.tolist())\\n self._norma(current_solution)\\n elif self.mode == \\\"VISUALIZATION\\\":\\n return solutions\",\n \"def SolveFcn(self):\\n return _hypre.HyprePCG_SolveFcn(self)\",\n \"def test_cases():\\r\\n quadratic_roots(1,3,-21)\\r\\n quadratic_roots(2,-4,-6)\\r\\n quadratic_roots(1,4,-12)\\r\\n quadratic_roots(4,12,9)\\r\\n quadratic_roots(-2,-11,-21)\\r\\n quadratic_roots(4,1,4)\\r\\n quadratic_roots(1,1,0)\\r\\n quadratic_roots(1,0,-16)\\r\\n quadratic_roots(1,-14,-49)\\r\\n quadratic_roots(1,10,25)\",\n \"def _solve(self) -> CasADiArrayType:\\n self._solution = minimize(**self.minimize_input)\\n return self._solution.x\",\n \"def solve(self):\\n\\n if self.degree > 2:\\n return \\\"The polynomial degree is strictly greater than 2, I can't solve.\\\"\\n \\n elif self.degree == 0:\\n \\\"\\\"\\\"a * X^0 = 0\\\"\\\"\\\" \\n a = self.all_terms[0].coefficient\\n if a != 0:\\n return \\\"The eqution has no solution\\\"\\n else:\\n return \\\"Every real number is a solution\\\"\\n\\n elif self.degree == 1:\\n \\\"\\\"\\\"a * X^1 + b * X^0 = 0\\\"\\\"\\\"\\n a = self.all_terms[1].coefficient\\n b = self.all_terms[0].coefficient\\n return formula.linear(a, b)\\n\\n elif self.degree == 2:\\n \\\"\\\"\\\"a * X^2 + b * X^1 + c * X^0 = 0\\\"\\\"\\\"\\n a = self.all_terms[2].coefficient\\n b = self.all_terms[1].coefficient\\n c = self.all_terms[0].coefficient\\n discriminant = (b ** 2) - (4 * a * c)\\n two_a = 2 * a\\n if discriminant == 0:\\n return formula.linear(two_a, b)\\n else:\\n if discriminant > 0:\\n return formula.quadratic(two_a, b, discriminant)\\n else:\\n return formula.quadratic(two_a, b, discriminant, simple=False)\",\n \"def loevinger_coeff(self):\\n a, c, d, b = self.to_ccw()\\n p1, q1 = a + b, c + d\\n p2, q2 = a + c, b + d\\n n = p1 + q1\\n\\n cov = self.covar()\\n\\n if n == 0:\\n return np.nan\\n elif a == n or d == n:\\n # only one (diagonal) cell is non-zero\\n return 0.5\\n elif cov == 0.0:\\n return 0.0\\n else:\\n return _div(cov, min(p1 * q2, p2 * q1))\",\n \"def test_exact_numerical_solution():\\n a = 0.2\\n b = 3\\n\\n def f(t, u):\\n return a # + (u - u_exact(t))**5\\n\\n def u_exact(t):\\n \\\"\\\"\\\"Exact u(t) corresponding to f above.\\\"\\\"\\\"\\n return a * t + b\\n\\n u0 = u_exact(0)\\n T = 8\\n N = 10\\n tol = 1E-15\\n #t_points = np.linspace(0, T, N)\\n t_span = (0, T)\\n for solver_class in registered_solver_classes:\\n solver = solver_class(f)\\n solver.set_initial_condition(u0)\\n t, u = solver.solve(t_span, N)\\n u_e = u_exact(t)\\n max_error = (u_e - u).max()\\n msg = f'{solver.__class__.__name__} failed with max_error={max_error}'\\n assert max_error < tol, msg\",\n \"def pointPotential(x,y,q,posx,posy):\\n k = 8.99e9\\n V = (k * q) / (sqrt(x**2 + (y - sqrt((posx**2 + posy**2)))**2))\\n return V\",\n \"def getExactSoln(phi_ic, c, nt):\\n \\n dimx = len(phi_ic) \\n\\n lag = int(c*nt)\\n\\n # phiExact stores the exact solution phi(x-ut)\\n phiExact = np.roll(phi_ic, lag)\\n \\n #impose periodic boundary condn\\n phiExact[dimx-1] = phiExact[0]\\n \\n return phiExact\",\n \"def solve_Q(ih, jh):\\n # Build A and b\\n\\n # Solve for c via least squares.\\n\\n # Form C from c\\n\\n # Solve for Q and return it.\\n return None\",\n \"def solve(self):\\n\\n # Assign variables to each quantity being solved.\\n r_lookup, lookup, num = {}, {}, 0\\n for element in self.elements:\\n if is_wire(element) and element is not self.ground:\\n lookup[num] = element\\n r_lookup[element] = num\\n num += 1\\n elif not is_cs(element) and element is not self.ground:\\n lookup[num] = element\\n r_lookup[element] = num\\n num += 1\\n\\n # Set up the linear algebraic equation Ax=b\\n A = np.zeros((num, num))\\n b = np.zeros(num)\\n for row, element in lookup.items():\\n if is_wire(element) and element is not self.ground:\\n for two_sided in element.attached:\\n if is_cs(two_sided):\\n if two_sided.pos is element:\\n b[row] += -1 * two_sided.current\\n else:\\n b[row] += two_sided.current\\n else:\\n if two_sided.pos is element:\\n flow = 1\\n else:\\n flow = -1\\n A[row, r_lookup[two_sided]] = flow\\n elif is_vs(element):\\n check_connected(element)\\n if element.pos is not self.ground:\\n A[row, r_lookup[element.pos]] = 1\\n if element.neg is not self.ground:\\n A[row, r_lookup[element.neg]] = -1\\n b[row] = element.voltage\\n elif is_resistor(element):\\n check_connected(element)\\n if element.pos is not self.ground:\\n A[row, r_lookup[element.pos]] = 1\\n if element.neg is not self.ground:\\n A[row, r_lookup[element.neg]] = -1\\n A[row, r_lookup[element]] = -1 * element.resistance\\n\\n b = b.reshape((num, 1))\\n try:\\n x = np.linalg.solve(A, b)\\n except np.linalg.LinAlgError:\\n raise CircuitError('Insufficient information to solve circuit')\\n\\n # Assign values to all circuit components\\n for i in range(num):\\n item = lookup[i]\\n if is_wire(item):\\n item.potential = x[i, 0]\\n elif isinstance(item, DualSided):\\n item.current = x[i, 0]\\n\\n # Mark circuit as solved\\n self.been_solved = True\",\n \"def solve(self) -> jnp.ndarray:\\n pass\",\n \"def run_exact(self):\\n self.operator, var_form, opt = self.generate_VQE_args()\\n\\n exact_eigensolver = ExactEigensolver(self.operator, k=1)\\n self.result = exact_eigensolver.run()\\n\\n solution = self.extract_solution(self.result, True)\\n return solution\",\n \"def coefC(x0,y0,x1,y1):\\n return (x1*y0-x0*y1)/(x1-x0)\",\n \"def inverse_cubic ( a , b , c , d ) :\\n\\n x0 , f0 = a.x , a.fx\\n x1 , f1 = b.x , b.fx\\n x2 , f2 = c.x , c.fx\\n x3 , f3 = d.x , d.fx\\n\\n ## switch to inverse parabolic if some function values coincide \\n if f0 == f1 or isequal ( f0 , f1 ) : return inverse_parabolic ( a , c , d ) \\n if f0 == f2 or isequal ( f0 , f2 ) : return inverse_parabolic ( a , b , d )\\n if f0 == f3 or isequal ( f0 , f3 ) : return inverse_parabolic ( a , b , c )\\n if f1 == f2 or isequal ( f1 , f2 ) : return inverse_parabolic ( a , b , d ) \\n if f1 == f3 or isequal ( f1 , f3 ) : return inverse_parabolic ( a , b , c ) \\n if f2 == f3 or isequal ( f2 , f3 ) : return inverse_parabolic ( a , b , c ) \\n\\n f01 = 1.0 / ( f0 - f1 ) ; f10 = - f01\\n f02 = 1.0 / ( f0 - f2 ) ; f20 = - f02\\n f03 = 1.0 / ( f0 - f3 ) ; f30 = - f03\\n f12 = 1.0 / ( f1 - f2 ) ; f21 = - f12\\n f13 = 1.0 / ( f1 - f3 ) ; f31 = - f13\\n f23 = 1.0 / ( f2 - f3 ) ; f32 = - f23\\n\\n xx = -x0 * f1 * f2 * f3 * f01 * f02 * f03 \\n xx += -x1 * f0 * f2 * f3 * f10 * f12 * f13 \\n xx += -x2 * f0 * f2 * f3 * f20 * f21 * f23 \\n xx += -x3 * f0 * f1 * f2 * f30 * f31 * f32\\n \\n return xx\",\n \"def l1(P, q):\\n\\n m, n = P.size\\n\\n # Solve equivalent LP \\n #\\n # minimize [0; 1]' * [u; v]\\n # subject to [P, -I; -P, -I] * [u; v] <= [q; -q]\\n #\\n # maximize -[q; -q]' * z \\n # subject to [P', -P']*z = 0\\n # [-I, -I]*z + 1 = 0 \\n # z >= 0 \\n \\n c = matrix(n*[0.0] + m*[1.0])\\n h = matrix([q, -q])\\n\\n def Fi(x, y, alpha = 1.0, beta = 0.0, trans = 'N'): \\n if trans == 'N':\\n # y := alpha * [P, -I; -P, -I] * x + beta*y\\n u = P*x[:n]\\n y[:m] = alpha * ( u - x[n:]) + beta*y[:m]\\n y[m:] = alpha * (-u - x[n:]) + beta*y[m:]\\n\\n else:\\n # y := alpha * [P', -P'; -I, -I] * x + beta*y\\n y[:n] = alpha * P.T * (x[:m] - x[m:]) + beta*y[:n]\\n y[n:] = -alpha * (x[:m] + x[m:]) + beta*y[n:]\\n\\n\\n def Fkkt(W): \\n\\n # Returns a function f(x, y, z) that solves\\n #\\n # [ 0 0 P' -P' ] [ x[:n] ] [ bx[:n] ]\\n # [ 0 0 -I -I ] [ x[n:] ] [ bx[n:] ]\\n # [ P -I -W1^2 0 ] [ z[:m] ] = [ bz[:m] ]\\n # [-P -I 0 -W2 ] [ z[m:] ] [ bz[m:] ]\\n #\\n # On entry bx, bz are stored in x, z.\\n # On exit x, z contain the solution, with z scaled (W['di'] .* z is\\n # returned instead of z). \\n\\n d1, d2 = W['d'][:m], W['d'][m:]\\n D = 4*(d1**2 + d2**2)**-1\\n A = P.T * spdiag(D) * P\\n lapack.potrf(A)\\n\\n def f(x, y, z):\\n\\n x[:n] += P.T * ( mul( div(d2**2 - d1**2, d1**2 + d2**2), x[n:]) \\n + mul( .5*D, z[:m]-z[m:] ) )\\n lapack.potrs(A, x)\\n\\n u = P*x[:n]\\n x[n:] = div( x[n:] - div(z[:m], d1**2) - div(z[m:], d2**2) + \\n mul(d1**-2 - d2**-2, u), d1**-2 + d2**-2 )\\n\\n z[:m] = div(u-x[n:]-z[:m], d1)\\n z[m:] = div(-u-x[n:]-z[m:], d2)\\n\\n return f\\n\\n\\n # Initial primal and dual points from least-squares solution.\\n\\n # uls minimizes ||P*u-q||_2; rls is the LS residual.\\n uls = +q\\n lapack.gels(+P, uls)\\n rls = P*uls[:n] - q \\n\\n # x0 = [ uls; 1.1*abs(rls) ]; s0 = [q;-q] - [P,-I; -P,-I] * x0\\n x0 = matrix( [uls[:n], 1.1*abs(rls)] ) \\n s0 = +h\\n Fi(x0, s0, alpha=-1, beta=1) \\n\\n # z0 = [ (1+w)/2; (1-w)/2 ] where w = (.9/||rls||_inf) * rls \\n # if rls is nonzero and w = 0 otherwise.\\n if max(abs(rls)) > 1e-10: \\n w = .9/max(abs(rls)) * rls\\n else: \\n w = matrix(0.0, (m,1))\\n z0 = matrix([.5*(1+w), .5*(1-w)])\\n\\n dims = {'l': 2*m, 'q': [], 's': []}\\n sol = solvers.conelp(c, Fi, h, dims, kktsolver = Fkkt, \\n primalstart={'x': x0, 's': s0}, dualstart={'z': z0})\\n return sol['x'][:n]\",\n \"def SolveFcn(self):\\n return _hypre.HypreTriSolve_SolveFcn(self)\",\n \"def FindClosestPointWithinRadius(self, p_float, , p_float_4):\\n ...\",\n \"def calc_C(h, x0, nu_C, W):\\n M = len(nu_C)\\n C = np.zeros((W, M), dtype=float)\\n N = len(h)\\n B = np.zeros((2 * N + 2, W))\\n x = x0 * np.arange(0, N + 1, dtype=float) / N\\n h_ext = np.concatenate(([1.0], h))\\n rhs = np.r_[np.ones(N + 1, dtype=float), np.zeros(N + 1, dtype=float)]\\n rhs[0] = rhs[0] / np.sqrt(2.0)\\n rhs[N] = rhs[N] / np.sqrt(2.0)\\n for m, nu_val in enumerate(nu_C):\\n for r in range(W):\\n k = r - (W / 2) + 1\\n B[:N + 1, r] = h_ext * np.cos(2 * np.pi * (k - nu_val) * x)\\n B[N + 1:, r] = h_ext * np.sin(2 * np.pi * (k - nu_val) * x)\\n B[0, :] = B[0, :] / np.sqrt(2.0)\\n B[N, :] = B[N, :] / np.sqrt(2.0)\\n B[N + 1, :] = B[N + 1, :] / np.sqrt(2.0)\\n B[2 * N + 1, :] = B[2 * N + 1, :] / np.sqrt(2.0)\\n q, r = np.linalg.qr(B)\\n C[:, m] = solve_triangular(r, np.dot(q.transpose(), rhs))\\n # C[:,m] = np.linalg.lstsq(B, rhs)[0]\\n return C\",\n \"def compute(self, *args, **kwargs):\\n vertices = args[0]\\n xpts = vertices[2] # z plays the 'x' part\\n ypts = vertices[0] # x plays the 'y' part\\n #zpts = vertices[1]\\n #********************************************\\n # switcharoo: using z in place of x\\n # using x in place of y\\n # i.e.\\n #\\n # y <- x\\n # x <- z\\n #\\n qxdot = np.dot(xpts,self.localBasis[1])\\n qxddot = np.dot(xpts,self.localBasis[2])\\n qydot = np.dot(ypts,self.localBasis[1])\\n qyddot = np.dot(ypts,self.localBasis[2])\\n store = (qxdot*qyddot - qydot*qxddot)\\n temp = np.sqrt(qxdot**2 + qydot**2)\\n if isinstance(temp, ia):\\n if temp.inf<=0:\\n temp.inf = 0.\\n denom = temp*((temp)**2)#**.5## #problem foud with sqrt\\n #\\n curvature = store/denom#((np.sqrt(qxdot*qxdot + qydot*qydot))**3.)\\n return curvature\",\n \"def iroots(a, b, c):\\n discriminant = b*b-4*a*c\\n if discriminant == 0:\\n return -b/(2*a), None\\n else:\\n return (-b+isqrt(discriminant))/(2*a), (-b-isqrt(discriminant))/(2*a)\",\n \"def getCurvature(f,x):\\n df = f.derivative(nu=1)(x)\\n ddf = f.derivative(nu=2)(x)\\n k = ddf/pow(1-df*df,3/2)\\n return k, abs(1.0/k)\",\n \"def F(x):\\n soln = x - (1.0/5.0)*math.cos(10.0*x+1.0) \\n return soln\",\n \"def optimal_nc(f, xl: float, xr: float, n: int, tol: float, *params):\\n # required local variables to return\\n # S : computed value of the integral with required tolerance\\n # N : number of steps for S\\n # err : estimated error of S\\n # iter : number of iterations (steps doubling)\\n iter = 1\\n N = 200\\n h_old = (xr - xl) / (4*N)\\n\\n s1 = composite_quad(f, xl, xr, N, n, *params)\\n N *= 2\\n s2 = composite_quad(f, xl, xr, N, n, *params)\\n N *= 2\\n s3 = composite_quad(f, xl, xr, N, n, *params)\\n\\n L = 2\\n m = aitken(s1, s2, s3, L)\\n\\n\\n # если m далеко от теоретического значения, значит мы находимся в области,\\n # где отброшенные величины не малы и нам нужно продолжать делить шаг\\n while m > 4.5 or m < 2.5:\\n s1 = s2\\n s2 = s3\\n N *= 2\\n s3 = composite_quad(f, xl, xr, N, n, *params)\\n m = aitken(s1, s2, s3, L)\\n\\n # далее предлагаем идти по оптимальному шагу\\n coef = 0.95\\n h_new = coef * h_old * (tol / np.abs(runge(s2, s3, L, m))) ** (1 / m)\\n\\n N = int((xr - xl) / h_new) + 1\\n\\n while iter != MAXITER + 1:\\n s1 = s2\\n s2 = s3\\n\\n s3 = composite_quad(f, xl, xr, N, n, *params)\\n\\n m = aitken(s1, s2, s3, L)\\n\\n # берём погрешность из метода рунге\\n estimate = np.abs(runge(s2, s3, L, m))\\n\\n if estimate < tol:\\n return N, s3, estimate\\n\\n N *= 2\\n iter += 1\\n\\n print(\\\"Convergence not reached!\\\")\\n return 0, 0, 10 * tol, -100\",\n \"def solve_exact(case, nodes = 100):\\n L, = get_valdict(case, 'L')\\n axis = np.linspace(0, L, nodes)\\n ordinat = func_exact_sol(axis, case)\\n \\n sol_exact = (axis, ordinat)\\n \\n return sol_exact\",\n \"def find_x(p, c):\\n if p == 0:\\n x = int(math.sqrt(c)) + 1\\n else:\\n x = int(c / (20. * p)) + 1\\n while True:\\n y = (20 * p + x)*x\\n if y <= c:\\n return x\\n else:\\n x -= 1\",\n \"def _lonely_coefficient(replies):\\n return 1/((replies+1)**0.3)\",\n \"def solve(self):\\n\\n constrains, bounds = self.init_constraint_list()\\n result = minimize(self.objective_function,\\n x0=self.init_guess,\\n constraints=constrains,\\n bounds=bounds,\\n options={'disp': False})\\n\\n return result\",\n \"def yule_q(self):\\n a, c, d, b = self.to_ccw()\\n p1, q1 = a + b, c + d\\n p2, q2 = a + c, b + d\\n n = a + b + c + d\\n\\n if n == 0:\\n return np.nan\\n elif p1 == n:\\n # c and d are zero\\n return _div(a - b, p1)\\n elif p2 == n:\\n # b and d are zero\\n return _div(a - c, p2)\\n elif q1 == n:\\n # a and b are zero\\n return _div(d - c, q1)\\n elif q2 == n:\\n # a and c are zero\\n return _div(d - b, q2)\\n\\n return _div(self.covar(), a * d + b * c)\",\n \"def estimateCs(y, inp):\\n\\treturn 1 -(math.tanh(getK1(inp) - (y/getY90(inp)) / (2 * getD0(inp)) + (y/getY90(inp) - 1/3.0)**3 / (3 * getD0(inp))))**2\",\n \"def lowerlim(x, y, z, a, b, c):\\n if x/a + y/b + z/c > 1:\\n B = a + b + c - x - y - z\\n C = a*b + a*c + b*c - a*y - a*z - b*x - b*z - c*x - c*y\\n D = a*b*c - a*b*z - a*c*y - b*c*x\\n r = np.roots([1,B,C,D])\\n ll = r[~np.iscomplex(r) & (r>0.)]\\n return ll[0].real\\n else:\\n return 0.\",\n \"def solve(s):\\n \\n # Solve 2 eqs. for 'b' in terms of 'a'\\n b = lambda a: ( s*a - s*s/2 ) / ( a - s )\\n \\n for a in range (1, s - 1):\\n if b(a).is_integer():\\n break\\n \\n c = s - a - b(a)\\n \\n return int(a*b(a)*c)\",\n \"def Es_case_C(z, x, gamma, alp, lamb):\\n\\n if z == 0 and x == 0 and alp == 0:\\n return 0\\n \\n beta2 = 1-1/gamma**2\\n beta = sqrt(beta2)\\n \\n sin2a = sin(2*alp)\\n cos2a = cos(2*alp) \\n eta = eta_case_C(z, x, beta2, alp, lamb)\\n \\n kap = (2*(alp - z) + eta + lamb)/beta # kappa for case C\\n #kap = sqrt( lamb**2 + eta**2 + x**2 + 4*(1+x)*sin(alp)**2 + 2*(lamb + eta*(1+x))*sin2a + 2*lamb*eta*cos2a) \\n \\n N = lamb + sin2a + (eta - beta*kap)*cos2a\\n D = kap - beta*(eta + lamb*cos2a + (1+x)*sin2a)\\n \\n return N/D**3\",\n \"def calculate_coefficients(self):\\n for i in range(0, self.nz):\\n zno = i * self.dz\\n self.z[0][i] = zno\\n plot_eccentricity_error = False\\n position = -1\\n for j in range(0, self.ntheta):\\n # fmt: off\\n self.gama[i][j] = j * self.dtheta + (np.pi - self.beta)\\n [radius_external, self.xre[i][j], self.yre[i][j]] = \\\\\\n self.external_radius_function(self.gama[i][j])\\n [radius_internal, self.xri[i][j], self.yri[i][j]] = \\\\\\n self.internal_radius_function(zno, self.gama[i][j])\\n self.re[i][j] = radius_external\\n self.ri[i][j] = radius_internal\\n\\n w = self.omega * self.ri[i][j]\\n\\n k = (self.re[i][j] ** 2 * (np.log(self.re[i][j]) - 1 / 2) - self.ri[i][j] ** 2 *\\n (np.log(self.ri[i][j]) - 1 / 2)) / (self.ri[i][j] ** 2 - self.re[i][j] ** 2)\\n\\n self.c1[i][j] = (1 / (4 * self.viscosity)) * ((self.re[i][j] ** 2 * np.log(self.re[i][j]) -\\n self.ri[i][j] ** 2 * np.log(self.ri[i][j]) +\\n (self.re[i][j] ** 2 - self.ri[i][j] ** 2) *\\n (k - 1)) - 2 * self.re[i][j] ** 2 * (\\n (np.log(self.re[i][j]) + k - 1 / 2) * np.log(\\n self.re[i][j] / self.ri[i][j])))\\n\\n self.c2[i][j] = (- self.ri[i][j] ** 2) / (8 * self.viscosity) * \\\\\\n ((self.re[i][j] ** 2 - self.ri[i][j] ** 2 -\\n (self.re[i][j] ** 4 - self.ri[i][j] ** 4) /\\n (2 * self.ri[i][j] ** 2)) +\\n ((self.re[i][j] ** 2 - self.ri[i][j] ** 2) /\\n (self.ri[i][j] ** 2 *\\n np.log(self.re[i][j] / self.ri[i][j]))) *\\n (self.re[i][j] ** 2 * np.log(self.re[i][j] / self.ri[i][j]) -\\n (self.re[i][j] ** 2 - self.ri[i][j] ** 2) / 2))\\n\\n self.c0w[i][j] = (- w * self.ri[i][j] *\\n (np.log(self.re[i][j] / self.ri[i][j]) *\\n (1 + (self.ri[i][j] ** 2) / (self.re[i][j] ** 2 - self.ri[i][j] ** 2)) - 1 / 2))\\n # fmt: on\\n if not plot_eccentricity_error:\\n if abs(self.xri[i][j]) > abs(self.xre[i][j]) or abs(\\n self.yri[i][j]\\n ) > abs(self.yre[i][j]):\\n plot_eccentricity_error = True\\n position = i\\n if plot_eccentricity_error:\\n self.plot_eccentricity(position)\\n sys.exit(\\n \\\"Error: The given parameters create a rotor that is not inside the stator. \\\"\\n \\\"Check the plotted figure and fix accordingly.\\\"\\n )\",\n \"def roots_cubic(f, trig=False):\\n if trig:\\n a, b, c, d = f.all_coeffs()\\n p = (3*a*c - b**2)/(3*a**2)\\n q = (2*b**3 - 9*a*b*c + 27*a**2*d)/(27*a**3)\\n D = 18*a*b*c*d - 4*b**3*d + b**2*c**2 - 4*a*c**3 - 27*a**2*d**2\\n if (D > 0) == True:\\n rv = []\\n for k in range(3):\\n rv.append(2*sqrt(-p/3)*cos(acos(q/p*sqrt(-3/p)*Rational(3, 2))/3 - k*pi*Rational(2, 3)))\\n return [i - b/3/a for i in rv]\\n\\n # a*x**3 + b*x**2 + c*x + d -> x**3 + a*x**2 + b*x + c\\n _, a, b, c = f.monic().all_coeffs()\\n\\n if c is S.Zero:\\n x1, x2 = roots([1, a, b], multiple=True)\\n return [x1, S.Zero, x2]\\n\\n # x**3 + a*x**2 + b*x + c -> u**3 + p*u + q\\n p = b - a**2/3\\n q = c - a*b/3 + 2*a**3/27\\n\\n pon3 = p/3\\n aon3 = a/3\\n\\n u1 = None\\n if p is S.Zero:\\n if q is S.Zero:\\n return [-aon3]*3\\n u1 = -root(q, 3) if q.is_positive else root(-q, 3)\\n elif q is S.Zero:\\n y1, y2 = roots([1, 0, p], multiple=True)\\n return [tmp - aon3 for tmp in [y1, S.Zero, y2]]\\n elif q.is_real and q.is_negative:\\n u1 = -root(-q/2 + sqrt(q**2/4 + pon3**3), 3)\\n\\n coeff = I*sqrt(3)/2\\n if u1 is None:\\n u1 = S.One\\n u2 = Rational(-1, 2) + coeff\\n u3 = Rational(-1, 2) - coeff\\n b, c, d = a, b, c # a, b, c, d = S.One, a, b, c\\n D0 = b**2 - 3*c # b**2 - 3*a*c\\n D1 = 2*b**3 - 9*b*c + 27*d # 2*b**3 - 9*a*b*c + 27*a**2*d\\n C = root((D1 + sqrt(D1**2 - 4*D0**3))/2, 3)\\n return [-(b + uk*C + D0/C/uk)/3 for uk in [u1, u2, u3]] # -(b + uk*C + D0/C/uk)/3/a\\n\\n u2 = u1*(Rational(-1, 2) + coeff)\\n u3 = u1*(Rational(-1, 2) - coeff)\\n\\n if p is S.Zero:\\n return [u1 - aon3, u2 - aon3, u3 - aon3]\\n\\n soln = [\\n -u1 + pon3/u1 - aon3,\\n -u2 + pon3/u2 - aon3,\\n -u3 + pon3/u3 - aon3\\n ]\\n\\n return soln\",\n \"def solucaoEspacoPontoX(arq,t,x):\\n \\n parametros = open(arq,'r')\\n lista = []\\n for linha in parametros:\\n valores = linha.split()\\n lista.append( valores[1] )\\n Ks = float(lista[0]) # Conductibilidade na fase solida\\n Kl = float(lista[1]) # Conductibilidade na fase liquida\\n Tf = float(lista[2]) # temperatura de mudanca de fase\\n Tinf = float(lista[3]) # Temperatura inicial na fase liquida T0\\n Tw = float(lista[4]) # Temperatura na fronteira no instante inicial\\n L = float(lista[5]) # calor latente\\n cs = float(lista[6]) # calor especifico na zona solida\\n cl = float(lista[7]) # calor especifico na zona liquida\\n cf = float(lista[8]) # calor especifico na zona de mudanca de fase\\n p = float(lista[9]) # pho = massa especifica\\n parametros.close()\\n \\n lam = 0.5064 # chute inicial\\n xx = x\\n lamb = calculaLambda(funcao,lam,Tinf,Tf,Ks,Kl,L,cs,Tw)\\n frente = X_espaco(lamb,Ks,t)\\n if (frente > xx):\\n T = temperaturaZonaSolida_espaco(Tf,Ks,lamb,xx,t,Tw)\\n elif (frente < xx):\\n T = temperaturaZonaLiquida_espaco(Tinf,Tf,Ks,Kl,lamb,xx,t)\\n else:\\n T = Tf\\n return T\",\n \"def solve(grid):\\n\\n return search(grid_values(grid))\",\n \"def solve(grid):\\n\\n return search(grid_values(grid))\",\n \"def potentialSolver3(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def potentialSolver3(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def solve(self):\\n raise NotImplementedError(\\\"This method needs to be implemented.\\\")\",\n \"def test_solve_polynomial_cv_1a():\\n assert solveset_real(sqrt(x) - 1, x) == FiniteSet(1)\\n assert solveset_real(sqrt(x) - 2, x) == FiniteSet(4)\\n assert solveset_real(x**Rational(1, 4) - 2, x) == FiniteSet(16)\\n assert solveset_real(x**Rational(1, 3) - 3, x) == FiniteSet(27)\\n assert solveset_real(x*(x**(S(1) / 3) - 3), x) == \\\\\\n FiniteSet(S(0), S(27))\",\n \"def cubic_interp(xi,yi):\\n\\n # check inputs and print error message if not valid:\\n\\n error_message = \\\"xi and yi should have type numpy.ndarray\\\"\\n assert (type(xi) is np.ndarray) and (type(yi) is np.ndarray), error_message\\n\\n error_message = \\\"xi and yi should have length 3\\\"\\n assert len(xi)==4 and len(yi)==4, error_message\\n\\n error_message = \\\"it is not possible to have more than one point in the with the same xi\\\"\\n assert (len(np.unique(xi)) == len(xi)), error_message\\n\\n # Set up linear system to interpolate through data points:\\n\\n A = np.array([[1, 1, 1, 1], xi, xi**2, xi**3]).T\\n b = yi\\n\\n c = solve(A,b)\\n \\n return c\",\n \"def solve():\\n\\n s, g, e = make_lattice(21)\\n stack = deque([[e]])\\n vals = {s: 1}\\n max_n = 0\\n\\n while stack:\\n max_n = max(max_n, len(stack))\\n n, *p = stack.pop()\\n for c in g.get_connected(n):\\n if c > n:\\n continue\\n if c in vals:\\n propagate(c, [n] + p, vals)\\n else:\\n stack.append([c, n] + p)\\n return vals[e]\",\n \"def KPMO(XVal,YVal_State_1,YVal_State_2,YVal_State_3,XVal_Mean_Trans_1,XVal_Mean_Trans_2,XVal_Sig_Trans_1,XVal_Sig_Trans_2,iOpt):\\n#\\t1. Computations:\\n\\tTiny=1E-20\\n\\tP_Trans_1 = fCPD(XVal,XVal_Mean_Trans_1, XVal_Sig_Trans_1) # Transition of kerogen from State #1 to State #2\\n\\tP_Trans_2 = fCPD(XVal,XVal_Mean_Trans_2, XVal_Sig_Trans_2) # Transition of kerogen from State #2 to State #3\\n\\tFunVal=0\\n\\tif(iOpt==0):\\n\\t\\tP_State_1=(1-P_Trans_1)*(1-P_Trans_2)\\n\\t\\tP_State_2=P_Trans_1*(1 - P_Trans_2)\\n\\t\\tP_State_3=1-P_State_1-P_State_2\\n\\t\\tFunVal=(YVal_State_1*P_State_1)+(YVal_State_2*P_State_2)+(YVal_State_3*P_State_3)\\n\\tif(iOpt==1):\\n\\t\\tFunVal=YVal_State_1+P_Trans_1*YVal_State_2+P_Trans_2*YVal_State_3\\n\\tif(FunVal==0):\\n\\t\\tFunVal=Tiny\\n\\treturn FunVal\",\n \"def solve(self):\\n start = datetime.now()\\n f = self.function\\n while not self.converged():\\n self.history.append(self.vertices)\\n\\n #step 1: sort\\n self.order_vertices()\\n\\n #step 3: reflect\\n reflected = self.get_reflected_point()\\n if f(*self.vertices[0]) < f(*reflected) < f(*self.vertices[-1]):\\n self.reflect()\\n continue\\n\\n #step 4: expand\\n if self.reflected_is_best():\\n expanded = self.get_expanded_point()\\n if f(*expanded) < f(*reflected):\\n self.expand()\\n else:\\n self.reflect()\\n continue\\n\\n #step 5: contract\\n contracted = self.get_contracted_point()\\n if f(*contracted) < f(*self.vertices[-1]):\\n self.contract()\\n continue\\n\\n #step 6: shrink\\n self.shrink()\\n print(\\\"optimization took {0}\\\".format(datetime.now()-start))\\n return self.history, self.cache.history\",\n \"def test_solve_polynomial_cv_1a():\\n assert solveset_real(sqrt(x) - 1, x) == FiniteSet(1)\\n assert solveset_real(sqrt(x) - 2, x) == FiniteSet(4)\\n assert solveset_real(x**Rational(1, 4) - 2, x) == FiniteSet(16)\\n assert solveset_real(x**Rational(1, 3) - 3, x) == FiniteSet(27)\\n assert solveset_real(x*(x**(S.One / 3) - 3), x) == \\\\\\n FiniteSet(S.Zero, S(27))\",\n \"def find_root(function, point_a, point_b, step, tol, max_iterations, \\n show_process = False):\\n left_point , right_point = search_interval_3d(function, point_a, point_b, \\n step, tol, max_iterations,\\n show_process)\\n \\n point_where_zero = bisection_3d(function, left_point, right_point, tol, \\n max_iterations, show_process)\\n \\n return point_where_zero\",\n \"def solve(self):\\n\\t\\t# row and column to control the selected corner\\n\\t\\tcurrent_positions = [0, 0]\\n\\t\\tmax_row = self.result_index[self.__ROW_INDEX]-1\\n\\t\\tmax_col = self.result_index[self.__COLUMN_INDEX]-1\\n\\t\\twhile self.matrix[max_row][max_col] != 0:\\n\\t\\t\\tcurrent_row = current_positions[self.__ROW_INDEX]\\n\\t\\t\\tcurrent_column = current_positions[self.__COLUMN_INDEX]\\n\\t\\t\\tmultiplier_selected = self.get_multiplier_with_index(current_row, current_column)\\n\\t\\t\\tactual_weight = self.matrix[current_row][current_column]\\n\\t\\t\\tactual_result_weight = multiplier_selected[1]\\n\\t\\t\\tself.resulting_matrix[current_row][current_column] = actual_weight * actual_result_weight\\n\\t\\t\\tself.matrix[max_row][max_col] -= actual_result_weight\\n\\t\\t\\tself.matrix[current_row][max_col] -= actual_result_weight\\n\\t\\t\\tself.matrix[max_row][current_column] -= actual_result_weight\\n\\t\\t\\tcurrent_positions[multiplier_selected[0]] += 1\",\n \"def _solve(self, mu=None):\\n pass\",\n \"def test_inv_sphere_v3_root_find(self):\\n import itertools\\n\\n for k in (0, -1, 1, 1.75, 0.325, 1/7, -1.75, -0.325, -1/7):\\n s = space(fake_curvature=k) \\n for m in itertools.chain(\\n range(30),\\n range(31,3000,100),\\n map((1).__truediv__, range(3, 30, 2)),\\n ):\\n r = s.inv_sphere_v3(m)\\n self.assertTrue(r >= 0)\\n v = s.sphere_v3(r)\\n self.assertTrue(isclose(\\n m,\\n v\\n ))\",\n \"def solve(grid):\\n return search(grid_values(grid))\",\n \"def solve(grid):\\n return search(grid_values(grid))\",\n \"def evaluate_objective(x):\\n\\n x_points_cartesian = x_to_cartesian(x)\\n hull = ConvexHull(x_points_cartesian)\\n\\n # Return the negative value because the optimization is a minimization\\n return -hull.volume\",\n \"def RepulsionForceFromObstacle(q,q_oi):\\r\\n d_i = CalculateDistance(q,q_oi) # Distance to the obstacle\\r\\n if (d_i < d_0): # Point within obstacle influence\\r\\n F_oi = k_o * (1/d_i - 1/d_0) /d_i**2 \\r\\n if (F_oi > F_rep_MaxValue): # F_rep won't exceed set constant\\r\\n return F_rep_MaxValue\\r\\n else: # Point without obstacle influence\\r\\n F_oi = 0\\r\\n return F_oi\",\n \"def rochelobe(q):\\n return 0.49*q**(2./3)/(0.6*q**(2./3) + log(1+q**(1./3)))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6496338","0.64271337","0.630471","0.6250335","0.6233523","0.62026256","0.61261874","0.60835856","0.6069071","0.60502964","0.6049461","0.60204566","0.59923995","0.59734356","0.5964771","0.595493","0.5916189","0.59153","0.59113973","0.59004","0.58809906","0.58754313","0.58747846","0.582057","0.58163416","0.58089936","0.58010894","0.58003974","0.57948494","0.5791945","0.5783539","0.57802075","0.5771125","0.5771125","0.5730976","0.5730611","0.5730392","0.5715655","0.57037824","0.5683051","0.5679401","0.5664308","0.5656942","0.56427926","0.5639349","0.5634616","0.5632498","0.56183493","0.56152016","0.5606799","0.5600335","0.5597365","0.5593238","0.5584068","0.5580936","0.55809045","0.5572974","0.55711544","0.5564558","0.5562927","0.5550785","0.5545328","0.5539518","0.5537358","0.55259174","0.55178183","0.55173546","0.5515816","0.55148697","0.55134964","0.5508634","0.5506988","0.5502089","0.5497682","0.54907286","0.5489433","0.54887486","0.5487504","0.548499","0.54726017","0.54694635","0.54690355","0.54690355","0.5469019","0.5469019","0.5468359","0.5458814","0.5456966","0.5455041","0.54534006","0.5443641","0.54420817","0.5437112","0.5430395","0.542536","0.5422047","0.5421261","0.5421261","0.5416444","0.5416299","0.54126865"],"string":"[\n \"0.6496338\",\n \"0.64271337\",\n \"0.630471\",\n \"0.6250335\",\n \"0.6233523\",\n \"0.62026256\",\n \"0.61261874\",\n \"0.60835856\",\n \"0.6069071\",\n \"0.60502964\",\n \"0.6049461\",\n \"0.60204566\",\n \"0.59923995\",\n \"0.59734356\",\n \"0.5964771\",\n \"0.595493\",\n \"0.5916189\",\n \"0.59153\",\n \"0.59113973\",\n \"0.59004\",\n \"0.58809906\",\n \"0.58754313\",\n \"0.58747846\",\n \"0.582057\",\n \"0.58163416\",\n \"0.58089936\",\n \"0.58010894\",\n \"0.58003974\",\n \"0.57948494\",\n \"0.5791945\",\n \"0.5783539\",\n \"0.57802075\",\n \"0.5771125\",\n \"0.5771125\",\n \"0.5730976\",\n \"0.5730611\",\n \"0.5730392\",\n \"0.5715655\",\n \"0.57037824\",\n \"0.5683051\",\n \"0.5679401\",\n \"0.5664308\",\n \"0.5656942\",\n \"0.56427926\",\n \"0.5639349\",\n \"0.5634616\",\n \"0.5632498\",\n \"0.56183493\",\n \"0.56152016\",\n \"0.5606799\",\n \"0.5600335\",\n \"0.5597365\",\n \"0.5593238\",\n \"0.5584068\",\n \"0.5580936\",\n \"0.55809045\",\n \"0.5572974\",\n \"0.55711544\",\n \"0.5564558\",\n \"0.5562927\",\n \"0.5550785\",\n \"0.5545328\",\n \"0.5539518\",\n \"0.5537358\",\n \"0.55259174\",\n \"0.55178183\",\n \"0.55173546\",\n \"0.5515816\",\n \"0.55148697\",\n \"0.55134964\",\n \"0.5508634\",\n \"0.5506988\",\n \"0.5502089\",\n \"0.5497682\",\n \"0.54907286\",\n \"0.5489433\",\n \"0.54887486\",\n \"0.5487504\",\n \"0.548499\",\n \"0.54726017\",\n \"0.54694635\",\n \"0.54690355\",\n \"0.54690355\",\n \"0.5469019\",\n \"0.5469019\",\n \"0.5468359\",\n \"0.5458814\",\n \"0.5456966\",\n \"0.5455041\",\n \"0.54534006\",\n \"0.5443641\",\n \"0.54420817\",\n \"0.5437112\",\n \"0.5430395\",\n \"0.542536\",\n \"0.5422047\",\n \"0.5421261\",\n \"0.5421261\",\n \"0.5416444\",\n \"0.5416299\",\n \"0.54126865\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83169,"cells":{"query":{"kind":"string","value":"Computes the first derivatives of the proximity operator of the log barrier with respect to x and gamma_mu. This method is automatically called by the backward method of the loss function."},"document":{"kind":"string","value":"def backward(ctx, grad_output_var):\n xmin = 0\n xmax = 1\n grad_output = grad_output_var.data\n gamma_mu,kappa,uTx,x = ctx.saved_tensors\n n = kappa.size()[0]\n nx = grad_output.size()[2]\n u = 1/nx**2*torch.linspace(1,nx,nx)\n norm_u = torch.norm(u)**2\n torch_u = u.view(1,1,-1)+torch.zeros(n,1,nx)#broadcast\n denom = (xmin-kappa)*(xmax-kappa)\\\n -(kappa-uTx)*(xmin+xmax-2*kappa)\\\n -2*gamma_mu*norm_u \n #\n idx = (denom.abs()>1e-7)\n ind = (denom.abs()>1e-7)+ torch.zeros(n,1,nx)#broadcasting\n ind = ind>0\n denom[~idx] = denom[~idx]+1\n grad_input_gamma_mu = (2*kappa-(xmin+xmax))/denom*torch_u\n coeff = (xmax-kappa)*(xmin-kappa)/denom - 1\n grad_input_u = torch.eye(nx) \\\n +coeff*torch.matmul(torch_u.view(1,1,-1,1),u.view(1,-1))/norm_u\n # if denom is very small, it means that gamma_mu is very small and u is very close to one of the bounds,\n # there is a discontinuity when gamma_mu tends to zero, if 0<u<1 the derivative wrt x is approximately equal to \n # 1 and the derivative wrt gamma_mu is approximated by 10^3 times the error 2kappa-xmin-xmax\n grad_input_gamma_mu[~ind] = 0*grad_input_gamma_mu[~ind]+1e3*(2*kappa[~idx]-(xmin+xmax))\n grad_input_u[~ind] = 0*grad_input_u[~ind]+1\n \n grad_input_gamma_mu = grad_input_gamma_mu*grad_output#.sum(1).sum(1).unsqueeze(1).unsqueeze(2)\n grad_input_u = grad_input_u*grad_output\n \n # safety check for numerical instabilities\n if (grad_input_gamma_mu!=grad_input_gamma_mu).any():\n print('there is a nan in grad_input_gamma_mu')\n if (x!=x).any():\n print('there is a nan in x')\n sys.exit()\n if (grad_input_u!=grad_input_u).any():\n print('there is a nan in grad_input_u')\n sys.exit()\n \n grad_input_gamma_mu = Variable(grad_input_gamma_mu,requires_grad=True)\n grad_input_u = Variable(grad_input_u,requires_grad=True)\n \n return grad_input_gamma_mu, grad_input_u, None"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _forward_log_det_jacobian(self, x):\n d = self._compute_shared(x=x)\n relx = (x - d.x_k) / d.w_k\n relx = relx # tf.where(d.out_of_bounds, 0.5*tf.ones_like(x), relx)\n grad = (\n 2 * tf.math.log(d.s_k) +\n tf.math.log(d.d_kp1 * relx**2 + 2 * d.s_k * relx * (1 - relx) + # newln\n d.d_k * (1 - relx)**2) -\n 2 * tf.math.log((d.d_kp1 + d.d_k - 2 * d.s_k) * relx *\n (1 - relx) + d.s_k))\n return grad # tf.where(d.out_of_bounds, tf.zeros_like(grad), grad)","def log_prob(self, x):\n z, log_det = self.backward_p(x)\n return self.prior.log_prob(z) + log_det","def _log_prior_gradients(self):\n x = self._get_params()\n ret = np.zeros(x.size)\n [np.put(ret,i,p.lnpdf_grad(xx)) for i,(p,xx) in enumerate(zip(self.priors,x)) if not p is None]\n return ret","def log_pdf_derivative(x):\n return gs.autodiff.jacobian(log_pdf_at_x(x))(base_point)","def log_prior_grad(self, inputs):","def _call(self, x):\n if functional.prior is None:\n tmp = np.log(x)\n else:\n tmp = np.log(x / functional.prior)\n\n if np.all(np.isfinite(tmp)):\n return tmp\n else:\n # The derivative is not defined.\n raise ValueError('The gradient of the Kullback-Leibler '\n 'Cross Entropy functional is not defined '\n 'for `x` with one or more components '\n 'less than or equal to zero.'.format(x))","def grad_log(self, X):\n # \"\"\"\n # Evaluate the gradients (with respect to the input) of the log density at\n # each of the n points in X. This is the score function.\n\n # X: n x d numpy array.\n XB = np.dot(X, self.B)\n Y = 0.5*XB + self.c\n E2y = np.exp(2*Y)\n # n x dh\n Phi = old_div((E2y-1.0),(E2y+1))\n # n x dx\n T = np.dot(Phi, 0.5*self.B.T)\n S = self.b - X + T\n return S","def objective_and_gradients(self, x):\r\n\r\n try:\r\n self._set_params_transformed(x)\r\n obj_f = -self.log_likelihood() - self.log_prior()\r\n self._fail_count = 0\r\n obj_grads = -self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients())\r\n except (LinAlgError, ZeroDivisionError, ValueError) as e:\r\n if self._fail_count >= self._allowed_failures:\r\n raise e\r\n self._fail_count += 1\r\n obj_f = np.inf\r\n obj_grads = np.clip(-self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients()), -1e100, 1e100)\r\n return obj_f, obj_grads","def log_forward_computations(self, x: list): \n n_x = len(x)\n \n # log_f_x initialized to -Inf because log(0) = -Inf\n log_f_x = np.zeros((self.n_states, n_x)) + logzero()\n x_emission_scores = np.array([self.scores['emission'][:, self.word_to_pos[w] if w in list(self.word_to_pos.keys()) else self.word_to_pos['UnknownWord']] for w in x]).T\n \n log_f_x[:,0] = x_emission_scores[:, 0] + self.scores['initial']\n \n for i in range(1,n_x):\n for s in range(self.n_states):\n log_f_x[s,i] = logsumexp(self.scores['transition'][s,:] + \n log_f_x[:,i-1]) + x_emission_scores[s, i]\n\n \n log_likelihood = logsumexp(self.scores['final'] + log_f_x[:,-1])\n \n return log_f_x, log_likelihood","def _log_posterior_x(self, X):\r\n LL = self.log_likelihood(X=X)\r\n LP = self._log_prior_x(X)\r\n return LL + LP","def objective_function_gradients(self, x):\n self._set_params_transformed(x)\n LL_gradients = self._transform_gradients(self._log_likelihood_gradients())\n prior_gradients = self._transform_gradients(self._log_prior_gradients())\n return - LL_gradients - prior_gradients","def _log_prior_gradients(self):\r\n if self.priors is None:\r\n return 0.\r\n x = self._get_params()\r\n ret = np.zeros(x.size)\r\n [np.put(ret, i, p.lnpdf_grad(xx)) for i, (p, xx) in enumerate(zip(self.priors, x)) if not p is None]\r\n return ret","def log_likelihood(self, theta, x, **kwargs):\n\n u, logdet_dudx, log_a = self.forward(theta, x, **kwargs)\n\n constant = float(-0.5 * self.n_inputs * np.log(2.0 * np.pi))\n # log_likelihood = torch.log(torch.sum(torch.exp(log_a - 0.5 * u ** 2 + logdet_dudx), dim=2))\n log_likelihood = torch.logsumexp(log_a - 0.5 * u**2 + logdet_dudx, dim=2)\n log_likelihood = constant + torch.sum(log_likelihood, dim=1)\n\n return u, log_likelihood","def _log_prior_gradients(self):\n if self.priors.size == 0:\n return 0.\n x = self.param_array\n ret = np.zeros(x.size)\n #compute derivate of prior density\n [np.put(ret, ind, p.lnpdf_grad(x[ind])) for p, ind in self.priors.items()]\n #add in jacobian derivatives if transformed\n priored_indexes = np.hstack([i for p, i in self.priors.items()])\n for c,j in self.constraints.items():\n if not isinstance(c, Transformation):continue\n for jj in j:\n if jj in priored_indexes:\n ret[jj] += c.log_jacobian_grad(x[jj])\n return ret","def _call(self, x):\n if self.prior is None:\n tmp = ((x - 1 - np.log(x)).inner(self.domain.one()))\n else:\n # This is the old line from odl version 0.6.0.\n # tmp = ((x - self.prior + self.prior * np.log(self.prior / x))\n tmp = ((x - self.prior + self.prior * np.log((self.prior + 1e-12) / x))\n .inner(self.domain.one()))\n if np.isnan(tmp):\n # In this case, some element was less than or equal to zero\n return np.inf\n else:\n return tmp","def grad_log(self, X):\n g = autograd.elementwise_grad(self.log_den)\n G = g(X)\n return G","def _log_posterior_x(self, X):\n if self.marginalize:\n LL = self.log_marginal_likelihood(X, self.W)\n else:\n LL = self.log_likelihood(X=X)\n LP = self._log_prior_x(X)\n return LL + LP","def logistic_loss_step(x_, rho, X, y, tensor_name, calculate_by_hand=True):\n\n if calculate_by_hand:\n # prob = torch.exp( -y * X.mm(x_.data))\n prob = torch.exp( -y * torch.matmul(X, x_.data))\n alpha = prob / (1+prob)\n x_.grad = rho * x_.data - torch.mean(alpha*y*X, dim = 0).reshape(-1,1)\n return\n\n else:\n if os.getenv('BLUEFOG_TIMELINE'):\n with bf.timeline_context(tensor_name=tensor_name,\n activity_name=\"gradient computation\"):\n loss_ = torch.mean(torch.log(1 + torch.exp(-y*X.mm(x_)))) + \\\n 0.5*rho*torch.norm(x_, p=2)\n loss_.backward()\n else:\n loss_ = torch.mean(torch.log(1 + torch.exp(-y*X.mm(x_)))) + \\\n 0.5*rho*torch.norm(x_, p=2)\n loss_.backward()\n return","def backward_p(self, x):\n log_det_jacob, z = x.new_zeros(x.shape[0]), x\n for i in reversed(range(len(self.t))):\n z_ = self.mask[i] * z\n s = self.s[i](z_) * (1 - self.mask[i])\n t = self.t[i](z_) * (1 - self.mask[i])\n z = (1 - self.mask[i]) * (z - t) * torch.exp(-s) + z_\n log_det_jacob -= s.sum(dim=1)\n return z, log_det_jacob","def log_prior(x):\n logp = (-0.5 * x.pow(2) - torch.tensor(2 * math.pi).sqrt().log()).sum(dim=1)\n return logp","def step(self, x):\r\n y,mean,stddev_p,z,xhat=self.forward(x)\r\n L_rec=self.loss_fn(x,xhat)\r\n\r\n var = torch.exp(stddev_p)\r\n s = torch.log(var) - torch.pow(mean,2) - var\r\n s = self.latent_dim + torch.sum(s, 1)\r\n s = -0.5*s\r\n s = self.lam*s \r\n L_kl = s.mean()\r\n \r\n \r\n L=L_kl+L_rec\r\n\r\n L.backward()\r\n self.opt.step()\r\n self.opt.zero_grad()\r\n \r\n return L_rec,L_kl,L","def log_likelihood(self, x):\n return self.log_likelihood_exp(x) + self.log_prior_nuisance_parameters(x)","def objective_function_gradients(self, x):\r\n try:\r\n self._set_params_transformed(x)\r\n obj_grads = -self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients())\r\n self._fail_count = 0\r\n except (LinAlgError, ZeroDivisionError, ValueError) as e:\r\n if self._fail_count >= self._allowed_failures:\r\n raise e\r\n self._fail_count += 1\r\n obj_grads = np.clip(-self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients()), -1e100, 1e100)\r\n return obj_grads","def _logprob_X(self, X, **kwargs):\n pass","def _estimate_log_prob(self, x):\n x = self.check_size(x)\n\n if self.covariance_type == \"full\":\n mu = self.mu\n var = self.var\n precision = tf.linalg.inv(var)\n d = x.shape[-1]\n\n log_2pi = d * tf.math.log(2. * pi)\n log_2pi = tf.cast(log_2pi, tf.double)\n log_det = self._calculate_log_det(precision)\n log_det = tf.cast(log_det, tf.double)\n\n\n x = tf.cast(x, tf.double)\n mu = tf.cast(mu, tf.double)\n x_mu_T = tf.expand_dims((x - mu), -2)\n x_mu = tf.expand_dims((x - mu), -1)\n\n x_mu_T_precision = calculate_matmul_n_times(self.n_components, x_mu_T, precision)\n # print(x_mu_T_precision, x_mu_T, x, mu)\n x_mu_T_precision_x_mu = calculate_matmul(x_mu_T_precision, x_mu)\n\n return -.5 * (log_2pi - log_det + x_mu_T_precision_x_mu)\n\n elif self.covariance_type == \"diag\":\n mu = self.mu\n prec = tf.math.rsqrt(self.var)\n\n log_p = tf.math.reduce_sum((mu * mu + x * x - 2 * x * mu) * (prec ** 2), axis=2, keepdims=True)\n log_det = tf.math.reduce_sum(tf.math.log(prec), axis=2, keepdims=True)\n\n return -.5 * (self.n_features * tf.math.log(2. * pi) + log_p) + log_det","def G_pre_step(self, x: tf.Tensor, y: tf.Tensor) -> None:\n\n with tf.GradientTape() as tape:\n logits, _, _ = self.G(x)\n\n loss = tf.reduce_mean(\n tf.nn.sparse_softmax_cross_entropy_with_logits(y, logits)\n )\n\n gradients = tape.gradient(loss, self.G.trainable_variables)\n\n self.P_optimizer.apply_gradients(zip(gradients, self.G.trainable_variables))\n\n self.G_loss.update_state(loss)","def log_likelihood_grad_rew(self, data, reward_model, bias_params):","def convertLaguerreToGamma(self,x):\n return x/self.beta+self.low","def log_gamma_unnormalised_lpdf(x, alpha, beta):\n return alpha * x - beta * tf.exp(x)","def calc_gamma_1d(x, fx, dfx, y, fpy, dfpy):\n beta = calc_beta(fx, dfx)\n print ' using beta = ', beta\n # upper and lower bounds\n sorted_x = numpy.array(sorted(x))\n sorted_y = numpy.array(sorted(y))\n if y.size == 0:\n delta_max = x.max() - x.min()\n delta_min = (sorted_x[1:] - sorted_x[:-1]).min()\n else:\n delta_max = max(x.max(), y.max()) - min(x.min(), y.min())\n delta_min = min((sorted_x[1:] - sorted_x[:-1]).min(), \\\n (sorted_y[1:] - sorted_y[:-1]).min())\n assert delta_max > delta_min\n gamma_min = 1. / delta_max\n gamma_max = pi / delta_min\n # logorithmic bisection for gamma\n while gamma_max / gamma_min > 1.1:\n print ' bisecting [', gamma_min, ',', gamma_max, '] for gamma...'\n gamma_mid = sqrt(gamma_max * gamma_min)\n res_ratio = calc_res_ratio_avg_1d(beta, gamma_mid, x, fx, dfx, y, fpy, dfpy)\n if res_ratio < 1.0:\n gamma_max = gamma_mid\n else:\n gamma_min = gamma_mid\n # final selected gamma\n gamma_mid = sqrt(gamma_max * gamma_min)\n print ' using gamma = ', gamma_mid\n return gamma_mid","def lorentz(x, x0, gamma): \n return (0.5/pi) * gamma / ((x-x0)**2 + 0.25 * gamma**2)","def logpdf(self, x):\n if self.transform is not None:\n x = self.transform(x) \n return (-self.alpha-1)*np.log(x) - (self.beta/float(x))","def formula(self, x: np.ndarray, gamma: float = None) -> np.ndarray:\n gamma = gamma or self.gamma\n Li = self._vpolylog(gamma, 1 - x)\n A = 1 / float(zeta(gamma).real)\n y = 1 - A * Li\n return y","def deriv(self, x, amplitude, x_0, gamma, alpha):\n d_A = (1 + (x - x_0) ** 2 / gamma ** 2) ** (-alpha)\n d_x_0 = - amplitude * alpha * d_A * (-2 * x + 2 * x_0) / (gamma ** 2 * d_A ** alpha)\n d_gamma = 2 * amplitude * alpha * d_A * (x - x_0) ** 2 / (gamma ** 3 * d_A ** alpha)\n d_alpha = -amplitude * d_A * np.log(1 + (x - x_0) ** 2 / gamma ** 2)\n return [d_A, d_x_0, d_gamma, d_alpha]","def log_likelihood(self) -> tf.Tensor:\n # K⁻¹ + GᵀΣ⁻¹G = LLᵀ.\n l_post = self._k_inv_post.cholesky\n num_data = self.observations_index.shape[0]\n\n # Hμ [..., num_transitions + 1, output_dim]\n marginal = self.emission.project_state_to_f(self.prior_ssm.marginal_means)\n marginal = self._drop_batch_shape(marginal)\n\n # y = obs - Hμ [..., num_transitions + 1, output_dim]\n disp = self.observations - marginal\n disp_data = self.sparse_observations - self.dense_to_sparse(marginal)\n\n # cst is the constant term for a gaussian log likelihood\n cst = (\n -0.5 * np.log(2 * np.pi) * tf.cast(self.emission.output_dim * num_data, default_float())\n )\n\n term1 = -0.5 * tf.reduce_sum(\n input_tensor=tf.einsum(\"...op,...p,...o->...o\", self._r_inv_data, disp_data, disp_data), axis=[-1, -2]\n )\n\n # term 2 is: ½|L⁻¹(GᵀΣ⁻¹)y|²\n # (GᵀΣ⁻¹)y [..., num_transitions + 1, state_dim]\n obs_proj = self._back_project_y_to_state(disp)\n\n # ½|L⁻¹(GᵀΣ⁻¹)y|² [...]\n term2 = 0.5 * tf.reduce_sum(\n input_tensor=tf.square(l_post.solve(obs_proj, transpose_left=False)), axis=[-1, -2]\n )\n\n ## term 3 is: ½log |K⁻¹| - log |L| + ½ log |Σ⁻¹|\n # where log |Σ⁻¹| = num_data * log|R⁻¹|\n term3 = (\n 0.5 * self.prior_ssm.log_det_precision()\n - l_post.abs_log_det()\n + 0.5 * self._log_det_observation_precision\n )\n\n return tf.reduce_sum(cst + term1 + term2 + term3)","def f(self, x):\n error = log_likelihood_calc(x[1], x[0], self.data)\n return error","def forward_backward(self, O):\n alpha, B, _Z_ = self.forward(O)\n beta = self.backward(O, B)\n gamma = alpha + beta # This must be a sum because what is stored in 'alpha' and 'beta' are logarithms of probabilities\n # Gamma must be normalized by means of P(O|lambda) : _Z_ = log P(O|lambda)\n gamma = gamma - _Z_\n if _Z_.min() != _Z_.min():\n print('gamma.min()', gamma.min())\n print('gamma.max()', gamma.max())\n print('_Z_.min()', _Z_.min())\n print('_Z_.max()', _Z_.max(), flush = True)\n raise Exception(\"nan appeared\")\n\n return alpha, beta, gamma, B, _Z_","def lorentz(x, gamma):\n return 1 / cs.pi * 0.5 * gamma / ((0.5 * gamma**2) + x**2)","def lgamma(x):\n return 0.0","def MvNormalLogp():\n cov = pt.matrix(\"cov\")\n cov.tag.test_value = floatX(np.eye(3))\n delta = pt.matrix(\"delta\")\n delta.tag.test_value = floatX(np.zeros((2, 3)))\n\n cholesky = Cholesky(lower=True, on_error=\"nan\")\n\n n, k = delta.shape\n n, k = f(n), f(k)\n chol_cov = cholesky(cov)\n diag = pt.diag(chol_cov)\n ok = pt.all(diag > 0)\n\n chol_cov = pt.switch(ok, chol_cov, pt.fill(chol_cov, 1))\n delta_trans = solve_lower(chol_cov, delta.T).T\n\n result = n * k * pt.log(f(2) * np.pi)\n result += f(2) * n * pt.sum(pt.log(diag))\n result += (delta_trans ** f(2)).sum()\n result = f(-0.5) * result\n logp = pt.switch(ok, result, -np.inf)\n\n def dlogp(inputs, gradients):\n (g_logp,) = gradients\n cov, delta = inputs\n\n g_logp.tag.test_value = floatX(1.0)\n n, k = delta.shape\n\n chol_cov = cholesky(cov)\n diag = pt.diag(chol_cov)\n ok = pt.all(diag > 0)\n\n chol_cov = pt.switch(ok, chol_cov, pt.fill(chol_cov, 1))\n delta_trans = solve_lower(chol_cov, delta.T).T\n\n inner = n * pt.eye(k) - pt.dot(delta_trans.T, delta_trans)\n g_cov = solve_upper(chol_cov.T, inner)\n g_cov = solve_upper(chol_cov.T, g_cov.T)\n\n tau_delta = solve_upper(chol_cov.T, delta_trans.T)\n g_delta = tau_delta.T\n\n g_cov = pt.switch(ok, g_cov, -np.nan)\n g_delta = pt.switch(ok, g_delta, -np.nan)\n\n return [-0.5 * g_cov * g_logp, -g_delta * g_logp]\n\n return OpFromGraph([cov, delta], [logp], grad_overrides=dlogp, inline=True)","def _inverse_log_det_jacobian(self, x):\n alpha, beta = self._get_alpha_beta()\n diff = x - self.x0\n r = tf.linalg.norm(diff, axis=-1, keepdims=True)\n h = 1. / (alpha + r)\n h_prime = -(h ** 2)\n beta_h = beta * h\n log_det_jacobian = tf.reduce_sum(\n (self.dim - 1) * tf.math.log1p(beta_h)\n + tf.math.log1p(beta_h + beta * h_prime * r), axis=-1)\n return log_det_jacobian","def forward(self, x):\n o = torch.clamp(\n 1 / (1 + torch.exp(-self.k * (x - self.x0))), min=0, max=1\n ).squeeze()\n return o","def log_likelihood_gradients_(self, y, f):\n log_lik = self.evaluate_log_likelihood(y, f)\n f = np.squeeze(f)\n J = jacrev(self.evaluate_log_likelihood, argnums=1)\n H = jacrev(J, argnums=1)\n return log_lik, J(y, f), H(y, f)","def leapfrog(params, momentum, log_prob_func, steps=10, step_size=0.1, jitter=0.01, normalizing_const=1., softabs_const=1e6, explicit_binding_const=100, fixed_point_threshold=1e-20, fixed_point_max_iterations=6, jitter_max_tries=10, inv_mass=None, ham_func=None, sampler=Sampler.HMC, integrator=Integrator.IMPLICIT, metric=Metric.HESSIAN, store_on_GPU = True, debug=False, pass_grad = None):\n\n params = params.clone(); momentum = momentum.clone()\n # TodO detach graph when storing ret_params for memory saving\n if sampler == Sampler.HMC and integrator != Integrator.SPLITTING and integrator != Integrator.SPLITTING_RAND and integrator != Integrator.SPLITTING_KMID:\n def params_grad(p):\n p = p.detach().requires_grad_()\n log_prob = log_prob_func(p)\n # log_prob.backward()\n p = collect_gradients(log_prob, p, pass_grad)\n # print(p.grad.std())\n if torch.cuda.is_available():\n torch.cuda.empty_cache()\n return p.grad\n ret_params = []\n ret_momenta = []\n momentum += 0.5 * step_size * params_grad(params)\n for n in range(steps):\n if inv_mass is None:\n params = params + step_size * momentum #/normalizing_const\n else:\n #Assum G is diag here so 1/Mass = G inverse\n if type(inv_mass) is list:\n i = 0\n for block in inv_mass:\n it = block[0].shape[0]\n params[i:it+i] = params[i:it+i] + step_size * torch.matmul(block,momentum[i:it+i].view(-1,1)).view(-1) #/normalizing_const\n i += it\n elif len(inv_mass.shape) == 2:\n params = params + step_size * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params = params + step_size * inv_mass * momentum #/normalizing_const\n p_grad = params_grad(params)\n momentum += step_size * p_grad\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n # only need last for Hamiltoninian check (see p.14) https://arxiv.org/pdf/1206.1901.pdf\n ret_momenta[-1] = ret_momenta[-1] - 0.5 * step_size * p_grad.clone()\n # import pdb; pdb.set_trace()\n return ret_params, ret_momenta\n elif sampler == Sampler.RMHMC and (integrator == Integrator.IMPLICIT or integrator == Integrator.S3):\n if integrator is not Integrator.S3:\n ham_func = None\n # Else we are doing semi sep and need auxiliary for Riemann version.\n if pass_grad is not None:\n raise RuntimeError('Passing user-determined gradients not implemented for RMHMC')\n\n def fixed_point_momentum(params, momentum):\n momentum_old = momentum.clone()\n # print('s')\n for i in range(fixed_point_max_iterations):\n momentum_prev = momentum.clone()\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n params = collect_gradients(ham, params)\n\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\n tries = 0\n while util.has_nan_or_inf(params.grad):\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n params = collect_gradients(ham, params)\n tries += 1\n if tries > jitter_max_tries:\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\n # import pdb; pdb.set_trace()\n raise util.LogProbError()\n # import pdb; pdb.set_trace()\n # break\n\n momentum = momentum_old - 0.5 * step_size * params.grad\n momenta_diff = torch.max((momentum_prev-momentum)**2)\n if momenta_diff < fixed_point_threshold:\n break\n if debug == 1:\n print('Converged (momentum), iterations: {}, momenta_diff: {}'.format(i, momenta_diff))\n return momentum\n\n def fixed_point_params(params, momentum):\n params_old = params.clone()\n momentum = momentum.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n momentum = collect_gradients(ham,momentum)\n momentum_grad_old = momentum.grad.clone()\n for i in range(fixed_point_max_iterations):\n params_prev = params.clone()\n momentum = momentum.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n momentum = collect_gradients(ham,momentum)#collect_gradients(ham, params)\n params = params_old + 0.5 * step_size * momentum.grad + 0.5 * step_size * momentum_grad_old\n params_diff = torch.max((params_prev-params)**2)\n if params_diff < fixed_point_threshold:\n break\n if debug == 1:\n print('Converged (params), iterations: {}, params_diff: {}'.format(i, params_diff))\n return params\n ret_params = []\n ret_momenta = []\n for n in range(steps):\n # import pdb; pdb.set_trace()\n momentum = fixed_point_momentum(params, momentum)\n params = fixed_point_params(params, momentum)\n\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n params = collect_gradients(ham, params)\n\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\n tries = 0\n while util.has_nan_or_inf(params.grad):\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n params = collect_gradients(ham, params)\n tries += 1\n if tries > jitter_max_tries:\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\n raise util.LogProbError()\n # break\n momentum -= 0.5 * step_size * params.grad\n\n ret_params.append(params)\n ret_momenta.append(momentum)\n return ret_params, ret_momenta\n\n elif sampler == Sampler.RMHMC and integrator == Integrator.EXPLICIT:\n if pass_grad is not None:\n raise RuntimeError('Passing user-determined gradients not implemented for RMHMC')\n\n #During leapfrog define integrator as implict when passing into riemannian_hamiltonian\n leapfrog_hamiltonian_flag = Integrator.IMPLICIT\n def hamAB_grad_params(params,momentum):\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum.detach(), log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\n params = collect_gradients(ham, params)\n\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\n tries = 0\n while util.has_nan_or_inf(params.grad):\n # import pdb; pdb.set_trace()\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum.detach(), log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\n params = collect_gradients(ham, params)\n tries += 1\n if tries > jitter_max_tries:\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\n raise util.LogProbError()\n # import pdb; pdb.set_trace()\n # break\n\n return params.grad\n def hamAB_grad_momentum(params,momentum):\n momentum = momentum.detach().requires_grad_()\n params = params.detach().requires_grad_()\n # Can't detach p as we still need grad to do derivatives\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\n # import pdb; pdb.set_trace()\n momentum = collect_gradients(ham,momentum)\n return momentum.grad\n ret_params = []\n ret_momenta = []\n params_copy = params.clone()\n momentum_copy = momentum.clone()\n for n in range(steps):\n # \\phi_{H_A}\n momentum = momentum - 0.5 * step_size * hamAB_grad_params(params,momentum_copy)\n params_copy = params_copy + 0.5 * step_size * hamAB_grad_momentum(params,momentum_copy)\n # \\phi_{H_B}\n params = params + 0.5 * step_size * hamAB_grad_momentum(params_copy,momentum)\n momentum_copy = momentum_copy - 0.5 * step_size * hamAB_grad_params(params_copy,momentum)\n # \\phi_{H_C}\n c = torch.cos(torch.FloatTensor([2* explicit_binding_const * step_size])).to(params.device)\n s = torch.sin(torch.FloatTensor([2* explicit_binding_const * step_size])).to(params.device)\n # params_add = params + params_copy\n # params_sub = params - params_copy\n # momentum_add = momentum + momentum_copy\n # momentum_sub = momentum - momentum_copy\n # ### CHECK IF THE VALUES ON THE RIGHT NEED TO BE THE OLD OR UPDATED ones\n # ### INSTINCT IS THAT USING UPDATED ONES IS BETTER\n # params = 0.5 * ((params_add) + c*(params_sub) + s*(momentum_sub))\n # momentum = 0.5 * ((momentum_add) - s*(params_sub) + c*(momentum_sub))\n # params_copy = 0.5 * ((params_add) - c*(params_sub) - s*(momentum_sub))\n # momentum_copy = 0.5 * ((momentum_add) + s*(params_sub) - c*(momentum_sub))\n params = 0.5 * ((params+params_copy) + c*(params-params_copy) + s*(momentum-momentum_copy))\n momentum = 0.5 * ((momentum+momentum_copy) - s*(params-params_copy) + c*(momentum-momentum_copy))\n params_copy = 0.5 * ((params+params_copy) - c*(params-params_copy) - s*(momentum-momentum_copy))\n momentum_copy = 0.5 * ((momentum+momentum_copy) + s*(params-params_copy) - c*(momentum-momentum_copy))\n\n\n # \\phi_{H_B}\n params = params + 0.5 * step_size * hamAB_grad_momentum(params_copy,momentum)\n momentum_copy = momentum_copy - 0.5 * step_size * hamAB_grad_params(params_copy,momentum)\n # \\phi_{H_A}\n momentum = momentum - 0.5 * step_size * hamAB_grad_params(params,momentum_copy)\n params_copy = params_copy + 0.5 * step_size * hamAB_grad_momentum(params,momentum_copy)\n\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n return [ret_params,params_copy], [ret_momenta, momentum_copy]\n\n # PAGE 35 MCMC Using Hamiltonian dynamics (Neal 2011)\n elif sampler == Sampler.HMC and (integrator == Integrator.SPLITTING or integrator == Integrator.SPLITTING_RAND or Integrator.SPLITTING_KMID):\n if type(log_prob_func) is not list:\n raise RuntimeError('For splitting log_prob_func must be list of functions')\n if pass_grad is not None:\n raise RuntimeError('Passing user-determined gradients not implemented for splitting')\n\n def params_grad(p,log_prob_func):\n # OLD:\n # p = p.detach().requires_grad_()\n # log_prob = log_prob_func(p)\n # # log_prob.backward()\n # p = collect_gradients(log_prob, p)\n # grad = p.grad\n # # For removing GPU memory for large data sets.\n # del p, log_prob\n # torch.cuda.empty_cache()\n\n p = p.detach().requires_grad_()\n log_prob = log_prob_func(p)\n # Need to check memory issues in collect_gradients\n grad = torch.autograd.grad(log_prob,p)[0]\n # For removing GPU memory for large data sets.\n del p, log_prob, log_prob_func\n torch.cuda.empty_cache()\n return grad\n\n params = params.detach() # Detach as we do not need to remember graph until we pass into log_prob\n ret_params = []\n ret_momenta = []\n if integrator == Integrator.SPLITTING:\n M = len(log_prob_func)\n K_div = (M - 1) * 2\n if M == 1:\n raise RuntimeError('For symmetric splitting log_prob_func must be list of functions greater than length 1')\n for n in range(steps):\n # Symmetric loop to ensure reversible\n for m in range(M):\n # print('p ',n)\n grad = params_grad(params,log_prob_func[m])\n with torch.no_grad():\n momentum += 0.5 * step_size * grad\n del grad\n if torch.cuda.is_available():\n torch.cuda.empty_cache()\n if m < M-1:\n # print('q ',n)\n if inv_mass is None:\n params += (step_size/K_div) * momentum #/normalizing_const\n else:\n if type(inv_mass) is list:\n pass\n #Assum G is diag here so 1/Mass = G inverse\n elif len(inv_mass.shape) == 2:\n params += (step_size/K_div) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params += (step_size/K_div) * inv_mass * momentum #/normalizing_const\n for m in reversed(range(M)):\n # print('p ', n )\n grad = params_grad(params,log_prob_func[m])\n with torch.no_grad():\n momentum += 0.5 * step_size * grad\n del grad\n if torch.cuda.is_available():\n torch.cuda.empty_cache()\n if m > 0:\n # print('q ', n-1)\n if inv_mass is None:\n params += (step_size/K_div) * momentum #/normalizing_const\n else:\n if type(inv_mass) is list:\n pass\n #Assum G is diag here so 1/Mass = G inverse\n elif len(inv_mass.shape) == 2:\n params += (step_size/K_div) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params += (step_size/K_div) * inv_mass * momentum #/normalizing_const\n\n if store_on_GPU:\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n else:\n ret_params.append(params.clone().cpu())\n ret_momenta.append(momentum.clone().cpu())\n elif integrator == Integrator.SPLITTING_RAND:\n M = len(log_prob_func)\n idx = torch.randperm(M)\n for n in range(steps):\n # \"Labelling of subsets is randomised for each iteration\"\n # idx = torch.randperm(M)\n for m in range(M):\n # print('p ',n)\n momentum += 0.5 * step_size * params_grad(params, log_prob_func[idx[m]])\n # print('q ',n)\n if inv_mass is None:\n params += (step_size/M) * momentum #/normalizing_const\n else:\n if type(inv_mass) is list:\n pass\n #Assum G is diag here so 1/Mass = G inverse\n elif len(inv_mass.shape) == 2:\n params += (step_size/M) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params += (step_size/M) * inv_mass * momentum #/normalizing_const\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[idx[m]])\n\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n # import pdb; pdb.set_trace()\n\n\n elif integrator == Integrator.SPLITTING_KMID:\n M = len(log_prob_func)\n if M == 1:\n raise RuntimeError('For symmetric splitting log_prob_func must be list of functions greater than length 1')\n for n in range(steps):\n # Symmetric loop to ensure reversible\n for m in range(M):\n # print('p ',n)\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[m])\n\n if inv_mass is None:\n params = params + (step_size) * momentum #/normalizing_const\n else:\n if type(inv_mass) is list:\n pass\n #Assum G is diag here so 1/Mass = G inverse\n elif len(inv_mass.shape) == 2:\n params = params + (step_size) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params = params + (step_size) * inv_mass * momentum #/normalizing_const\n\n for m in reversed(range(M)):\n # print('p ', n )\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[m])\n\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n\n return ret_params, ret_momenta\n\n else:\n raise NotImplementedError()","def log_target(self, x):\n return self.log_likelihood_exp(x) + self.log_prior_parameters(x) + self.log_prior_wilson_coeffs(x)","def forward(\n self,\n m_q: torch.Tensor,\n logs_q: torch.Tensor,\n m_p: torch.Tensor,\n logs_p: torch.Tensor,\n ) -> torch.Tensor:\n posterior_norm = D.Normal(m_q, torch.exp(logs_q))\n prior_norm = D.Normal(m_p, torch.exp(logs_p))\n loss = D.kl_divergence(posterior_norm, prior_norm).mean()\n return loss","def div_loss(gamma, model):\n\n def loss(data, y_pred):\n # TODO: Try using points other than the training data points for the divergence calculation.\n \"\"\"Punish non-zero divergence. Each input of size N (batch size) is expanded into\n 4 sets of surrounding points, p1, p2, p3, and p4, where the elements pj_i (j = 1,2,3,4 and\n i = 1,2,3...N) are defined according to:\n\n y\n | p2_i\n |\n | p1_i P_i p3_i\n |\n ------------- x p4_i\n\n\n The sets p1, p2, p3, and p4 are used in estimating the divergence for each point P_i. The partial\n derivatives are calculated with a three-point centered difference.\n\n The extra points are \"smuggled\" into the loss function in the data argument:\n\n data.head() =\n < y_true > <------ p1 -------> <------- p2 ------> <------- p3 ------> <--------p4 ------>\n | u | v | x1 | y1 | h | x2 | y2 | h | x3 | y3 | h | x4 | y4 | h |\n \"\"\"\n y_true = data[:,:2]\n p1 = data[:,2:5]\n p2 = data[:,5:8]\n p3 = data[:,8:11]\n p4 = data[:,11:14]\n\n ### Calculate divergence using model predictions:\n\n # Step 1: Use the model to calculate predicted wind field in the surrounding points p1, p2, p3 and p4.\n y_pred_p1 = model(p1)\n y_pred_p2 = model(p2)\n y_pred_p3 = model(p3)\n y_pred_p4 = model(p4)\n\n # Step 2: Calculate the partial derivatives with a three-point centered difference.\n scale_x = self.scaler_data.scale_[0] #scale-factor for x\n scale_y = self.scaler_data.scale_[1] #scale-factor for y\n\n dudx = (y_pred_p1[:, 0] - y_pred_p3[:, 0]) / (p1[:,0] - p3[:,0]) # <- pj = transformed data\n dvdy = (y_pred_p2[:, 1] - y_pred_p4[:, 1]) / (p2[:,1] - p4[:,1]) # <- pj = transformed data\n\n # Step 3: Calculate the divergence.\n divergence = ( dudx / scale_x + dvdy / scale_y ) * np.mean([scale_x, scale_y])\n #tf.print(K.mean(K.abs(divergence)))\n\n # Step 4: Calculate and return total loss.\n return K.mean(K.square(y_true - y_pred)) + gamma*K.mean(K.square(divergence))\n return loss","def log(self, x_old, grad, x, curr_iter, tol_g_val, tol_x_val, tol_f_val):\n\n print(\"-----------------------------------\")\n print(\"\\n Iter: \", curr_iter)\n print(\"\\n x_old: \", x_old)\n print(\"\\n gradient: \", grad)\n print(\"\\n x: \", x)\n print(\"\\n tol_x_val: \", tol_x_val)\n print(\"\\n tol_f_val: \", tol_f_val)\n print(\"\\n tol_g_val: %s \\n \" % tol_g_val)","def logp_grad(self, xs, ys, fs, **kwargs):","def _log_likelihood_gradients(self):\r\n return np.hstack((self.kern.dK_dtheta(dL_dK=self.dL_dK, X=self.X), self.likelihood._gradients(partial=np.diag(self.dL_dK))))","def _m_step(self, x, log_resp):\n x = self.check_size(x)\n\n resp = tf.exp(log_resp)\n\n pi = tf.reduce_sum(resp, axis=0, keepdims=True) + self.eps\n\n resp = tf.cast(resp, tf.double)\n pi = tf.cast(pi, tf.double)\n x = tf.cast(x, tf.double)\n\n mu = tf.reduce_sum(resp * x, axis=0, keepdims=True) / pi\n\n if self.covariance_type == \"full\":\n eps = (tf.linalg.eye(self.n_features) * self.eps)\n eps = tf.cast(eps, tf.double)\n\n var = tf.reduce_sum(tf.matmul(tf.expand_dims(x - mu, -1), tf.expand_dims(x - mu, -2)) * tf.expand_dims(resp, -1), axis=0,\n keepdims=True) / tf.expand_dims(tf.reduce_sum(resp, axis=0, keepdims=True), -1) + eps\n elif self.covariance_type == \"diag\":\n x2 = tf.reduce_sum((resp * x * x), axis=0, keepdims=True) / pi\n mu2 = mu * mu\n xmu = tf.reduce_sum((resp * mu * x), axis=0, keepdims=True) / pi\n var = x2 - 2 * xmu + mu2 + self.eps\n\n pi = pi / x.shape[0]\n\n return pi, mu, var","def logm(self, x):\n\n if K.backend() == 'theano':\n # construct theano tensor operation\n from theano.tensor.nlinalg import svd, diag\n from theano.tensor.elemwise import Elemwise\n from theano.scalar import log\n import theano.tensor as T\n # This implementation would be extremely slow. but efficient?\n u, d, v = svd(x)\n d += self.eps\n inner = diag(T.log(d))\n res = T.dot(u, T.dot(inner, v))\n return res\n else:\n from kyu.tensorflow.ops.svd_gradients import batch_matrix_log\n return batch_matrix_log(x, self.eps)","def _optfn(self, x):\n\n logger.debug(\" optfn(theta=%s)\", str(x))\n\n wmx = max(self.weights) * self.weighttrunc\n\n ip = []\n for i,w in enumerate(self.weights):\n if w < wmx:\n continue\n ip.append((i,w,x))\n\n if self.pool is None:\n itr = map(self.worker.loglik_grad, ip)\n else:\n itr = self.pool.imap_unordered(_pool_loglik_grad, ip, 10)\n\n if self._prior_shape is None:\n ll = 0.\n grad = np.zeros(len(x))\n else:\n ll = sum(sp.special.xlogy(self._prior_shape-1,x)-(x/self._prior_scale))\n grad = (self._prior_shape - 1)/x - 1/self._prior_scale\n\n for l,g in itr:\n ll += l\n grad += g\n\n logger.debug(\" optfn=%g\", ll)\n\n return -ll, -grad","def log_pacc(xy, x, y, h):\n logp = log_q(xy, y, x, h)\n logp += xy.log_density(y)\n logp -= log_q(xy, x, y, h)\n logp -= xy.log_density(x)\n return logp","def fgsm(model, x, y, epsilon=0.1, label_leaking=True):\n delta = torch.zeros_like(x, requires_grad=True)\n logits = model(x + delta)\n # Use the model's output instead of the true labels to avoid label leaking at training time.\n if not label_leaking:\n y = logits.max(dim=1)[1]\n loss = nn.CrossEntropyLoss()(logits, y)\n loss.backward()\n return epsilon * delta.grad.detach().sign()","def _call(self, x):\n if self.prior is None:\n tmp = -1.0 * (np.log(1 - x)).inner(self.domain.one())\n else:\n tmp = (-self.prior * np.log(1 - x)).inner(self.domain.one())\n if np.isnan(tmp):\n # In this case, some element was larger than or equal to one\n return np.inf\n else:\n return tmp","def log_probability(self, X):\n\n\t\treturn self.__log_probability(X)","def logaddexp(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n return torch.max(x, y) + torch.log(1 + torch.exp(-torch.abs(y - x)))","def zkl_divergence(x, y, gamma):\n return np.sum([p_i*np.log(p_i/q_i) if q_i > 0 and p_i > 0 else p_i*gamma for (p_i, q_i) in zip(x, y)])","def forward(self, x):\n\n embeds = self.dvector(x)\n logits = self.linear(embeds)\n\n return logits","def calculate_log_q_prior(theta, mu, rho):\n\n sigma = tf.nn.softplus(rho)\n log_qw = tm.log_gaussian(theta, mu, sigma)\n return tf.reduce_sum(log_qw)","def _log_probability(self, theta, model, bounds, x, y, yerr):\n lp = self._log_prior(theta, bounds)\n if not np.isfinite(lp):\n return -np.inf\n return lp + self._log_likelihood(theta, model, x, y, yerr)","def logbarrierfunc(delta, z, use_sigma):\n if use_sigma:\n z = np.where(z >= 0, np.tanh(z), z)\n k = 2\n return np.where(z > delta, -np.log(np.abs(z)),\n ((k - 1) / k) * (((z - k * delta) / ((k - 1) * delta)) ** k - 1) - np.log(delta))","def forward_pass(self, x):\n self.x = x\n exp_x = np.exp(x)\n sum_x = np.sum(axis=1)\n return exp_x/sum_x","def gelu(self, x):\r\n cdf = 0.5 * (1.0 + tf.tanh(\r\n (np.sqrt(2 / np.pi) * (x + 0.044715 * tf.pow(x, 3)))))\r\n return x * cdf","def derivative(self, theta):\n diag_gamma = np.dot(theta.T, self.X.T)\n logistic_term = self.logistic_fn(diag_gamma)\n diag_gamma = logistic_term * (1.0 - logistic_term)\n gamma = np.diag(diag_gamma)\n\n # v computation\n diags_v = 1.0 - 2*self.logistic_fn(np.dot(theta.T, self.X.T))\n diags_v = diags_v.reshape((-1, 1))\n diags_v = diags_v*self.X\n assert diags_v.shape == self.X.shape #N*d shape\n\n XtGamma = np.dot(self.X.T, gamma) # d*N shape\n\n # TODO: Verifier car pas sur de mon coup ... et surtout plus long...\n # id = np.eye(self.n_examples).reshape((self.n_examples, self.n_examples, 1))\n # diags_v = diags_v.reshape((self.n_examples, 1, self.dim))\n # v = id*diags_v # n*n*d tensor\n # left = np.tensordot(XtGamma, v, axes=(1, 0)) # shape d*N*d\n # assert left.shape == (self.dim, self.n_examples, self.dim)\n # dg = np.tensordot(left, self.X, axes=(1, 0))\n # dg = np.swapaxes(dg, axis1=-2, axis2=-1)\n\n dg = np.zeros((self.dim, self.dim, self.dim))\n for idx, v_i_diag in enumerate(diags_v.T):\n v_i = np.diag(v_i_diag)\n dg_di = np.dot(np.dot(XtGamma, v_i), self.X)\n dg[:, :, idx] = dg_di\n return dg","def forward(self, x):\n return F.log_softmax(self.proj(x), dim=-1)","def gradient_model (self, x, initial_weights = None, \\\n step_size = 5.0e-6, tol = 2.5e+7, n_iters = 501, l2 = 0):\n # setup initial intercept, slope, iter number and rss\n if initial_weights is None:\n weights = self.initial_weight\n else:\n weights = initial_weights\n # Compute indicator value for (y_i = +1)\n indicators = np.array([int (i) for i in (self.train_output_y==1)])\n for itr in range(n_iters):\n # Predict P(y_i = +1|x_1,w) using your predict_probability() function\n _, pred_probs = self.predict_probability(self.train_feature_x, weights)\n \n # Compute the errors as indicator - predictions\n errors = indicators - pred_probs\n\n #Update the weights:\n derivative = self.feature_derivative(errors, weights, l2)\n weights = weights + derivative * (step_size) \n \n #check if converged\n #todo\n \"\"\"\n # Checking whether log likelihood is increasing\n if itr <= 15 or (itr <= 100 and itr % 10 == 0) or (itr <= 1000 and itr % 100 == 0) \\\n or (itr <= 10000 and itr % 1000 == 0) or itr % 10000 == 0:\n lp = self.compute_log_likelihood(indicators,weights)\n print 'iteration %*d: log likelihood of observed labels = %.8f' % \\\n (int(np.ceil(np.log10(n_iters))), itr, lp)\n \"\"\"\n \n #check weights\n #print \"\\n\"\n #print \"The weights for features: \", weights\n #final prediction\n preds = self.prediction(x, weights)\n return preds, weights","def loglikelihood(self, x, previous=False):\r\n # testing of original fct: MC integrate must be one: mean(p(x_i)) * volume(where x_i are uniformely sampled)\r\n # for i in range(3): print mean([cma.likelihood(20*r-10, dim * [0], None, 3) for r in rand(10000,dim)]) * 20**dim\r\n # TODO: test this!!\r\n # c=cma.fmin...\r\n # c[3]['cma'].loglikelihood(...)\r\n\r\n if previous and hasattr(self, 'lastiter'):\r\n sigma = self.lastiter.sigma\r\n Crootinv = self.lastiter._Crootinv\r\n xmean = self.lastiter.mean\r\n D = self.lastiter.D\r\n elif previous and self.countiter > 1:\r\n raise _Error('no previous distribution parameters stored, check options importance_mixing')\r\n else:\r\n sigma = self.sigma\r\n Crootinv = self._Crootinv\r\n xmean = self.mean\r\n D = self.D\r\n\r\n dx = array(x) - xmean # array(x) - array(m)\r\n n = self.N\r\n logs2pi = n * log(2*np.pi) / 2.\r\n logdetC = 2 * sum(log(D))\r\n dx = np.dot(Crootinv, dx)\r\n res = -sum(dx**2) / sigma**2 / 2 - logs2pi - logdetC/2 - n*log(sigma)\r\n if 1 < 3: # testing\r\n s2pi = (2*np.pi)**(n/2.)\r\n detC = np.prod(D)**2\r\n res2 = -sum(dx**2) / sigma**2 / 2 - log(s2pi * abs(detC)**0.5 * sigma**n)\r\n assert res2 < res + 1e-8 or res2 > res - 1e-8\r\n return res","def _log_likelihood_gradients(self):\n return np.hstack((self.kern.dK_dtheta(dL_dK=self.dL_dK,X=self.X,slices1=self.Xslices,slices2=self.Xslices), self.likelihood._gradients(partial=np.diag(self.dL_dK))))","def L1_log_likelihood_gradient(X, y, B, lmbda):\n pass","def calc_energy_and_force(self, h, x, beta):\n h = h.clone().detach()\n h.requires_grad_(True)\n log_QhGx = self.encoder.calc_logQhGx(x, h)\n log_Pxh = self.decoder.calc_logPxh(x,h)\n energy = - (beta * log_Pxh + (1-beta)*log_QhGx)\n h_grad = autograd.grad(outputs = energy,\n inputs = h,\n grad_outputs = torch.ones_like(energy))[0]\n return energy.data, h_grad.data, log_QhGx.data, log_Pxh.data","def gamma(x):\n return 0.0","def gelu(x):\n cdf = 0.5 * (1.0 + tf.tanh(\n (np.sqrt(2 / np.pi) * (x + 0.044715 * tf.pow(x, 3)))))\n return x * cdf","def maximize_one(self, gamma, xisum, c, x_digits):\n log_likelihood = np.log(c).sum()\n self._i = gamma[0] / gamma[0].sum()\n self._t = (xisum.T / xisum.sum(1)).T\n self._e = np.dot(x_digits, gamma) / gamma.sum(0)\n return log_likelihood","def _x(rho, z):\r\n a = (1 - 2*rho*z + z**2)**.5 + z - rho\r\n b = 1 - rho\r\n return np.log(a / b)","def forward(ctx,gamma_mu,xtilde,mode_training=True):\n # Device CPU/GPU\n # if device == \"cuda\":\n # dtype = torch.cuda.FloatTensor\n # else :\n dtype = torch.FloatTensor\n #initialize variables\n n,_,nx = xtilde.size()\n x1,x2,x3 = torch.zeros(n,1,1).type(dtype),torch.zeros(n,1,1).type(dtype),torch.zeros(n,1,1).type(dtype) \n crit,crit_compare = torch.zeros(n,1,1).type(dtype),torch.zeros(n,1,1).type(dtype)\n sol = torch.zeros(n,1,nx).type(dtype)\n kappa = torch.zeros(n,1,1).type(dtype)\n xmin = 0\n xmax = 1\n u = 1/nx**2*torch.linspace(1,nx,nx)\n norm_u = torch.norm(u)**2\n uTx = torch.matmul(xtilde,u).view(n,1,1)\n torch_u = u.view(1,1,-1)+torch.zeros(n,1,nx).type(dtype)#broadcast\n torch_one = torch.ones(n,1,1).type(dtype)\n #set coefficients\n a = -(xmin+xmax+uTx)\n b = xmin*xmax + uTx*(xmin+xmax) - 2*gamma_mu*norm_u\n c = gamma_mu*(xmin+xmax)*norm_u - uTx*xmin*xmax\n p = b - (a**2)/3\n q = c - a*b/3 + 2*(a**3)/27\n delta = (p/3)**3 + (q/2)**2\n #three cases depending on the sign of delta\n #########################################################################\n #when delta is positive\n ind = delta>0\n z1 = -q[ind]/2\n z2 = torch.sqrt(delta[ind])\n w = (z1+z2).sign() * torch.pow((z1+z2).abs(),1/3)\n v = (z1-z2).sign() * torch.pow((z1-z2).abs(),1/3) \n x1[ind] = w + v \n x2[ind] = -(w + v)/2 ; #real part of the complex solution\n x3[ind] = -(w + v)/2 ; #real part of the complex solution\n #########################################################################\n #when delta is 0\n ind = delta==0\n x1[ind] = 3 *q[ind] / p[ind]\n x2[ind] = -1.5 * q[ind] / p[ind]\n x3[ind] = -1.5 * q[ind] / p[ind]\n #########################################################################\n #when delta is negative\n ind = delta<0\n cos = (-q[ind]/2) * ((27 / torch.pow(p[ind],3)).abs()).sqrt() \n cos[cos<-1] = 0*cos[cos<-1]-1\n cos[cos>1] = 0*cos[cos>1]+1\n phi = torch.acos(cos)\n tau = 2 * ((p[ind]/3).abs()).sqrt() \n x1[ind] = tau * torch.cos(phi/3) \n x2[ind] = -tau * torch.cos((phi + np.pi)/3)\n x3[ind] = -tau * torch.cos((phi - np.pi)/3)\n #########################################################################\n x1 = x1-a/3\n x2 = x2-a/3\n x3 = x3-a/3\n # when gamma_mu is very small there might be some numerical instabilities\n # in case there are nan values, we set the corresponding pixels equal to 2*xmax\n # these values will be replaced by valid values at least once\n if (x1!=x1).any():\n x1[x1!=x1]=2*xmax\n if (x2!=x2).any():\n x2[x2!=x2]=2*xmax\n if (x3!=x3).any():\n x3[x3!=x3]=2*xmax\n #########################################################################\n #\n sol = xtilde + (x1 - uTx)/norm_u*torch_u\n kappa = x1\n #########################################################################\n #take x1\n p1 = sol\n uTp1 = torch.matmul(p1,u).view(n,1,1)\n ind = (uTp1>xmin)&(uTp1<xmax)\n crit[~ind] = np.inf\n crit[ind] = -(torch.log(uTp1[ind]-xmin)+torch.log(xmax-uTp1[ind]))\n crit = 0.5*torch.norm(p1-xtilde,dim=2).view(n,1,1)**2+gamma_mu*crit \n #########################################################################\n #test x2\n p2 = xtilde + (x2 - uTx)/norm_u*torch_u\n uTp2 = torch.matmul(p2,u).view(n,1,1) \n ind = (uTp2 >xmin)&(uTp2 <xmax)\n crit_compare[~ind] = np.inf\n crit_compare[ind] = -(torch.log(uTp2[ind]-xmin)+torch.log(xmax-uTp2[ind]))\n crit_compare = 0.5*torch.norm(p2-xtilde,dim=2).view(n,1,1)**2+gamma_mu*crit_compare\n # Select solution between p1 and p2\n ind = (crit_compare<=crit) + torch.zeros(n,1,nx)#broadcasting\n ind = ind>0\n sol[ind] = p2[ind]\n kappa[crit_compare<=crit]= x2[crit_compare<=crit]\n crit[crit_compare<=crit] = crit_compare[crit_compare<=crit]\n #########################################################################\n #test x3\n p3 = xtilde + (x3 - uTx)/norm_u*torch_u\n uTp3 = torch.matmul(p3,u).view(n,1,1)\n ind = (uTp3>xmin)&(uTp3<xmax)\n crit_compare[~ind] = np.inf\n crit_compare[ind] = -(torch.log(uTp3[ind]-xmin)+torch.log(xmax-uTp3[ind]))\n crit_compare = 0.5*torch.norm(p3-xtilde,dim=2).view(n,1,1)**2+gamma_mu*crit_compare\n # Select solution between p3 and (p2,p1)\n ind = (crit_compare<=crit)+ torch.zeros(n,1,nx)#broadcasting\n ind = ind>0\n sol[ind] = p3[ind]\n kappa[crit_compare<=crit]= x3[crit_compare<=crit]\n crit[crit_compare<=crit] = crit_compare[crit_compare<=crit]\n #########################################################################\n #test xmin+1e-10\n crit_compare = 0.5*torch.norm(xtilde-xmin-1e-10,dim=2).view(n,1,1)**2-gamma_mu*(\n torch.log(1e-10*torch_one)+torch.log((xmax-xmin-1e-10)*torch_one))\n ind = (crit_compare<=crit)+ torch.zeros(n,1,nx)#broadcasting \n ind = ind>0 \n sol[ind] = 0*sol[ind]+(xmin+1e-10)\n kappa[crit_compare<=crit]= uTx\n crit[crit_compare<=crit] = crit_compare[crit_compare<=crit]\n #########################################################################\n #test xmax-1e-10\n crit_compare = 0.5*torch.norm(xtilde-xmax+1e-10,dim=2).view(n,1,1)**2-gamma_mu*(\n torch.log(1e-10*torch_one)+torch.log((xmax-xmin-1e-10)*torch_one))\n ind = (crit_compare<=crit)+ torch.zeros(n,1,nx)#broadcasting\n ind = ind>0\n sol[ind] = 0*sol[ind]+(xmax-1e-10)\n kappa[crit_compare<=crit]= uTx[crit_compare<=crit]\n crit[crit_compare<=crit] = crit_compare[crit_compare<=crit]\n #########################################################################\n # when gamma_mu is very small and uTx is very close to one of the bounds,\n # the solution of the cubic equation is not very well estimated -> test xtilde\n #denom = (sol-xmin)*(sol-xmax)-2*gamma_mu -(sol-xtilde)*(xmin+xmax-2*sol)\n uTx_ok = (uTx>xmin)&(uTx<xmax)\n crit_compare[~uTx_ok] = np.inf\n crit_compare[uTx_ok] = -(torch.log(xmax-uTx[uTx_ok])+torch.log(uTx[uTx_ok]-xmin))\n crit_compare = gamma_mu*crit_compare\n ind = (crit_compare<crit)+ torch.zeros(n,1,nx)#broadcasting\n ind = ind>0\n sol[ind] = xtilde[ind]\n kappa[crit_compare<=crit]= uTx[crit_compare<=crit]\n \n if mode_training==True:\n ctx.save_for_backward(gamma_mu,kappa,uTx,sol)\n return sol","def log_density(\n self,\n theta_unc: FloatArray,\n *,\n propto: bool = True,\n jacobian: bool = True,\n ) -> float:\n lp = ctypes.pointer(ctypes.c_double())\n err = ctypes.pointer(ctypes.c_char_p())\n rc = self._log_density(\n self.model, int(propto), int(jacobian), theta_unc, lp, err\n )\n if rc:\n raise self._handle_error(err.contents, \"log_density\")\n return lp.contents.value","def logp(self, x):\n pass","def __call__(self, x):\n\n self.dbeads.q = x\n e = self.dforces.pot # Energy\n g = -self.dforces.f # Gradient\n\n return e, g","def log_prob(self, z, x):\n n_samples = z.shape[0].value\n log_prob = 0\n for i in range(self.time_steps):\n lat_dim = self.transition.dim_x\n obs_dim = self.emmision.dim_x\n # Current time step latent state and observation\n z_t = tf.slice(z, [0, i * lat_dim], [-1, lat_dim])\n x_t = tf.slice(x, [0, i * obs_dim], [-1, obs_dim])\n if i == 0:\n log_prob += tf.reduce_sum(\n self.init_state_p.log_prob(z_t), axis=1)\n else:\n log_prob += self.transition.log_prob(z_t, z_tminus)\n log_prob += self.emmision.log_prob(x_t, z_t)\n # Update the previous latent state for next iteration\n z_tminus = z_t\n return log_prob","def gelu(x):\n cdf = 0.5 * (1.0 + tf.tanh(\n (np.sqrt(2 / np.pi) * (x + 0.044715 * tf.pow(x, 3)))))\n return x * cdf","def log_likelihood_exp(self, x):\n predictions = self.get_predictions(x)\n ll = 0.\n for measurement in self.get_measurements:\n m_obj = flavio.Measurement[measurement]\n m_obs = m_obj.all_parameters\n exclude_observables = set(m_obs) - set(self.observables)\n prob_dict = m_obj.get_logprobability_all(predictions, exclude_parameters=exclude_observables)\n ll += sum(prob_dict.values())\n return ll","def compute_log_prior(self,params: ndarray) -> float:\n ln_tE = params[0]\n ln_A0 = params[1]\n ln_deltaT = params[2]\n fbl = params[3]\n mb = params[4]\n\n # Equation (16,15,17) (note that Albrow uses \"log\" for log10)\n log10e = np.log10(np.exp(1))\n ln_pr_ln_tE = np.log(0.476) - ((log10e*ln_tE - 1.333)**2 / 0.330) + np.log(log10e)\n ln_pr_ln_A0 = np.log(0.660) - (1.289*log10e*ln_A0) + np.log(log10e)\n ln_pr_ln_deltaT = np.log(0.156) - ((log10e*ln_deltaT - 1.432)**2 / 0.458) +\\\n np.log(log10e)\n \n # Paper doesnt mention the prior used, but I assume it to be uniform\n ln_pr_fbl = uniform.logpdf(fbl,0.0,1.0)\n\n # Paper doesnr mention the prior used but I will asuumed it to be uniform\n ln_pr_mb = uniform.logpdf(mb,self.mag_min - 1.0, self.mag_max + 1.0)\n \n \n return ln_pr_fbl + ln_pr_ln_A0 + ln_pr_ln_deltaT + ln_pr_ln_tE + ln_pr_mb","def forward(self, x: torch.Tensor) -> torch.Tensor:\n return torch.nn.functional.linear(\n x,\n self.weight_mu + self.weight_sigma * self.weight_epsilon,\n self.bias_mu + self.bias_sigma * self.bias_epsilon,\n )","def forward(self, x):\n # action\n act = self.act_fc1(x)\n act = torch.tanh(act)\n act = self.act_fc2(act)\n act = torch.tanh(act)\n mean = self.mu(act) # N, num_actions\n logstd = self.logstd.expand_as(mean)\n std = torch.exp(logstd)\n action = torch.normal(mean, std)\n\n # value\n v = self.value_fc1(x)\n v = torch.tanh(v)\n v = self.value_fc2(v)\n v = torch.tanh(v)\n v = self.value_fc3(v)\n\n # action prob on log scale\n logprob = log_normal_density(action, mean, std=std, log_std=logstd)\n return v, action, logprob, mean","def log_prob(self, x):\n n_samples = x.shape[0].value\n log_prob = 0\n for i in range(self.time_steps):\n obs_dim = self.transition.dim_x\n # Current time step latent state and observation\n x_t = tf.slice(x, [0, i * obs_dim], [-1, obs_dim])\n if i == 0:\n log_prob += tf.reduce_sum(\n self.init_state_p.log_prob(x_t), axis=1)\n else:\n log_prob += self.transition.log_prob(x_t, x_tminus)\n # Update the previous latent state for next iteration\n x_tminus = x_t\n return log_prob","def get_dphi_dx_fast(self, sess, x_train):\n dphi_dx = tf.gradients(self.featurizations, self.x)\n feed_dict = {self.x: x_train}\n dphi_dx_np = sess.run(dphi_dx, feed_dict = feed_dict)\n return dphi_dx_np","def logp(self, x):\n p_trans = self.p_trans\n p_t0 = self.p_t0 # Probability for first point (unconditional)\n p_t1 = self.p_t1 # Probability for second point (conditional on first)\n p_t2 = self.p_t2 # Probability for third point (conditional on first and second)\n\n # Probability of the next points (conditional on previous 3 points) - P(x_t | x_t-1, x_t-1)\n p_t = p_trans[x[:-3], x[1:-2], x[2:-1]] # Index into trans matrix to generate categorical probabilities for each point,\n # where p_trans is indexed by furthest back point first i.e. p_trans[x_t-2, x_t-1]\n\n x_ti = x[3:] # The first and second and third point is not based on 2 back, this is what we are trying to predict\n likelihood_ti = pm.Categorical.dist(p_t).logp(x_ti) # likelihood for dynamic process_datasets\n # Full likelihood is static first point + static second point + dynamic next points\n return pm.Categorical.dist(p_t0).logp(x[0]) + pm.Categorical.dist(p_t1[x[0]]).logp(x[1]) \\\n + pm.Categorical.dist(p_t2[x[0],x[1]]).logp(x[2]) + tt.sum(likelihood_ti)","def forward(self, x) -> Tuple[Tensor, Tensor]:\n x = F.relu(self.fc1(x.float()))\n a = F.log_softmax(self.actor_head(x), dim=-1)\n c = self.critic_head(x)\n return a, c","def forward(self, x):\n # draw gumbel noise\n shp = x.shape\n eps = self.eps\n # footnote 1 from https://arxiv.org/pdf/1611.01144.pdf,\n # with a guard against log of 0\n # u = np.random.uniform(low=0, high=1, size=shp)\n # TODO: can this be replaced with rng.gumbel()?\n # what is the relatinship between low, high and gumbel parameters?\n u = self.rng.uniform(low=0, high=1, size=shp)\n g = -np.log(-np.log(u + eps) + eps)\n # x are the \"logits\" from the paper, add gumbel noise and normalize by temperature\n y = x + g\n yy = y / self.tau\n return self.smax.forward(yy)","def posterior_loss(X, mu, sigma, log_pi):\r\n log_PDF = log_GaussPDF(X, mu, sigma)\r\n log_post = log_posterior(log_PDF, log_pi)\r\n\r\n loss = torch.logsumexp(log_post, dim=1)\r\n # loss = torch.exp(log_post)\r\n # loss = torch.sum(loss, dim=1)\r\n # loss = torch.log(loss)\r\n loss = torch.sum(loss)\r\n loss = -loss\r\n return loss","def test_log():\n x, y = fwd.Variable(), fwd.Variable()\n f = fwd.log(fwd.sin(x)+y**2)\n dfdx = lambda x, y: np.cos(x) / (np.sin(x)+y**2)\n dfdy = lambda x, y: 2*y / (np.sin(x)+y**2)\n d2fdxdy = lambda x, y: -2*y*np.cos(x) / (np.sin(x)+y**2)**2\n assert equals(f.evaluation_at({x: 1.5, y:2.5}), np.log(np.sin(1.5)+2.5**2))\n assert equals(f.derivative_at(x, {x: 1.5, y:2.5}), dfdx(1.5, 2.5))\n assert equals(f.derivative_at(y, {x: 1.5, y:2.5}), dfdy(1.5, 2.5))\n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}), d2fdxdy(1.5, 2.5))\n with pytest.raises(NotImplementedError):\n f.derivative_at(x, {x:1.0, y: 2.0}, order=3)","def log_prior(cosmo_param):\n\n Omega_m, beta = cosmo_param\n\n # Get bounds\n bounds = get_bounds()\n\n if bounds[0][0] < Omega_m < bounds[0][1] and bounds[1][0] < beta < bounds[1][1]:\n return 0.0 \n return -np.inf","def _calculate_ll(self, x):\n observation_log_probs = self._observation_log_probs(x, mask=None)\n forward_log_probs = self._forward(observation_log_probs)\n log_likelihood = logsumexp(\n forward_log_probs[forward_log_probs.shape[0] - 1, :].numpy())\n return log_likelihood","def log_agm(x, prec):\n x2 = (x*x) >> prec\n # Compute jtheta2(x)**2\n s = a = b = x2\n while a:\n b = (b*x2) >> prec\n a = (a*b) >> prec\n s += a\n s += (MPZ_ONE<<prec)\n s = (s*s)>>(prec-2)\n s = (s*isqrt_fast(x<<prec))>>prec\n # Compute jtheta3(x)**2\n t = a = b = x\n while a:\n b = (b*x2) >> prec\n a = (a*b) >> prec\n t += a\n t = (MPZ_ONE<<prec) + (t<<1)\n t = (t*t)>>prec\n # Final formula\n p = agm_fixed(s, t, prec)\n return (pi_fixed(prec) << prec) // p","def forward(self, x, y):\n\n masked = self.mask * x\n\n s = self.s(masked, y)\n t = self.t(masked, y)\n z = masked + (1 - self.mask) * (x * s.exp() + t)\n\n log_det = (s * (1 - self.mask)).sum(1)\n\n return z, log_det","def forward(self, X, labels):\n features = self.get_conv_feats(X)\n W = self.W\n T = self.T\n log_prob = CRFautograd.apply(W, T, features, labels)\n return log_prob","def psi_x0(z, x, gamma, dx):\n \n if x == 0:\n return (psi_x(z, -dx/2, gamma) + psi_x(z, dx/2, gamma))/2\n else:\n return psi_x(z, x, gamma)","def gelu(x):\n cdf = 0.5 * (1.0 + torch.tanh(\n (np.sqrt(2 / np.pi) * (x + 0.044715 * torch.pow(x, 3)))))\n return x * cdf","def post_rho(store):\n return loglike(store) + prior_rho(store)"],"string":"[\n \"def _forward_log_det_jacobian(self, x):\\n d = self._compute_shared(x=x)\\n relx = (x - d.x_k) / d.w_k\\n relx = relx # tf.where(d.out_of_bounds, 0.5*tf.ones_like(x), relx)\\n grad = (\\n 2 * tf.math.log(d.s_k) +\\n tf.math.log(d.d_kp1 * relx**2 + 2 * d.s_k * relx * (1 - relx) + # newln\\n d.d_k * (1 - relx)**2) -\\n 2 * tf.math.log((d.d_kp1 + d.d_k - 2 * d.s_k) * relx *\\n (1 - relx) + d.s_k))\\n return grad # tf.where(d.out_of_bounds, tf.zeros_like(grad), grad)\",\n \"def log_prob(self, x):\\n z, log_det = self.backward_p(x)\\n return self.prior.log_prob(z) + log_det\",\n \"def _log_prior_gradients(self):\\n x = self._get_params()\\n ret = np.zeros(x.size)\\n [np.put(ret,i,p.lnpdf_grad(xx)) for i,(p,xx) in enumerate(zip(self.priors,x)) if not p is None]\\n return ret\",\n \"def log_pdf_derivative(x):\\n return gs.autodiff.jacobian(log_pdf_at_x(x))(base_point)\",\n \"def log_prior_grad(self, inputs):\",\n \"def _call(self, x):\\n if functional.prior is None:\\n tmp = np.log(x)\\n else:\\n tmp = np.log(x / functional.prior)\\n\\n if np.all(np.isfinite(tmp)):\\n return tmp\\n else:\\n # The derivative is not defined.\\n raise ValueError('The gradient of the Kullback-Leibler '\\n 'Cross Entropy functional is not defined '\\n 'for `x` with one or more components '\\n 'less than or equal to zero.'.format(x))\",\n \"def grad_log(self, X):\\n # \\\"\\\"\\\"\\n # Evaluate the gradients (with respect to the input) of the log density at\\n # each of the n points in X. This is the score function.\\n\\n # X: n x d numpy array.\\n XB = np.dot(X, self.B)\\n Y = 0.5*XB + self.c\\n E2y = np.exp(2*Y)\\n # n x dh\\n Phi = old_div((E2y-1.0),(E2y+1))\\n # n x dx\\n T = np.dot(Phi, 0.5*self.B.T)\\n S = self.b - X + T\\n return S\",\n \"def objective_and_gradients(self, x):\\r\\n\\r\\n try:\\r\\n self._set_params_transformed(x)\\r\\n obj_f = -self.log_likelihood() - self.log_prior()\\r\\n self._fail_count = 0\\r\\n obj_grads = -self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients())\\r\\n except (LinAlgError, ZeroDivisionError, ValueError) as e:\\r\\n if self._fail_count >= self._allowed_failures:\\r\\n raise e\\r\\n self._fail_count += 1\\r\\n obj_f = np.inf\\r\\n obj_grads = np.clip(-self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients()), -1e100, 1e100)\\r\\n return obj_f, obj_grads\",\n \"def log_forward_computations(self, x: list): \\n n_x = len(x)\\n \\n # log_f_x initialized to -Inf because log(0) = -Inf\\n log_f_x = np.zeros((self.n_states, n_x)) + logzero()\\n x_emission_scores = np.array([self.scores['emission'][:, self.word_to_pos[w] if w in list(self.word_to_pos.keys()) else self.word_to_pos['UnknownWord']] for w in x]).T\\n \\n log_f_x[:,0] = x_emission_scores[:, 0] + self.scores['initial']\\n \\n for i in range(1,n_x):\\n for s in range(self.n_states):\\n log_f_x[s,i] = logsumexp(self.scores['transition'][s,:] + \\n log_f_x[:,i-1]) + x_emission_scores[s, i]\\n\\n \\n log_likelihood = logsumexp(self.scores['final'] + log_f_x[:,-1])\\n \\n return log_f_x, log_likelihood\",\n \"def _log_posterior_x(self, X):\\r\\n LL = self.log_likelihood(X=X)\\r\\n LP = self._log_prior_x(X)\\r\\n return LL + LP\",\n \"def objective_function_gradients(self, x):\\n self._set_params_transformed(x)\\n LL_gradients = self._transform_gradients(self._log_likelihood_gradients())\\n prior_gradients = self._transform_gradients(self._log_prior_gradients())\\n return - LL_gradients - prior_gradients\",\n \"def _log_prior_gradients(self):\\r\\n if self.priors is None:\\r\\n return 0.\\r\\n x = self._get_params()\\r\\n ret = np.zeros(x.size)\\r\\n [np.put(ret, i, p.lnpdf_grad(xx)) for i, (p, xx) in enumerate(zip(self.priors, x)) if not p is None]\\r\\n return ret\",\n \"def log_likelihood(self, theta, x, **kwargs):\\n\\n u, logdet_dudx, log_a = self.forward(theta, x, **kwargs)\\n\\n constant = float(-0.5 * self.n_inputs * np.log(2.0 * np.pi))\\n # log_likelihood = torch.log(torch.sum(torch.exp(log_a - 0.5 * u ** 2 + logdet_dudx), dim=2))\\n log_likelihood = torch.logsumexp(log_a - 0.5 * u**2 + logdet_dudx, dim=2)\\n log_likelihood = constant + torch.sum(log_likelihood, dim=1)\\n\\n return u, log_likelihood\",\n \"def _log_prior_gradients(self):\\n if self.priors.size == 0:\\n return 0.\\n x = self.param_array\\n ret = np.zeros(x.size)\\n #compute derivate of prior density\\n [np.put(ret, ind, p.lnpdf_grad(x[ind])) for p, ind in self.priors.items()]\\n #add in jacobian derivatives if transformed\\n priored_indexes = np.hstack([i for p, i in self.priors.items()])\\n for c,j in self.constraints.items():\\n if not isinstance(c, Transformation):continue\\n for jj in j:\\n if jj in priored_indexes:\\n ret[jj] += c.log_jacobian_grad(x[jj])\\n return ret\",\n \"def _call(self, x):\\n if self.prior is None:\\n tmp = ((x - 1 - np.log(x)).inner(self.domain.one()))\\n else:\\n # This is the old line from odl version 0.6.0.\\n # tmp = ((x - self.prior + self.prior * np.log(self.prior / x))\\n tmp = ((x - self.prior + self.prior * np.log((self.prior + 1e-12) / x))\\n .inner(self.domain.one()))\\n if np.isnan(tmp):\\n # In this case, some element was less than or equal to zero\\n return np.inf\\n else:\\n return tmp\",\n \"def grad_log(self, X):\\n g = autograd.elementwise_grad(self.log_den)\\n G = g(X)\\n return G\",\n \"def _log_posterior_x(self, X):\\n if self.marginalize:\\n LL = self.log_marginal_likelihood(X, self.W)\\n else:\\n LL = self.log_likelihood(X=X)\\n LP = self._log_prior_x(X)\\n return LL + LP\",\n \"def logistic_loss_step(x_, rho, X, y, tensor_name, calculate_by_hand=True):\\n\\n if calculate_by_hand:\\n # prob = torch.exp( -y * X.mm(x_.data))\\n prob = torch.exp( -y * torch.matmul(X, x_.data))\\n alpha = prob / (1+prob)\\n x_.grad = rho * x_.data - torch.mean(alpha*y*X, dim = 0).reshape(-1,1)\\n return\\n\\n else:\\n if os.getenv('BLUEFOG_TIMELINE'):\\n with bf.timeline_context(tensor_name=tensor_name,\\n activity_name=\\\"gradient computation\\\"):\\n loss_ = torch.mean(torch.log(1 + torch.exp(-y*X.mm(x_)))) + \\\\\\n 0.5*rho*torch.norm(x_, p=2)\\n loss_.backward()\\n else:\\n loss_ = torch.mean(torch.log(1 + torch.exp(-y*X.mm(x_)))) + \\\\\\n 0.5*rho*torch.norm(x_, p=2)\\n loss_.backward()\\n return\",\n \"def backward_p(self, x):\\n log_det_jacob, z = x.new_zeros(x.shape[0]), x\\n for i in reversed(range(len(self.t))):\\n z_ = self.mask[i] * z\\n s = self.s[i](z_) * (1 - self.mask[i])\\n t = self.t[i](z_) * (1 - self.mask[i])\\n z = (1 - self.mask[i]) * (z - t) * torch.exp(-s) + z_\\n log_det_jacob -= s.sum(dim=1)\\n return z, log_det_jacob\",\n \"def log_prior(x):\\n logp = (-0.5 * x.pow(2) - torch.tensor(2 * math.pi).sqrt().log()).sum(dim=1)\\n return logp\",\n \"def step(self, x):\\r\\n y,mean,stddev_p,z,xhat=self.forward(x)\\r\\n L_rec=self.loss_fn(x,xhat)\\r\\n\\r\\n var = torch.exp(stddev_p)\\r\\n s = torch.log(var) - torch.pow(mean,2) - var\\r\\n s = self.latent_dim + torch.sum(s, 1)\\r\\n s = -0.5*s\\r\\n s = self.lam*s \\r\\n L_kl = s.mean()\\r\\n \\r\\n \\r\\n L=L_kl+L_rec\\r\\n\\r\\n L.backward()\\r\\n self.opt.step()\\r\\n self.opt.zero_grad()\\r\\n \\r\\n return L_rec,L_kl,L\",\n \"def log_likelihood(self, x):\\n return self.log_likelihood_exp(x) + self.log_prior_nuisance_parameters(x)\",\n \"def objective_function_gradients(self, x):\\r\\n try:\\r\\n self._set_params_transformed(x)\\r\\n obj_grads = -self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients())\\r\\n self._fail_count = 0\\r\\n except (LinAlgError, ZeroDivisionError, ValueError) as e:\\r\\n if self._fail_count >= self._allowed_failures:\\r\\n raise e\\r\\n self._fail_count += 1\\r\\n obj_grads = np.clip(-self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients()), -1e100, 1e100)\\r\\n return obj_grads\",\n \"def _logprob_X(self, X, **kwargs):\\n pass\",\n \"def _estimate_log_prob(self, x):\\n x = self.check_size(x)\\n\\n if self.covariance_type == \\\"full\\\":\\n mu = self.mu\\n var = self.var\\n precision = tf.linalg.inv(var)\\n d = x.shape[-1]\\n\\n log_2pi = d * tf.math.log(2. * pi)\\n log_2pi = tf.cast(log_2pi, tf.double)\\n log_det = self._calculate_log_det(precision)\\n log_det = tf.cast(log_det, tf.double)\\n\\n\\n x = tf.cast(x, tf.double)\\n mu = tf.cast(mu, tf.double)\\n x_mu_T = tf.expand_dims((x - mu), -2)\\n x_mu = tf.expand_dims((x - mu), -1)\\n\\n x_mu_T_precision = calculate_matmul_n_times(self.n_components, x_mu_T, precision)\\n # print(x_mu_T_precision, x_mu_T, x, mu)\\n x_mu_T_precision_x_mu = calculate_matmul(x_mu_T_precision, x_mu)\\n\\n return -.5 * (log_2pi - log_det + x_mu_T_precision_x_mu)\\n\\n elif self.covariance_type == \\\"diag\\\":\\n mu = self.mu\\n prec = tf.math.rsqrt(self.var)\\n\\n log_p = tf.math.reduce_sum((mu * mu + x * x - 2 * x * mu) * (prec ** 2), axis=2, keepdims=True)\\n log_det = tf.math.reduce_sum(tf.math.log(prec), axis=2, keepdims=True)\\n\\n return -.5 * (self.n_features * tf.math.log(2. * pi) + log_p) + log_det\",\n \"def G_pre_step(self, x: tf.Tensor, y: tf.Tensor) -> None:\\n\\n with tf.GradientTape() as tape:\\n logits, _, _ = self.G(x)\\n\\n loss = tf.reduce_mean(\\n tf.nn.sparse_softmax_cross_entropy_with_logits(y, logits)\\n )\\n\\n gradients = tape.gradient(loss, self.G.trainable_variables)\\n\\n self.P_optimizer.apply_gradients(zip(gradients, self.G.trainable_variables))\\n\\n self.G_loss.update_state(loss)\",\n \"def log_likelihood_grad_rew(self, data, reward_model, bias_params):\",\n \"def convertLaguerreToGamma(self,x):\\n return x/self.beta+self.low\",\n \"def log_gamma_unnormalised_lpdf(x, alpha, beta):\\n return alpha * x - beta * tf.exp(x)\",\n \"def calc_gamma_1d(x, fx, dfx, y, fpy, dfpy):\\n beta = calc_beta(fx, dfx)\\n print ' using beta = ', beta\\n # upper and lower bounds\\n sorted_x = numpy.array(sorted(x))\\n sorted_y = numpy.array(sorted(y))\\n if y.size == 0:\\n delta_max = x.max() - x.min()\\n delta_min = (sorted_x[1:] - sorted_x[:-1]).min()\\n else:\\n delta_max = max(x.max(), y.max()) - min(x.min(), y.min())\\n delta_min = min((sorted_x[1:] - sorted_x[:-1]).min(), \\\\\\n (sorted_y[1:] - sorted_y[:-1]).min())\\n assert delta_max > delta_min\\n gamma_min = 1. / delta_max\\n gamma_max = pi / delta_min\\n # logorithmic bisection for gamma\\n while gamma_max / gamma_min > 1.1:\\n print ' bisecting [', gamma_min, ',', gamma_max, '] for gamma...'\\n gamma_mid = sqrt(gamma_max * gamma_min)\\n res_ratio = calc_res_ratio_avg_1d(beta, gamma_mid, x, fx, dfx, y, fpy, dfpy)\\n if res_ratio < 1.0:\\n gamma_max = gamma_mid\\n else:\\n gamma_min = gamma_mid\\n # final selected gamma\\n gamma_mid = sqrt(gamma_max * gamma_min)\\n print ' using gamma = ', gamma_mid\\n return gamma_mid\",\n \"def lorentz(x, x0, gamma): \\n return (0.5/pi) * gamma / ((x-x0)**2 + 0.25 * gamma**2)\",\n \"def logpdf(self, x):\\n if self.transform is not None:\\n x = self.transform(x) \\n return (-self.alpha-1)*np.log(x) - (self.beta/float(x))\",\n \"def formula(self, x: np.ndarray, gamma: float = None) -> np.ndarray:\\n gamma = gamma or self.gamma\\n Li = self._vpolylog(gamma, 1 - x)\\n A = 1 / float(zeta(gamma).real)\\n y = 1 - A * Li\\n return y\",\n \"def deriv(self, x, amplitude, x_0, gamma, alpha):\\n d_A = (1 + (x - x_0) ** 2 / gamma ** 2) ** (-alpha)\\n d_x_0 = - amplitude * alpha * d_A * (-2 * x + 2 * x_0) / (gamma ** 2 * d_A ** alpha)\\n d_gamma = 2 * amplitude * alpha * d_A * (x - x_0) ** 2 / (gamma ** 3 * d_A ** alpha)\\n d_alpha = -amplitude * d_A * np.log(1 + (x - x_0) ** 2 / gamma ** 2)\\n return [d_A, d_x_0, d_gamma, d_alpha]\",\n \"def log_likelihood(self) -> tf.Tensor:\\n # K⁻¹ + GᵀΣ⁻¹G = LLᵀ.\\n l_post = self._k_inv_post.cholesky\\n num_data = self.observations_index.shape[0]\\n\\n # Hμ [..., num_transitions + 1, output_dim]\\n marginal = self.emission.project_state_to_f(self.prior_ssm.marginal_means)\\n marginal = self._drop_batch_shape(marginal)\\n\\n # y = obs - Hμ [..., num_transitions + 1, output_dim]\\n disp = self.observations - marginal\\n disp_data = self.sparse_observations - self.dense_to_sparse(marginal)\\n\\n # cst is the constant term for a gaussian log likelihood\\n cst = (\\n -0.5 * np.log(2 * np.pi) * tf.cast(self.emission.output_dim * num_data, default_float())\\n )\\n\\n term1 = -0.5 * tf.reduce_sum(\\n input_tensor=tf.einsum(\\\"...op,...p,...o->...o\\\", self._r_inv_data, disp_data, disp_data), axis=[-1, -2]\\n )\\n\\n # term 2 is: ½|L⁻¹(GᵀΣ⁻¹)y|²\\n # (GᵀΣ⁻¹)y [..., num_transitions + 1, state_dim]\\n obs_proj = self._back_project_y_to_state(disp)\\n\\n # ½|L⁻¹(GᵀΣ⁻¹)y|² [...]\\n term2 = 0.5 * tf.reduce_sum(\\n input_tensor=tf.square(l_post.solve(obs_proj, transpose_left=False)), axis=[-1, -2]\\n )\\n\\n ## term 3 is: ½log |K⁻¹| - log |L| + ½ log |Σ⁻¹|\\n # where log |Σ⁻¹| = num_data * log|R⁻¹|\\n term3 = (\\n 0.5 * self.prior_ssm.log_det_precision()\\n - l_post.abs_log_det()\\n + 0.5 * self._log_det_observation_precision\\n )\\n\\n return tf.reduce_sum(cst + term1 + term2 + term3)\",\n \"def f(self, x):\\n error = log_likelihood_calc(x[1], x[0], self.data)\\n return error\",\n \"def forward_backward(self, O):\\n alpha, B, _Z_ = self.forward(O)\\n beta = self.backward(O, B)\\n gamma = alpha + beta # This must be a sum because what is stored in 'alpha' and 'beta' are logarithms of probabilities\\n # Gamma must be normalized by means of P(O|lambda) : _Z_ = log P(O|lambda)\\n gamma = gamma - _Z_\\n if _Z_.min() != _Z_.min():\\n print('gamma.min()', gamma.min())\\n print('gamma.max()', gamma.max())\\n print('_Z_.min()', _Z_.min())\\n print('_Z_.max()', _Z_.max(), flush = True)\\n raise Exception(\\\"nan appeared\\\")\\n\\n return alpha, beta, gamma, B, _Z_\",\n \"def lorentz(x, gamma):\\n return 1 / cs.pi * 0.5 * gamma / ((0.5 * gamma**2) + x**2)\",\n \"def lgamma(x):\\n return 0.0\",\n \"def MvNormalLogp():\\n cov = pt.matrix(\\\"cov\\\")\\n cov.tag.test_value = floatX(np.eye(3))\\n delta = pt.matrix(\\\"delta\\\")\\n delta.tag.test_value = floatX(np.zeros((2, 3)))\\n\\n cholesky = Cholesky(lower=True, on_error=\\\"nan\\\")\\n\\n n, k = delta.shape\\n n, k = f(n), f(k)\\n chol_cov = cholesky(cov)\\n diag = pt.diag(chol_cov)\\n ok = pt.all(diag > 0)\\n\\n chol_cov = pt.switch(ok, chol_cov, pt.fill(chol_cov, 1))\\n delta_trans = solve_lower(chol_cov, delta.T).T\\n\\n result = n * k * pt.log(f(2) * np.pi)\\n result += f(2) * n * pt.sum(pt.log(diag))\\n result += (delta_trans ** f(2)).sum()\\n result = f(-0.5) * result\\n logp = pt.switch(ok, result, -np.inf)\\n\\n def dlogp(inputs, gradients):\\n (g_logp,) = gradients\\n cov, delta = inputs\\n\\n g_logp.tag.test_value = floatX(1.0)\\n n, k = delta.shape\\n\\n chol_cov = cholesky(cov)\\n diag = pt.diag(chol_cov)\\n ok = pt.all(diag > 0)\\n\\n chol_cov = pt.switch(ok, chol_cov, pt.fill(chol_cov, 1))\\n delta_trans = solve_lower(chol_cov, delta.T).T\\n\\n inner = n * pt.eye(k) - pt.dot(delta_trans.T, delta_trans)\\n g_cov = solve_upper(chol_cov.T, inner)\\n g_cov = solve_upper(chol_cov.T, g_cov.T)\\n\\n tau_delta = solve_upper(chol_cov.T, delta_trans.T)\\n g_delta = tau_delta.T\\n\\n g_cov = pt.switch(ok, g_cov, -np.nan)\\n g_delta = pt.switch(ok, g_delta, -np.nan)\\n\\n return [-0.5 * g_cov * g_logp, -g_delta * g_logp]\\n\\n return OpFromGraph([cov, delta], [logp], grad_overrides=dlogp, inline=True)\",\n \"def _inverse_log_det_jacobian(self, x):\\n alpha, beta = self._get_alpha_beta()\\n diff = x - self.x0\\n r = tf.linalg.norm(diff, axis=-1, keepdims=True)\\n h = 1. / (alpha + r)\\n h_prime = -(h ** 2)\\n beta_h = beta * h\\n log_det_jacobian = tf.reduce_sum(\\n (self.dim - 1) * tf.math.log1p(beta_h)\\n + tf.math.log1p(beta_h + beta * h_prime * r), axis=-1)\\n return log_det_jacobian\",\n \"def forward(self, x):\\n o = torch.clamp(\\n 1 / (1 + torch.exp(-self.k * (x - self.x0))), min=0, max=1\\n ).squeeze()\\n return o\",\n \"def log_likelihood_gradients_(self, y, f):\\n log_lik = self.evaluate_log_likelihood(y, f)\\n f = np.squeeze(f)\\n J = jacrev(self.evaluate_log_likelihood, argnums=1)\\n H = jacrev(J, argnums=1)\\n return log_lik, J(y, f), H(y, f)\",\n \"def leapfrog(params, momentum, log_prob_func, steps=10, step_size=0.1, jitter=0.01, normalizing_const=1., softabs_const=1e6, explicit_binding_const=100, fixed_point_threshold=1e-20, fixed_point_max_iterations=6, jitter_max_tries=10, inv_mass=None, ham_func=None, sampler=Sampler.HMC, integrator=Integrator.IMPLICIT, metric=Metric.HESSIAN, store_on_GPU = True, debug=False, pass_grad = None):\\n\\n params = params.clone(); momentum = momentum.clone()\\n # TodO detach graph when storing ret_params for memory saving\\n if sampler == Sampler.HMC and integrator != Integrator.SPLITTING and integrator != Integrator.SPLITTING_RAND and integrator != Integrator.SPLITTING_KMID:\\n def params_grad(p):\\n p = p.detach().requires_grad_()\\n log_prob = log_prob_func(p)\\n # log_prob.backward()\\n p = collect_gradients(log_prob, p, pass_grad)\\n # print(p.grad.std())\\n if torch.cuda.is_available():\\n torch.cuda.empty_cache()\\n return p.grad\\n ret_params = []\\n ret_momenta = []\\n momentum += 0.5 * step_size * params_grad(params)\\n for n in range(steps):\\n if inv_mass is None:\\n params = params + step_size * momentum #/normalizing_const\\n else:\\n #Assum G is diag here so 1/Mass = G inverse\\n if type(inv_mass) is list:\\n i = 0\\n for block in inv_mass:\\n it = block[0].shape[0]\\n params[i:it+i] = params[i:it+i] + step_size * torch.matmul(block,momentum[i:it+i].view(-1,1)).view(-1) #/normalizing_const\\n i += it\\n elif len(inv_mass.shape) == 2:\\n params = params + step_size * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params = params + step_size * inv_mass * momentum #/normalizing_const\\n p_grad = params_grad(params)\\n momentum += step_size * p_grad\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n # only need last for Hamiltoninian check (see p.14) https://arxiv.org/pdf/1206.1901.pdf\\n ret_momenta[-1] = ret_momenta[-1] - 0.5 * step_size * p_grad.clone()\\n # import pdb; pdb.set_trace()\\n return ret_params, ret_momenta\\n elif sampler == Sampler.RMHMC and (integrator == Integrator.IMPLICIT or integrator == Integrator.S3):\\n if integrator is not Integrator.S3:\\n ham_func = None\\n # Else we are doing semi sep and need auxiliary for Riemann version.\\n if pass_grad is not None:\\n raise RuntimeError('Passing user-determined gradients not implemented for RMHMC')\\n\\n def fixed_point_momentum(params, momentum):\\n momentum_old = momentum.clone()\\n # print('s')\\n for i in range(fixed_point_max_iterations):\\n momentum_prev = momentum.clone()\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n params = collect_gradients(ham, params)\\n\\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\\n tries = 0\\n while util.has_nan_or_inf(params.grad):\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n params = collect_gradients(ham, params)\\n tries += 1\\n if tries > jitter_max_tries:\\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\\n # import pdb; pdb.set_trace()\\n raise util.LogProbError()\\n # import pdb; pdb.set_trace()\\n # break\\n\\n momentum = momentum_old - 0.5 * step_size * params.grad\\n momenta_diff = torch.max((momentum_prev-momentum)**2)\\n if momenta_diff < fixed_point_threshold:\\n break\\n if debug == 1:\\n print('Converged (momentum), iterations: {}, momenta_diff: {}'.format(i, momenta_diff))\\n return momentum\\n\\n def fixed_point_params(params, momentum):\\n params_old = params.clone()\\n momentum = momentum.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n momentum = collect_gradients(ham,momentum)\\n momentum_grad_old = momentum.grad.clone()\\n for i in range(fixed_point_max_iterations):\\n params_prev = params.clone()\\n momentum = momentum.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n momentum = collect_gradients(ham,momentum)#collect_gradients(ham, params)\\n params = params_old + 0.5 * step_size * momentum.grad + 0.5 * step_size * momentum_grad_old\\n params_diff = torch.max((params_prev-params)**2)\\n if params_diff < fixed_point_threshold:\\n break\\n if debug == 1:\\n print('Converged (params), iterations: {}, params_diff: {}'.format(i, params_diff))\\n return params\\n ret_params = []\\n ret_momenta = []\\n for n in range(steps):\\n # import pdb; pdb.set_trace()\\n momentum = fixed_point_momentum(params, momentum)\\n params = fixed_point_params(params, momentum)\\n\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n params = collect_gradients(ham, params)\\n\\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\\n tries = 0\\n while util.has_nan_or_inf(params.grad):\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n params = collect_gradients(ham, params)\\n tries += 1\\n if tries > jitter_max_tries:\\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\\n raise util.LogProbError()\\n # break\\n momentum -= 0.5 * step_size * params.grad\\n\\n ret_params.append(params)\\n ret_momenta.append(momentum)\\n return ret_params, ret_momenta\\n\\n elif sampler == Sampler.RMHMC and integrator == Integrator.EXPLICIT:\\n if pass_grad is not None:\\n raise RuntimeError('Passing user-determined gradients not implemented for RMHMC')\\n\\n #During leapfrog define integrator as implict when passing into riemannian_hamiltonian\\n leapfrog_hamiltonian_flag = Integrator.IMPLICIT\\n def hamAB_grad_params(params,momentum):\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum.detach(), log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\\n params = collect_gradients(ham, params)\\n\\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\\n tries = 0\\n while util.has_nan_or_inf(params.grad):\\n # import pdb; pdb.set_trace()\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum.detach(), log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\\n params = collect_gradients(ham, params)\\n tries += 1\\n if tries > jitter_max_tries:\\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\\n raise util.LogProbError()\\n # import pdb; pdb.set_trace()\\n # break\\n\\n return params.grad\\n def hamAB_grad_momentum(params,momentum):\\n momentum = momentum.detach().requires_grad_()\\n params = params.detach().requires_grad_()\\n # Can't detach p as we still need grad to do derivatives\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\\n # import pdb; pdb.set_trace()\\n momentum = collect_gradients(ham,momentum)\\n return momentum.grad\\n ret_params = []\\n ret_momenta = []\\n params_copy = params.clone()\\n momentum_copy = momentum.clone()\\n for n in range(steps):\\n # \\\\phi_{H_A}\\n momentum = momentum - 0.5 * step_size * hamAB_grad_params(params,momentum_copy)\\n params_copy = params_copy + 0.5 * step_size * hamAB_grad_momentum(params,momentum_copy)\\n # \\\\phi_{H_B}\\n params = params + 0.5 * step_size * hamAB_grad_momentum(params_copy,momentum)\\n momentum_copy = momentum_copy - 0.5 * step_size * hamAB_grad_params(params_copy,momentum)\\n # \\\\phi_{H_C}\\n c = torch.cos(torch.FloatTensor([2* explicit_binding_const * step_size])).to(params.device)\\n s = torch.sin(torch.FloatTensor([2* explicit_binding_const * step_size])).to(params.device)\\n # params_add = params + params_copy\\n # params_sub = params - params_copy\\n # momentum_add = momentum + momentum_copy\\n # momentum_sub = momentum - momentum_copy\\n # ### CHECK IF THE VALUES ON THE RIGHT NEED TO BE THE OLD OR UPDATED ones\\n # ### INSTINCT IS THAT USING UPDATED ONES IS BETTER\\n # params = 0.5 * ((params_add) + c*(params_sub) + s*(momentum_sub))\\n # momentum = 0.5 * ((momentum_add) - s*(params_sub) + c*(momentum_sub))\\n # params_copy = 0.5 * ((params_add) - c*(params_sub) - s*(momentum_sub))\\n # momentum_copy = 0.5 * ((momentum_add) + s*(params_sub) - c*(momentum_sub))\\n params = 0.5 * ((params+params_copy) + c*(params-params_copy) + s*(momentum-momentum_copy))\\n momentum = 0.5 * ((momentum+momentum_copy) - s*(params-params_copy) + c*(momentum-momentum_copy))\\n params_copy = 0.5 * ((params+params_copy) - c*(params-params_copy) - s*(momentum-momentum_copy))\\n momentum_copy = 0.5 * ((momentum+momentum_copy) + s*(params-params_copy) - c*(momentum-momentum_copy))\\n\\n\\n # \\\\phi_{H_B}\\n params = params + 0.5 * step_size * hamAB_grad_momentum(params_copy,momentum)\\n momentum_copy = momentum_copy - 0.5 * step_size * hamAB_grad_params(params_copy,momentum)\\n # \\\\phi_{H_A}\\n momentum = momentum - 0.5 * step_size * hamAB_grad_params(params,momentum_copy)\\n params_copy = params_copy + 0.5 * step_size * hamAB_grad_momentum(params,momentum_copy)\\n\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n return [ret_params,params_copy], [ret_momenta, momentum_copy]\\n\\n # PAGE 35 MCMC Using Hamiltonian dynamics (Neal 2011)\\n elif sampler == Sampler.HMC and (integrator == Integrator.SPLITTING or integrator == Integrator.SPLITTING_RAND or Integrator.SPLITTING_KMID):\\n if type(log_prob_func) is not list:\\n raise RuntimeError('For splitting log_prob_func must be list of functions')\\n if pass_grad is not None:\\n raise RuntimeError('Passing user-determined gradients not implemented for splitting')\\n\\n def params_grad(p,log_prob_func):\\n # OLD:\\n # p = p.detach().requires_grad_()\\n # log_prob = log_prob_func(p)\\n # # log_prob.backward()\\n # p = collect_gradients(log_prob, p)\\n # grad = p.grad\\n # # For removing GPU memory for large data sets.\\n # del p, log_prob\\n # torch.cuda.empty_cache()\\n\\n p = p.detach().requires_grad_()\\n log_prob = log_prob_func(p)\\n # Need to check memory issues in collect_gradients\\n grad = torch.autograd.grad(log_prob,p)[0]\\n # For removing GPU memory for large data sets.\\n del p, log_prob, log_prob_func\\n torch.cuda.empty_cache()\\n return grad\\n\\n params = params.detach() # Detach as we do not need to remember graph until we pass into log_prob\\n ret_params = []\\n ret_momenta = []\\n if integrator == Integrator.SPLITTING:\\n M = len(log_prob_func)\\n K_div = (M - 1) * 2\\n if M == 1:\\n raise RuntimeError('For symmetric splitting log_prob_func must be list of functions greater than length 1')\\n for n in range(steps):\\n # Symmetric loop to ensure reversible\\n for m in range(M):\\n # print('p ',n)\\n grad = params_grad(params,log_prob_func[m])\\n with torch.no_grad():\\n momentum += 0.5 * step_size * grad\\n del grad\\n if torch.cuda.is_available():\\n torch.cuda.empty_cache()\\n if m < M-1:\\n # print('q ',n)\\n if inv_mass is None:\\n params += (step_size/K_div) * momentum #/normalizing_const\\n else:\\n if type(inv_mass) is list:\\n pass\\n #Assum G is diag here so 1/Mass = G inverse\\n elif len(inv_mass.shape) == 2:\\n params += (step_size/K_div) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params += (step_size/K_div) * inv_mass * momentum #/normalizing_const\\n for m in reversed(range(M)):\\n # print('p ', n )\\n grad = params_grad(params,log_prob_func[m])\\n with torch.no_grad():\\n momentum += 0.5 * step_size * grad\\n del grad\\n if torch.cuda.is_available():\\n torch.cuda.empty_cache()\\n if m > 0:\\n # print('q ', n-1)\\n if inv_mass is None:\\n params += (step_size/K_div) * momentum #/normalizing_const\\n else:\\n if type(inv_mass) is list:\\n pass\\n #Assum G is diag here so 1/Mass = G inverse\\n elif len(inv_mass.shape) == 2:\\n params += (step_size/K_div) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params += (step_size/K_div) * inv_mass * momentum #/normalizing_const\\n\\n if store_on_GPU:\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n else:\\n ret_params.append(params.clone().cpu())\\n ret_momenta.append(momentum.clone().cpu())\\n elif integrator == Integrator.SPLITTING_RAND:\\n M = len(log_prob_func)\\n idx = torch.randperm(M)\\n for n in range(steps):\\n # \\\"Labelling of subsets is randomised for each iteration\\\"\\n # idx = torch.randperm(M)\\n for m in range(M):\\n # print('p ',n)\\n momentum += 0.5 * step_size * params_grad(params, log_prob_func[idx[m]])\\n # print('q ',n)\\n if inv_mass is None:\\n params += (step_size/M) * momentum #/normalizing_const\\n else:\\n if type(inv_mass) is list:\\n pass\\n #Assum G is diag here so 1/Mass = G inverse\\n elif len(inv_mass.shape) == 2:\\n params += (step_size/M) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params += (step_size/M) * inv_mass * momentum #/normalizing_const\\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[idx[m]])\\n\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n # import pdb; pdb.set_trace()\\n\\n\\n elif integrator == Integrator.SPLITTING_KMID:\\n M = len(log_prob_func)\\n if M == 1:\\n raise RuntimeError('For symmetric splitting log_prob_func must be list of functions greater than length 1')\\n for n in range(steps):\\n # Symmetric loop to ensure reversible\\n for m in range(M):\\n # print('p ',n)\\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[m])\\n\\n if inv_mass is None:\\n params = params + (step_size) * momentum #/normalizing_const\\n else:\\n if type(inv_mass) is list:\\n pass\\n #Assum G is diag here so 1/Mass = G inverse\\n elif len(inv_mass.shape) == 2:\\n params = params + (step_size) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params = params + (step_size) * inv_mass * momentum #/normalizing_const\\n\\n for m in reversed(range(M)):\\n # print('p ', n )\\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[m])\\n\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n\\n return ret_params, ret_momenta\\n\\n else:\\n raise NotImplementedError()\",\n \"def log_target(self, x):\\n return self.log_likelihood_exp(x) + self.log_prior_parameters(x) + self.log_prior_wilson_coeffs(x)\",\n \"def forward(\\n self,\\n m_q: torch.Tensor,\\n logs_q: torch.Tensor,\\n m_p: torch.Tensor,\\n logs_p: torch.Tensor,\\n ) -> torch.Tensor:\\n posterior_norm = D.Normal(m_q, torch.exp(logs_q))\\n prior_norm = D.Normal(m_p, torch.exp(logs_p))\\n loss = D.kl_divergence(posterior_norm, prior_norm).mean()\\n return loss\",\n \"def div_loss(gamma, model):\\n\\n def loss(data, y_pred):\\n # TODO: Try using points other than the training data points for the divergence calculation.\\n \\\"\\\"\\\"Punish non-zero divergence. Each input of size N (batch size) is expanded into\\n 4 sets of surrounding points, p1, p2, p3, and p4, where the elements pj_i (j = 1,2,3,4 and\\n i = 1,2,3...N) are defined according to:\\n\\n y\\n | p2_i\\n |\\n | p1_i P_i p3_i\\n |\\n ------------- x p4_i\\n\\n\\n The sets p1, p2, p3, and p4 are used in estimating the divergence for each point P_i. The partial\\n derivatives are calculated with a three-point centered difference.\\n\\n The extra points are \\\"smuggled\\\" into the loss function in the data argument:\\n\\n data.head() =\\n < y_true > <------ p1 -------> <------- p2 ------> <------- p3 ------> <--------p4 ------>\\n | u | v | x1 | y1 | h | x2 | y2 | h | x3 | y3 | h | x4 | y4 | h |\\n \\\"\\\"\\\"\\n y_true = data[:,:2]\\n p1 = data[:,2:5]\\n p2 = data[:,5:8]\\n p3 = data[:,8:11]\\n p4 = data[:,11:14]\\n\\n ### Calculate divergence using model predictions:\\n\\n # Step 1: Use the model to calculate predicted wind field in the surrounding points p1, p2, p3 and p4.\\n y_pred_p1 = model(p1)\\n y_pred_p2 = model(p2)\\n y_pred_p3 = model(p3)\\n y_pred_p4 = model(p4)\\n\\n # Step 2: Calculate the partial derivatives with a three-point centered difference.\\n scale_x = self.scaler_data.scale_[0] #scale-factor for x\\n scale_y = self.scaler_data.scale_[1] #scale-factor for y\\n\\n dudx = (y_pred_p1[:, 0] - y_pred_p3[:, 0]) / (p1[:,0] - p3[:,0]) # <- pj = transformed data\\n dvdy = (y_pred_p2[:, 1] - y_pred_p4[:, 1]) / (p2[:,1] - p4[:,1]) # <- pj = transformed data\\n\\n # Step 3: Calculate the divergence.\\n divergence = ( dudx / scale_x + dvdy / scale_y ) * np.mean([scale_x, scale_y])\\n #tf.print(K.mean(K.abs(divergence)))\\n\\n # Step 4: Calculate and return total loss.\\n return K.mean(K.square(y_true - y_pred)) + gamma*K.mean(K.square(divergence))\\n return loss\",\n \"def log(self, x_old, grad, x, curr_iter, tol_g_val, tol_x_val, tol_f_val):\\n\\n print(\\\"-----------------------------------\\\")\\n print(\\\"\\\\n Iter: \\\", curr_iter)\\n print(\\\"\\\\n x_old: \\\", x_old)\\n print(\\\"\\\\n gradient: \\\", grad)\\n print(\\\"\\\\n x: \\\", x)\\n print(\\\"\\\\n tol_x_val: \\\", tol_x_val)\\n print(\\\"\\\\n tol_f_val: \\\", tol_f_val)\\n print(\\\"\\\\n tol_g_val: %s \\\\n \\\" % tol_g_val)\",\n \"def logp_grad(self, xs, ys, fs, **kwargs):\",\n \"def _log_likelihood_gradients(self):\\r\\n return np.hstack((self.kern.dK_dtheta(dL_dK=self.dL_dK, X=self.X), self.likelihood._gradients(partial=np.diag(self.dL_dK))))\",\n \"def _m_step(self, x, log_resp):\\n x = self.check_size(x)\\n\\n resp = tf.exp(log_resp)\\n\\n pi = tf.reduce_sum(resp, axis=0, keepdims=True) + self.eps\\n\\n resp = tf.cast(resp, tf.double)\\n pi = tf.cast(pi, tf.double)\\n x = tf.cast(x, tf.double)\\n\\n mu = tf.reduce_sum(resp * x, axis=0, keepdims=True) / pi\\n\\n if self.covariance_type == \\\"full\\\":\\n eps = (tf.linalg.eye(self.n_features) * self.eps)\\n eps = tf.cast(eps, tf.double)\\n\\n var = tf.reduce_sum(tf.matmul(tf.expand_dims(x - mu, -1), tf.expand_dims(x - mu, -2)) * tf.expand_dims(resp, -1), axis=0,\\n keepdims=True) / tf.expand_dims(tf.reduce_sum(resp, axis=0, keepdims=True), -1) + eps\\n elif self.covariance_type == \\\"diag\\\":\\n x2 = tf.reduce_sum((resp * x * x), axis=0, keepdims=True) / pi\\n mu2 = mu * mu\\n xmu = tf.reduce_sum((resp * mu * x), axis=0, keepdims=True) / pi\\n var = x2 - 2 * xmu + mu2 + self.eps\\n\\n pi = pi / x.shape[0]\\n\\n return pi, mu, var\",\n \"def logm(self, x):\\n\\n if K.backend() == 'theano':\\n # construct theano tensor operation\\n from theano.tensor.nlinalg import svd, diag\\n from theano.tensor.elemwise import Elemwise\\n from theano.scalar import log\\n import theano.tensor as T\\n # This implementation would be extremely slow. but efficient?\\n u, d, v = svd(x)\\n d += self.eps\\n inner = diag(T.log(d))\\n res = T.dot(u, T.dot(inner, v))\\n return res\\n else:\\n from kyu.tensorflow.ops.svd_gradients import batch_matrix_log\\n return batch_matrix_log(x, self.eps)\",\n \"def _optfn(self, x):\\n\\n logger.debug(\\\" optfn(theta=%s)\\\", str(x))\\n\\n wmx = max(self.weights) * self.weighttrunc\\n\\n ip = []\\n for i,w in enumerate(self.weights):\\n if w < wmx:\\n continue\\n ip.append((i,w,x))\\n\\n if self.pool is None:\\n itr = map(self.worker.loglik_grad, ip)\\n else:\\n itr = self.pool.imap_unordered(_pool_loglik_grad, ip, 10)\\n\\n if self._prior_shape is None:\\n ll = 0.\\n grad = np.zeros(len(x))\\n else:\\n ll = sum(sp.special.xlogy(self._prior_shape-1,x)-(x/self._prior_scale))\\n grad = (self._prior_shape - 1)/x - 1/self._prior_scale\\n\\n for l,g in itr:\\n ll += l\\n grad += g\\n\\n logger.debug(\\\" optfn=%g\\\", ll)\\n\\n return -ll, -grad\",\n \"def log_pacc(xy, x, y, h):\\n logp = log_q(xy, y, x, h)\\n logp += xy.log_density(y)\\n logp -= log_q(xy, x, y, h)\\n logp -= xy.log_density(x)\\n return logp\",\n \"def fgsm(model, x, y, epsilon=0.1, label_leaking=True):\\n delta = torch.zeros_like(x, requires_grad=True)\\n logits = model(x + delta)\\n # Use the model's output instead of the true labels to avoid label leaking at training time.\\n if not label_leaking:\\n y = logits.max(dim=1)[1]\\n loss = nn.CrossEntropyLoss()(logits, y)\\n loss.backward()\\n return epsilon * delta.grad.detach().sign()\",\n \"def _call(self, x):\\n if self.prior is None:\\n tmp = -1.0 * (np.log(1 - x)).inner(self.domain.one())\\n else:\\n tmp = (-self.prior * np.log(1 - x)).inner(self.domain.one())\\n if np.isnan(tmp):\\n # In this case, some element was larger than or equal to one\\n return np.inf\\n else:\\n return tmp\",\n \"def log_probability(self, X):\\n\\n\\t\\treturn self.__log_probability(X)\",\n \"def logaddexp(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\\n return torch.max(x, y) + torch.log(1 + torch.exp(-torch.abs(y - x)))\",\n \"def zkl_divergence(x, y, gamma):\\n return np.sum([p_i*np.log(p_i/q_i) if q_i > 0 and p_i > 0 else p_i*gamma for (p_i, q_i) in zip(x, y)])\",\n \"def forward(self, x):\\n\\n embeds = self.dvector(x)\\n logits = self.linear(embeds)\\n\\n return logits\",\n \"def calculate_log_q_prior(theta, mu, rho):\\n\\n sigma = tf.nn.softplus(rho)\\n log_qw = tm.log_gaussian(theta, mu, sigma)\\n return tf.reduce_sum(log_qw)\",\n \"def _log_probability(self, theta, model, bounds, x, y, yerr):\\n lp = self._log_prior(theta, bounds)\\n if not np.isfinite(lp):\\n return -np.inf\\n return lp + self._log_likelihood(theta, model, x, y, yerr)\",\n \"def logbarrierfunc(delta, z, use_sigma):\\n if use_sigma:\\n z = np.where(z >= 0, np.tanh(z), z)\\n k = 2\\n return np.where(z > delta, -np.log(np.abs(z)),\\n ((k - 1) / k) * (((z - k * delta) / ((k - 1) * delta)) ** k - 1) - np.log(delta))\",\n \"def forward_pass(self, x):\\n self.x = x\\n exp_x = np.exp(x)\\n sum_x = np.sum(axis=1)\\n return exp_x/sum_x\",\n \"def gelu(self, x):\\r\\n cdf = 0.5 * (1.0 + tf.tanh(\\r\\n (np.sqrt(2 / np.pi) * (x + 0.044715 * tf.pow(x, 3)))))\\r\\n return x * cdf\",\n \"def derivative(self, theta):\\n diag_gamma = np.dot(theta.T, self.X.T)\\n logistic_term = self.logistic_fn(diag_gamma)\\n diag_gamma = logistic_term * (1.0 - logistic_term)\\n gamma = np.diag(diag_gamma)\\n\\n # v computation\\n diags_v = 1.0 - 2*self.logistic_fn(np.dot(theta.T, self.X.T))\\n diags_v = diags_v.reshape((-1, 1))\\n diags_v = diags_v*self.X\\n assert diags_v.shape == self.X.shape #N*d shape\\n\\n XtGamma = np.dot(self.X.T, gamma) # d*N shape\\n\\n # TODO: Verifier car pas sur de mon coup ... et surtout plus long...\\n # id = np.eye(self.n_examples).reshape((self.n_examples, self.n_examples, 1))\\n # diags_v = diags_v.reshape((self.n_examples, 1, self.dim))\\n # v = id*diags_v # n*n*d tensor\\n # left = np.tensordot(XtGamma, v, axes=(1, 0)) # shape d*N*d\\n # assert left.shape == (self.dim, self.n_examples, self.dim)\\n # dg = np.tensordot(left, self.X, axes=(1, 0))\\n # dg = np.swapaxes(dg, axis1=-2, axis2=-1)\\n\\n dg = np.zeros((self.dim, self.dim, self.dim))\\n for idx, v_i_diag in enumerate(diags_v.T):\\n v_i = np.diag(v_i_diag)\\n dg_di = np.dot(np.dot(XtGamma, v_i), self.X)\\n dg[:, :, idx] = dg_di\\n return dg\",\n \"def forward(self, x):\\n return F.log_softmax(self.proj(x), dim=-1)\",\n \"def gradient_model (self, x, initial_weights = None, \\\\\\n step_size = 5.0e-6, tol = 2.5e+7, n_iters = 501, l2 = 0):\\n # setup initial intercept, slope, iter number and rss\\n if initial_weights is None:\\n weights = self.initial_weight\\n else:\\n weights = initial_weights\\n # Compute indicator value for (y_i = +1)\\n indicators = np.array([int (i) for i in (self.train_output_y==1)])\\n for itr in range(n_iters):\\n # Predict P(y_i = +1|x_1,w) using your predict_probability() function\\n _, pred_probs = self.predict_probability(self.train_feature_x, weights)\\n \\n # Compute the errors as indicator - predictions\\n errors = indicators - pred_probs\\n\\n #Update the weights:\\n derivative = self.feature_derivative(errors, weights, l2)\\n weights = weights + derivative * (step_size) \\n \\n #check if converged\\n #todo\\n \\\"\\\"\\\"\\n # Checking whether log likelihood is increasing\\n if itr <= 15 or (itr <= 100 and itr % 10 == 0) or (itr <= 1000 and itr % 100 == 0) \\\\\\n or (itr <= 10000 and itr % 1000 == 0) or itr % 10000 == 0:\\n lp = self.compute_log_likelihood(indicators,weights)\\n print 'iteration %*d: log likelihood of observed labels = %.8f' % \\\\\\n (int(np.ceil(np.log10(n_iters))), itr, lp)\\n \\\"\\\"\\\"\\n \\n #check weights\\n #print \\\"\\\\n\\\"\\n #print \\\"The weights for features: \\\", weights\\n #final prediction\\n preds = self.prediction(x, weights)\\n return preds, weights\",\n \"def loglikelihood(self, x, previous=False):\\r\\n # testing of original fct: MC integrate must be one: mean(p(x_i)) * volume(where x_i are uniformely sampled)\\r\\n # for i in range(3): print mean([cma.likelihood(20*r-10, dim * [0], None, 3) for r in rand(10000,dim)]) * 20**dim\\r\\n # TODO: test this!!\\r\\n # c=cma.fmin...\\r\\n # c[3]['cma'].loglikelihood(...)\\r\\n\\r\\n if previous and hasattr(self, 'lastiter'):\\r\\n sigma = self.lastiter.sigma\\r\\n Crootinv = self.lastiter._Crootinv\\r\\n xmean = self.lastiter.mean\\r\\n D = self.lastiter.D\\r\\n elif previous and self.countiter > 1:\\r\\n raise _Error('no previous distribution parameters stored, check options importance_mixing')\\r\\n else:\\r\\n sigma = self.sigma\\r\\n Crootinv = self._Crootinv\\r\\n xmean = self.mean\\r\\n D = self.D\\r\\n\\r\\n dx = array(x) - xmean # array(x) - array(m)\\r\\n n = self.N\\r\\n logs2pi = n * log(2*np.pi) / 2.\\r\\n logdetC = 2 * sum(log(D))\\r\\n dx = np.dot(Crootinv, dx)\\r\\n res = -sum(dx**2) / sigma**2 / 2 - logs2pi - logdetC/2 - n*log(sigma)\\r\\n if 1 < 3: # testing\\r\\n s2pi = (2*np.pi)**(n/2.)\\r\\n detC = np.prod(D)**2\\r\\n res2 = -sum(dx**2) / sigma**2 / 2 - log(s2pi * abs(detC)**0.5 * sigma**n)\\r\\n assert res2 < res + 1e-8 or res2 > res - 1e-8\\r\\n return res\",\n \"def _log_likelihood_gradients(self):\\n return np.hstack((self.kern.dK_dtheta(dL_dK=self.dL_dK,X=self.X,slices1=self.Xslices,slices2=self.Xslices), self.likelihood._gradients(partial=np.diag(self.dL_dK))))\",\n \"def L1_log_likelihood_gradient(X, y, B, lmbda):\\n pass\",\n \"def calc_energy_and_force(self, h, x, beta):\\n h = h.clone().detach()\\n h.requires_grad_(True)\\n log_QhGx = self.encoder.calc_logQhGx(x, h)\\n log_Pxh = self.decoder.calc_logPxh(x,h)\\n energy = - (beta * log_Pxh + (1-beta)*log_QhGx)\\n h_grad = autograd.grad(outputs = energy,\\n inputs = h,\\n grad_outputs = torch.ones_like(energy))[0]\\n return energy.data, h_grad.data, log_QhGx.data, log_Pxh.data\",\n \"def gamma(x):\\n return 0.0\",\n \"def gelu(x):\\n cdf = 0.5 * (1.0 + tf.tanh(\\n (np.sqrt(2 / np.pi) * (x + 0.044715 * tf.pow(x, 3)))))\\n return x * cdf\",\n \"def maximize_one(self, gamma, xisum, c, x_digits):\\n log_likelihood = np.log(c).sum()\\n self._i = gamma[0] / gamma[0].sum()\\n self._t = (xisum.T / xisum.sum(1)).T\\n self._e = np.dot(x_digits, gamma) / gamma.sum(0)\\n return log_likelihood\",\n \"def _x(rho, z):\\r\\n a = (1 - 2*rho*z + z**2)**.5 + z - rho\\r\\n b = 1 - rho\\r\\n return np.log(a / b)\",\n \"def forward(ctx,gamma_mu,xtilde,mode_training=True):\\n # Device CPU/GPU\\n # if device == \\\"cuda\\\":\\n # dtype = torch.cuda.FloatTensor\\n # else :\\n dtype = torch.FloatTensor\\n #initialize variables\\n n,_,nx = xtilde.size()\\n x1,x2,x3 = torch.zeros(n,1,1).type(dtype),torch.zeros(n,1,1).type(dtype),torch.zeros(n,1,1).type(dtype) \\n crit,crit_compare = torch.zeros(n,1,1).type(dtype),torch.zeros(n,1,1).type(dtype)\\n sol = torch.zeros(n,1,nx).type(dtype)\\n kappa = torch.zeros(n,1,1).type(dtype)\\n xmin = 0\\n xmax = 1\\n u = 1/nx**2*torch.linspace(1,nx,nx)\\n norm_u = torch.norm(u)**2\\n uTx = torch.matmul(xtilde,u).view(n,1,1)\\n torch_u = u.view(1,1,-1)+torch.zeros(n,1,nx).type(dtype)#broadcast\\n torch_one = torch.ones(n,1,1).type(dtype)\\n #set coefficients\\n a = -(xmin+xmax+uTx)\\n b = xmin*xmax + uTx*(xmin+xmax) - 2*gamma_mu*norm_u\\n c = gamma_mu*(xmin+xmax)*norm_u - uTx*xmin*xmax\\n p = b - (a**2)/3\\n q = c - a*b/3 + 2*(a**3)/27\\n delta = (p/3)**3 + (q/2)**2\\n #three cases depending on the sign of delta\\n #########################################################################\\n #when delta is positive\\n ind = delta>0\\n z1 = -q[ind]/2\\n z2 = torch.sqrt(delta[ind])\\n w = (z1+z2).sign() * torch.pow((z1+z2).abs(),1/3)\\n v = (z1-z2).sign() * torch.pow((z1-z2).abs(),1/3) \\n x1[ind] = w + v \\n x2[ind] = -(w + v)/2 ; #real part of the complex solution\\n x3[ind] = -(w + v)/2 ; #real part of the complex solution\\n #########################################################################\\n #when delta is 0\\n ind = delta==0\\n x1[ind] = 3 *q[ind] / p[ind]\\n x2[ind] = -1.5 * q[ind] / p[ind]\\n x3[ind] = -1.5 * q[ind] / p[ind]\\n #########################################################################\\n #when delta is negative\\n ind = delta<0\\n cos = (-q[ind]/2) * ((27 / torch.pow(p[ind],3)).abs()).sqrt() \\n cos[cos<-1] = 0*cos[cos<-1]-1\\n cos[cos>1] = 0*cos[cos>1]+1\\n phi = torch.acos(cos)\\n tau = 2 * ((p[ind]/3).abs()).sqrt() \\n x1[ind] = tau * torch.cos(phi/3) \\n x2[ind] = -tau * torch.cos((phi + np.pi)/3)\\n x3[ind] = -tau * torch.cos((phi - np.pi)/3)\\n #########################################################################\\n x1 = x1-a/3\\n x2 = x2-a/3\\n x3 = x3-a/3\\n # when gamma_mu is very small there might be some numerical instabilities\\n # in case there are nan values, we set the corresponding pixels equal to 2*xmax\\n # these values will be replaced by valid values at least once\\n if (x1!=x1).any():\\n x1[x1!=x1]=2*xmax\\n if (x2!=x2).any():\\n x2[x2!=x2]=2*xmax\\n if (x3!=x3).any():\\n x3[x3!=x3]=2*xmax\\n #########################################################################\\n #\\n sol = xtilde + (x1 - uTx)/norm_u*torch_u\\n kappa = x1\\n #########################################################################\\n #take x1\\n p1 = sol\\n uTp1 = torch.matmul(p1,u).view(n,1,1)\\n ind = (uTp1>xmin)&(uTp1<xmax)\\n crit[~ind] = np.inf\\n crit[ind] = -(torch.log(uTp1[ind]-xmin)+torch.log(xmax-uTp1[ind]))\\n crit = 0.5*torch.norm(p1-xtilde,dim=2).view(n,1,1)**2+gamma_mu*crit \\n #########################################################################\\n #test x2\\n p2 = xtilde + (x2 - uTx)/norm_u*torch_u\\n uTp2 = torch.matmul(p2,u).view(n,1,1) \\n ind = (uTp2 >xmin)&(uTp2 <xmax)\\n crit_compare[~ind] = np.inf\\n crit_compare[ind] = -(torch.log(uTp2[ind]-xmin)+torch.log(xmax-uTp2[ind]))\\n crit_compare = 0.5*torch.norm(p2-xtilde,dim=2).view(n,1,1)**2+gamma_mu*crit_compare\\n # Select solution between p1 and p2\\n ind = (crit_compare<=crit) + torch.zeros(n,1,nx)#broadcasting\\n ind = ind>0\\n sol[ind] = p2[ind]\\n kappa[crit_compare<=crit]= x2[crit_compare<=crit]\\n crit[crit_compare<=crit] = crit_compare[crit_compare<=crit]\\n #########################################################################\\n #test x3\\n p3 = xtilde + (x3 - uTx)/norm_u*torch_u\\n uTp3 = torch.matmul(p3,u).view(n,1,1)\\n ind = (uTp3>xmin)&(uTp3<xmax)\\n crit_compare[~ind] = np.inf\\n crit_compare[ind] = -(torch.log(uTp3[ind]-xmin)+torch.log(xmax-uTp3[ind]))\\n crit_compare = 0.5*torch.norm(p3-xtilde,dim=2).view(n,1,1)**2+gamma_mu*crit_compare\\n # Select solution between p3 and (p2,p1)\\n ind = (crit_compare<=crit)+ torch.zeros(n,1,nx)#broadcasting\\n ind = ind>0\\n sol[ind] = p3[ind]\\n kappa[crit_compare<=crit]= x3[crit_compare<=crit]\\n crit[crit_compare<=crit] = crit_compare[crit_compare<=crit]\\n #########################################################################\\n #test xmin+1e-10\\n crit_compare = 0.5*torch.norm(xtilde-xmin-1e-10,dim=2).view(n,1,1)**2-gamma_mu*(\\n torch.log(1e-10*torch_one)+torch.log((xmax-xmin-1e-10)*torch_one))\\n ind = (crit_compare<=crit)+ torch.zeros(n,1,nx)#broadcasting \\n ind = ind>0 \\n sol[ind] = 0*sol[ind]+(xmin+1e-10)\\n kappa[crit_compare<=crit]= uTx\\n crit[crit_compare<=crit] = crit_compare[crit_compare<=crit]\\n #########################################################################\\n #test xmax-1e-10\\n crit_compare = 0.5*torch.norm(xtilde-xmax+1e-10,dim=2).view(n,1,1)**2-gamma_mu*(\\n torch.log(1e-10*torch_one)+torch.log((xmax-xmin-1e-10)*torch_one))\\n ind = (crit_compare<=crit)+ torch.zeros(n,1,nx)#broadcasting\\n ind = ind>0\\n sol[ind] = 0*sol[ind]+(xmax-1e-10)\\n kappa[crit_compare<=crit]= uTx[crit_compare<=crit]\\n crit[crit_compare<=crit] = crit_compare[crit_compare<=crit]\\n #########################################################################\\n # when gamma_mu is very small and uTx is very close to one of the bounds,\\n # the solution of the cubic equation is not very well estimated -> test xtilde\\n #denom = (sol-xmin)*(sol-xmax)-2*gamma_mu -(sol-xtilde)*(xmin+xmax-2*sol)\\n uTx_ok = (uTx>xmin)&(uTx<xmax)\\n crit_compare[~uTx_ok] = np.inf\\n crit_compare[uTx_ok] = -(torch.log(xmax-uTx[uTx_ok])+torch.log(uTx[uTx_ok]-xmin))\\n crit_compare = gamma_mu*crit_compare\\n ind = (crit_compare<crit)+ torch.zeros(n,1,nx)#broadcasting\\n ind = ind>0\\n sol[ind] = xtilde[ind]\\n kappa[crit_compare<=crit]= uTx[crit_compare<=crit]\\n \\n if mode_training==True:\\n ctx.save_for_backward(gamma_mu,kappa,uTx,sol)\\n return sol\",\n \"def log_density(\\n self,\\n theta_unc: FloatArray,\\n *,\\n propto: bool = True,\\n jacobian: bool = True,\\n ) -> float:\\n lp = ctypes.pointer(ctypes.c_double())\\n err = ctypes.pointer(ctypes.c_char_p())\\n rc = self._log_density(\\n self.model, int(propto), int(jacobian), theta_unc, lp, err\\n )\\n if rc:\\n raise self._handle_error(err.contents, \\\"log_density\\\")\\n return lp.contents.value\",\n \"def logp(self, x):\\n pass\",\n \"def __call__(self, x):\\n\\n self.dbeads.q = x\\n e = self.dforces.pot # Energy\\n g = -self.dforces.f # Gradient\\n\\n return e, g\",\n \"def log_prob(self, z, x):\\n n_samples = z.shape[0].value\\n log_prob = 0\\n for i in range(self.time_steps):\\n lat_dim = self.transition.dim_x\\n obs_dim = self.emmision.dim_x\\n # Current time step latent state and observation\\n z_t = tf.slice(z, [0, i * lat_dim], [-1, lat_dim])\\n x_t = tf.slice(x, [0, i * obs_dim], [-1, obs_dim])\\n if i == 0:\\n log_prob += tf.reduce_sum(\\n self.init_state_p.log_prob(z_t), axis=1)\\n else:\\n log_prob += self.transition.log_prob(z_t, z_tminus)\\n log_prob += self.emmision.log_prob(x_t, z_t)\\n # Update the previous latent state for next iteration\\n z_tminus = z_t\\n return log_prob\",\n \"def gelu(x):\\n cdf = 0.5 * (1.0 + tf.tanh(\\n (np.sqrt(2 / np.pi) * (x + 0.044715 * tf.pow(x, 3)))))\\n return x * cdf\",\n \"def log_likelihood_exp(self, x):\\n predictions = self.get_predictions(x)\\n ll = 0.\\n for measurement in self.get_measurements:\\n m_obj = flavio.Measurement[measurement]\\n m_obs = m_obj.all_parameters\\n exclude_observables = set(m_obs) - set(self.observables)\\n prob_dict = m_obj.get_logprobability_all(predictions, exclude_parameters=exclude_observables)\\n ll += sum(prob_dict.values())\\n return ll\",\n \"def compute_log_prior(self,params: ndarray) -> float:\\n ln_tE = params[0]\\n ln_A0 = params[1]\\n ln_deltaT = params[2]\\n fbl = params[3]\\n mb = params[4]\\n\\n # Equation (16,15,17) (note that Albrow uses \\\"log\\\" for log10)\\n log10e = np.log10(np.exp(1))\\n ln_pr_ln_tE = np.log(0.476) - ((log10e*ln_tE - 1.333)**2 / 0.330) + np.log(log10e)\\n ln_pr_ln_A0 = np.log(0.660) - (1.289*log10e*ln_A0) + np.log(log10e)\\n ln_pr_ln_deltaT = np.log(0.156) - ((log10e*ln_deltaT - 1.432)**2 / 0.458) +\\\\\\n np.log(log10e)\\n \\n # Paper doesnt mention the prior used, but I assume it to be uniform\\n ln_pr_fbl = uniform.logpdf(fbl,0.0,1.0)\\n\\n # Paper doesnr mention the prior used but I will asuumed it to be uniform\\n ln_pr_mb = uniform.logpdf(mb,self.mag_min - 1.0, self.mag_max + 1.0)\\n \\n \\n return ln_pr_fbl + ln_pr_ln_A0 + ln_pr_ln_deltaT + ln_pr_ln_tE + ln_pr_mb\",\n \"def forward(self, x: torch.Tensor) -> torch.Tensor:\\n return torch.nn.functional.linear(\\n x,\\n self.weight_mu + self.weight_sigma * self.weight_epsilon,\\n self.bias_mu + self.bias_sigma * self.bias_epsilon,\\n )\",\n \"def forward(self, x):\\n # action\\n act = self.act_fc1(x)\\n act = torch.tanh(act)\\n act = self.act_fc2(act)\\n act = torch.tanh(act)\\n mean = self.mu(act) # N, num_actions\\n logstd = self.logstd.expand_as(mean)\\n std = torch.exp(logstd)\\n action = torch.normal(mean, std)\\n\\n # value\\n v = self.value_fc1(x)\\n v = torch.tanh(v)\\n v = self.value_fc2(v)\\n v = torch.tanh(v)\\n v = self.value_fc3(v)\\n\\n # action prob on log scale\\n logprob = log_normal_density(action, mean, std=std, log_std=logstd)\\n return v, action, logprob, mean\",\n \"def log_prob(self, x):\\n n_samples = x.shape[0].value\\n log_prob = 0\\n for i in range(self.time_steps):\\n obs_dim = self.transition.dim_x\\n # Current time step latent state and observation\\n x_t = tf.slice(x, [0, i * obs_dim], [-1, obs_dim])\\n if i == 0:\\n log_prob += tf.reduce_sum(\\n self.init_state_p.log_prob(x_t), axis=1)\\n else:\\n log_prob += self.transition.log_prob(x_t, x_tminus)\\n # Update the previous latent state for next iteration\\n x_tminus = x_t\\n return log_prob\",\n \"def get_dphi_dx_fast(self, sess, x_train):\\n dphi_dx = tf.gradients(self.featurizations, self.x)\\n feed_dict = {self.x: x_train}\\n dphi_dx_np = sess.run(dphi_dx, feed_dict = feed_dict)\\n return dphi_dx_np\",\n \"def logp(self, x):\\n p_trans = self.p_trans\\n p_t0 = self.p_t0 # Probability for first point (unconditional)\\n p_t1 = self.p_t1 # Probability for second point (conditional on first)\\n p_t2 = self.p_t2 # Probability for third point (conditional on first and second)\\n\\n # Probability of the next points (conditional on previous 3 points) - P(x_t | x_t-1, x_t-1)\\n p_t = p_trans[x[:-3], x[1:-2], x[2:-1]] # Index into trans matrix to generate categorical probabilities for each point,\\n # where p_trans is indexed by furthest back point first i.e. p_trans[x_t-2, x_t-1]\\n\\n x_ti = x[3:] # The first and second and third point is not based on 2 back, this is what we are trying to predict\\n likelihood_ti = pm.Categorical.dist(p_t).logp(x_ti) # likelihood for dynamic process_datasets\\n # Full likelihood is static first point + static second point + dynamic next points\\n return pm.Categorical.dist(p_t0).logp(x[0]) + pm.Categorical.dist(p_t1[x[0]]).logp(x[1]) \\\\\\n + pm.Categorical.dist(p_t2[x[0],x[1]]).logp(x[2]) + tt.sum(likelihood_ti)\",\n \"def forward(self, x) -> Tuple[Tensor, Tensor]:\\n x = F.relu(self.fc1(x.float()))\\n a = F.log_softmax(self.actor_head(x), dim=-1)\\n c = self.critic_head(x)\\n return a, c\",\n \"def forward(self, x):\\n # draw gumbel noise\\n shp = x.shape\\n eps = self.eps\\n # footnote 1 from https://arxiv.org/pdf/1611.01144.pdf,\\n # with a guard against log of 0\\n # u = np.random.uniform(low=0, high=1, size=shp)\\n # TODO: can this be replaced with rng.gumbel()?\\n # what is the relatinship between low, high and gumbel parameters?\\n u = self.rng.uniform(low=0, high=1, size=shp)\\n g = -np.log(-np.log(u + eps) + eps)\\n # x are the \\\"logits\\\" from the paper, add gumbel noise and normalize by temperature\\n y = x + g\\n yy = y / self.tau\\n return self.smax.forward(yy)\",\n \"def posterior_loss(X, mu, sigma, log_pi):\\r\\n log_PDF = log_GaussPDF(X, mu, sigma)\\r\\n log_post = log_posterior(log_PDF, log_pi)\\r\\n\\r\\n loss = torch.logsumexp(log_post, dim=1)\\r\\n # loss = torch.exp(log_post)\\r\\n # loss = torch.sum(loss, dim=1)\\r\\n # loss = torch.log(loss)\\r\\n loss = torch.sum(loss)\\r\\n loss = -loss\\r\\n return loss\",\n \"def test_log():\\n x, y = fwd.Variable(), fwd.Variable()\\n f = fwd.log(fwd.sin(x)+y**2)\\n dfdx = lambda x, y: np.cos(x) / (np.sin(x)+y**2)\\n dfdy = lambda x, y: 2*y / (np.sin(x)+y**2)\\n d2fdxdy = lambda x, y: -2*y*np.cos(x) / (np.sin(x)+y**2)**2\\n assert equals(f.evaluation_at({x: 1.5, y:2.5}), np.log(np.sin(1.5)+2.5**2))\\n assert equals(f.derivative_at(x, {x: 1.5, y:2.5}), dfdx(1.5, 2.5))\\n assert equals(f.derivative_at(y, {x: 1.5, y:2.5}), dfdy(1.5, 2.5))\\n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}), d2fdxdy(1.5, 2.5))\\n with pytest.raises(NotImplementedError):\\n f.derivative_at(x, {x:1.0, y: 2.0}, order=3)\",\n \"def log_prior(cosmo_param):\\n\\n Omega_m, beta = cosmo_param\\n\\n # Get bounds\\n bounds = get_bounds()\\n\\n if bounds[0][0] < Omega_m < bounds[0][1] and bounds[1][0] < beta < bounds[1][1]:\\n return 0.0 \\n return -np.inf\",\n \"def _calculate_ll(self, x):\\n observation_log_probs = self._observation_log_probs(x, mask=None)\\n forward_log_probs = self._forward(observation_log_probs)\\n log_likelihood = logsumexp(\\n forward_log_probs[forward_log_probs.shape[0] - 1, :].numpy())\\n return log_likelihood\",\n \"def log_agm(x, prec):\\n x2 = (x*x) >> prec\\n # Compute jtheta2(x)**2\\n s = a = b = x2\\n while a:\\n b = (b*x2) >> prec\\n a = (a*b) >> prec\\n s += a\\n s += (MPZ_ONE<<prec)\\n s = (s*s)>>(prec-2)\\n s = (s*isqrt_fast(x<<prec))>>prec\\n # Compute jtheta3(x)**2\\n t = a = b = x\\n while a:\\n b = (b*x2) >> prec\\n a = (a*b) >> prec\\n t += a\\n t = (MPZ_ONE<<prec) + (t<<1)\\n t = (t*t)>>prec\\n # Final formula\\n p = agm_fixed(s, t, prec)\\n return (pi_fixed(prec) << prec) // p\",\n \"def forward(self, x, y):\\n\\n masked = self.mask * x\\n\\n s = self.s(masked, y)\\n t = self.t(masked, y)\\n z = masked + (1 - self.mask) * (x * s.exp() + t)\\n\\n log_det = (s * (1 - self.mask)).sum(1)\\n\\n return z, log_det\",\n \"def forward(self, X, labels):\\n features = self.get_conv_feats(X)\\n W = self.W\\n T = self.T\\n log_prob = CRFautograd.apply(W, T, features, labels)\\n return log_prob\",\n \"def psi_x0(z, x, gamma, dx):\\n \\n if x == 0:\\n return (psi_x(z, -dx/2, gamma) + psi_x(z, dx/2, gamma))/2\\n else:\\n return psi_x(z, x, gamma)\",\n \"def gelu(x):\\n cdf = 0.5 * (1.0 + torch.tanh(\\n (np.sqrt(2 / np.pi) * (x + 0.044715 * torch.pow(x, 3)))))\\n return x * cdf\",\n \"def post_rho(store):\\n return loglike(store) + prior_rho(store)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6992019","0.66589755","0.6592865","0.65579003","0.6555126","0.64870846","0.6481399","0.6379075","0.6354919","0.6340459","0.6330749","0.6322805","0.6269888","0.6226955","0.61627597","0.613101","0.61285204","0.6118351","0.6108239","0.61030525","0.6101484","0.6053687","0.6002438","0.59783095","0.5965504","0.5957795","0.59239334","0.59196675","0.5916815","0.5916182","0.5902321","0.58785224","0.58611035","0.5856163","0.5835269","0.5829248","0.5805655","0.57938284","0.5791159","0.5790163","0.5788697","0.57769156","0.57710296","0.5762109","0.57542765","0.5751777","0.5728402","0.5719069","0.57119507","0.57116693","0.57086","0.570598","0.5705081","0.5704443","0.5703372","0.57011944","0.5701009","0.56909555","0.5685078","0.5670219","0.5669711","0.5661168","0.5659771","0.56462914","0.56412345","0.56399673","0.5638617","0.56376326","0.5628559","0.5624709","0.5597703","0.5595241","0.5590743","0.5581548","0.55740964","0.5561943","0.5559154","0.5557609","0.5556711","0.5553937","0.5549779","0.5548486","0.55467033","0.55418795","0.5538212","0.5535977","0.553515","0.55253214","0.5518153","0.55174315","0.5508754","0.55049866","0.54895526","0.5487605","0.5486442","0.5484324","0.5483428","0.5481123","0.5478784","0.547578","0.5474333"],"string":"[\n \"0.6992019\",\n \"0.66589755\",\n \"0.6592865\",\n \"0.65579003\",\n \"0.6555126\",\n \"0.64870846\",\n \"0.6481399\",\n \"0.6379075\",\n \"0.6354919\",\n \"0.6340459\",\n \"0.6330749\",\n \"0.6322805\",\n \"0.6269888\",\n \"0.6226955\",\n \"0.61627597\",\n \"0.613101\",\n \"0.61285204\",\n \"0.6118351\",\n \"0.6108239\",\n \"0.61030525\",\n \"0.6101484\",\n \"0.6053687\",\n \"0.6002438\",\n \"0.59783095\",\n \"0.5965504\",\n \"0.5957795\",\n \"0.59239334\",\n \"0.59196675\",\n \"0.5916815\",\n \"0.5916182\",\n \"0.5902321\",\n \"0.58785224\",\n \"0.58611035\",\n \"0.5856163\",\n \"0.5835269\",\n \"0.5829248\",\n \"0.5805655\",\n \"0.57938284\",\n \"0.5791159\",\n \"0.5790163\",\n \"0.5788697\",\n \"0.57769156\",\n \"0.57710296\",\n \"0.5762109\",\n \"0.57542765\",\n \"0.5751777\",\n \"0.5728402\",\n \"0.5719069\",\n \"0.57119507\",\n \"0.57116693\",\n \"0.57086\",\n \"0.570598\",\n \"0.5705081\",\n \"0.5704443\",\n \"0.5703372\",\n \"0.57011944\",\n \"0.5701009\",\n \"0.56909555\",\n \"0.5685078\",\n \"0.5670219\",\n \"0.5669711\",\n \"0.5661168\",\n \"0.5659771\",\n \"0.56462914\",\n \"0.56412345\",\n \"0.56399673\",\n \"0.5638617\",\n \"0.56376326\",\n \"0.5628559\",\n \"0.5624709\",\n \"0.5597703\",\n \"0.5595241\",\n \"0.5590743\",\n \"0.5581548\",\n \"0.55740964\",\n \"0.5561943\",\n \"0.5559154\",\n \"0.5557609\",\n \"0.5556711\",\n \"0.5553937\",\n \"0.5549779\",\n \"0.5548486\",\n \"0.55467033\",\n \"0.55418795\",\n \"0.5538212\",\n \"0.5535977\",\n \"0.553515\",\n \"0.55253214\",\n \"0.5518153\",\n \"0.55174315\",\n \"0.5508754\",\n \"0.55049866\",\n \"0.54895526\",\n \"0.5487605\",\n \"0.5486442\",\n \"0.5484324\",\n \"0.5483428\",\n \"0.5481123\",\n \"0.5478784\",\n \"0.547578\",\n \"0.5474333\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83170,"cells":{"query":{"kind":"string","value":"Accepts a size and text of a message to print on a shirt."},"document":{"kind":"string","value":"def make_shirt(size, text):\n\tprint(f\"\\nThe size of the shirt is {size} and the printed text reads: {text}.\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def make_shirt(size, message):\n print(\"I need a shirt, size \" + size + \", that says \" + message + \".\")","def make_shirt(size, text):\n print('You wanted the t-shirt to be in size: ' + size)\n print('The message you wanted on the t-shirt: ' + text)","def make_shirt(size, message):\n print(\"My t-shirt is a size \" + size.upper() + \" and says, \" + message + \".\")","def make_shirt(message=\"I love Python\", size=\"L\"):\n print(\"A \" + size + \" t-shirt with the following message: \" + message)","def make_shirt(size, message):\n print(\"\\nI'm going to make a \" + size + \" t-shirt.\")\n print('It will say, \"' + message + '\"')","def make_shirt(size, message):\n print(\"\\nI'm going to make a \" + size + \" t-shirt.\")\n print('It will say, \"' + message + '\"')","def make_shirt(size='L', message='Look Away'):\n print(\"I need a shirt, size \" + size + \", that says \" + \"'\" + message + \"'.\")","def make_shirt2(text, size='large'):\n print(f\"\\nI'm going to make a {size} shirt that says {text}. \")","def make_shirt1(size, text):\n print(f\"\\nI'm going to make a {size} shirt that says {text}. \")","def make_shirt(size=\"Large\", message=\"I Love Python\"):\n print(\"\\nI am going to make a \" + size + \" T-shirt \")\n print(\"It will say,\" + message)","def make_shirt(text = 'I love Python', size = 'large'):\n\tprint(\"The size of the shirt is: \" + size.title() + \".\")\n\tprint(\"The text printed on the shirt is: \" + text.title() + '\\n')","def make_shirt(size='large', message='I love Python!'):\n print(\"\\nI'm going to make a \" + size + \" t-shirt.\")\n print('It will say, \"' + message + '\"')","def make_shirt(size='large', message='I love Python!'):\n print(\"\\nI'm going to make a \" + size + \" t-shirt.\")\n print('It will say, \"' + message + '\"')","def make_shirt(size, text):\n print(\"I'll be making a \" + size + \" shirt with '\" + text + \"' written on\"\n + \" the front of it.\")","def make_shirt(text='I love Python', size='large'):\t\n\tprint(f\"\\nThe size of the shirt is {size} and the printed text reads: {text}.\")","def make_shirt(size='large', text='I love Python'):\n print(\"\\nThis t-shirt is size \" + size + \" and has the word(s): \" + text + \".\")","def display_message(self, text, color, text_size, coordinates):\n\n if text_size == \"large\":\n text_size = 100\n elif text_size == \"normal\":\n text_size = 60\n \n text_style = pygame.font.Font(\"etc/Roboto-Regular.ttf\", text_size)\n text_surface, text_rect = self.text_objects(text, text_style, color)\n text_rect.center = coordinates\n self.game_display.blit(text_surface, text_rect)\n pygame.display.update()","def print_message(self, message, color):\n\n xpos = 20\n ypos = self.height\n\n size = common.FONT_SIZE\n\n arcade.draw_text(\n text=message,\n start_x=xpos,\n start_y=ypos,\n anchor_x=\"left\",\n anchor_y=\"top\",\n width=size*len(message),\n color=color,\n font_size=size,\n bold=True)","def no_size_printer(self, data=None):\n border = self.options.border\n filler = self.options.filler\n spacer = self.options.spacer\n blocker = self.options.blocker\n # catch a blank line\n if data is None:\n data = spacer * int((70/len(self.options.spacer)))\n msg = \"{border}{0:{filler}^{size}}{border}\".format(\n data[:76], size=70, border=border, filler=filler\n )\n if self.options.verbose:\n print(msg)\n # return msg","def showText(self, context, text, size=1, color=colors.WHITE, conversion=True):\n context.print(text, self.components, size, color=color, conversion=conversion)","def print(self,text,position=None,size=None,color=mycolors.WHITE,font=None,conversion=True):\n if conversion:\n if not position: position=(0,0)\n if not size: size=1\n position=self.draw.plane.getToScreen(position,self.draw.window)\n ux,uy=self.draw.plane.units\n size=int(size*ux/50)\n else:\n if not position: position=(10,10)\n if not size: size=20\n self.window.print(text,position,size,color,font)","def Print(self, s, color=(229, 153, 153, 255)):\r\n self.screen.blit(self.font.render(s, True, color), (5, self.textLine))\r\n self.textLine += 15","def message_to_screen(msg,\n colour,\n y_displace=0,\n x_displace=0,\n size='small',\n side='center'):\n\ttext_surf, text_rect = text_object(msg, colour, size)\n\tif side == 'center':\n\t\ttext_rect.center = (display_width / 2) + x_displace, \\\n\t\t (display_height / 2) + y_displace\n\telif side == 'top':\n\t\ttext_rect.midtop = (display_width / 2) + x_displace, y_displace\n\telif side == 'bottom_left':\n\t\ttext_rect.bottomleft = (x_displace,\n\t\t display_height - y_displace)\n\telif side == 'bottom_right':\n\t\ttext_rect.bottomright = (display_width - x_displace,\n\t\t display_height - y_displace)\n\telif side == 'custom_center':\n\t\ttext_rect.center = x_displace, y_displace\n\telif side == 'custom_top':\n\t\ttext_rect.midtop = x_displace, y_displace\n\telif side == 'custom_bottom':\n\t\ttext_rect.midbottom = x_displace, y_displace\n\telif side == 'custom_bot_left':\n\t\ttext_rect.bottomleft = x_displace, y_displace\n\telif side == 'custom_bot_right':\n\t\ttext_rect.bottomright = x_displace, y_displace\n\telif side == 'custom_mid_right':\n\t\ttext_rect.midright = x_displace, y_displace\n\telif side == 'custom_mid_left':\n\t\ttext_rect.midleft = x_displace, y_displace\n\telse:\n\t\ttext_rect.center = (display_width / 2) + x_displace, \\\n\t\t (display_height / 2) + y_displace\n\tDisplay.blit(text_surf, text_rect)","def message_display(text, loc, size, color=None):\n # gameDisplay = pygame.display.set_mode((width, height))\n largeText = pygame.font.Font('freesansbold.ttf', size)\n TextSurf, TextRect = text_objects(text, largeText, color)\n TextRect.center = (loc[0], loc[1])\n gameDisplay.blit(TextSurf, TextRect)\n\n pygame.display.update()","def esprint(self,text,w=1,h=1):\n self.dps.set(height=h,width=w)\n self.dps.text(text)","def message(self, text):\n\n if type(text) in (bytes, str):\n T = text\n else:\n # list probably:\n T = '\\n'.join(text)\n print(('-'*60))\n print(T)\n print(('='*60))","def message_to_screen(msg,\n colour,\n y_displace=0,\n x_displace=0,\n size='small',\n side='center'):\n\ttext_surf, text_rect = text_object(msg, colour, size)\n\tif side == 'center':\n\t\ttext_rect.center = (display_width / 2) + x_displace, \\\n\t\t (display_height / 2) + y_displace\n\telif side == 'top':\n\t\ttext_rect.midtop = (display_width / 2) + x_displace, y_displace\n\telif side == 'bottom_left':\n\t\ttext_rect.bottomleft = (x_displace,\n\t\t display_height - y_displace)\n\telif side == 'bottom_right':\n\t\ttext_rect.bottomright = (display_width - x_displace,\n\t\t display_height - y_displace)\n\tDisplay.blit(text_surf, text_rect)","def print_text(TINY_FONT, x, y, text, color = white):\n text_image = TINY_FONT.render(text, True, color)\n gameDisplay.blit(text_image, (x,y))","def show_text(text, colour):\n message = font_style.render(text, True, colour)\n dis.blit(message, [game_size_x/2, game_size_y/2])","def print(self, my_screen, text_string):\n text_bitmap = self.font.render(text_string, True, BLACK)\n my_screen.blit(text_bitmap, [self.x_pos, self.y_pos])\n self.y_pos += self.line_height","def message(msg ,font_size, color , pos):\n font_style = pygame.font.SysFont( \"Times New Roman\" , font_size)\n mesg = font_style.render(msg, True, color)\n dis.blit(mesg, pos)\n pygame.display.update()","def changeScreen(msg, color, offset_x, offset_y, size):\n font = pygame.font.SysFont(\"headlinea\", size) # default font\n text = font.render(msg, True, color) \n text_rect = text.get_rect()\n text_x = Screen.get_width() / 2 - text_rect.width / 2 + offset_x\n text_y = Screen.get_height() / 2 - text_rect.height / 2 + offset_y \n Screen.blit(text, [text_x, text_y])","async def ascii(self, ctx, *, text):\n text = text.replace(' ', '\\n')\n \n if not text:\n await ctx.send(f\"{ctx.tick(False)} You need to specify the text you want to convert!\")\n \n _fig = figlet_format(text.replace(' ', '\\n'))\n \n if len(_fig) > 1300:\n await ctx.send(f\"{ctx.tick(False)} That message is too long!\")\n await ctx.send(f\"{ctx.tick(True)} Done!\")\n await ctx.send(f\"```{_fig}```\")","def write_text(size, text):\n img = Image.new('RGB', size, (255, 255, 255))\n draw = ImageDraw.Draw(img)\n font = ImageFont.truetype('/Library/Fonts/Arial.ttf', size)\n draw.text((10,10), text, (0, 0, 0), font=font)\n return img","def show_message_scrabble(self, player_name):\n\n interface_width = self.interface.GAME_WINDOW_WIDTH;\n interface_height = self.interface.GAME_WINDOW_HEIGHT;\n\n title_text = \"Le joueur \" + player_name + \" a fait un scrabble !!!\";\n subtitle_text = \"Il remporte 50 points bonus !\";\n\n self.message_scrabble.set_text_title(title_text);\n self.message_scrabble.set_text_subtitle(subtitle_text);\n self.message_scrabble.set_horizontal_alignment(Alignment.Center);\n self.message_scrabble.set_text_title_size(40);\n self.message_scrabble.set_text_subtitle_size(32);\n self.message_scrabble.set_space_between_titles(20);\n self.message_scrabble.set_color_title((0, 0, 0));\n self.message_scrabble.set_color_subtitle((0, 0, 0));\n self.message_scrabble.set_border_color((0, 0, 0));\n self.message_scrabble.set_border_thickness(4);\n\n self.message_scrabble.set_pos((interface_width/2, 200));\n\n self.message_placed_word.add_queued_message(self.message_scrabble, 3);","def message(msg, color):\n mesg = font_style.render(msg, True, color)\n dis.blit(mesg, [dis_width / 3, dis_height / 2])","def add_text(\n self,\n text: str,\n size: Size = Size.Medium,\n ) -> None: # noqa: E501\n if not isinstance(size, Size):\n size = Size(size)\n\n if size == Size.Small:\n self._client.add_element(element=Text(text, style=\"bodySmall\"))\n elif size == Size.Medium:\n self._client.add_element(element=Text(text, style=\"bodyMedium\"))\n elif size == Size.Large:\n self._client.add_element(element=Text(text, style=\"bodyLarge\"))","def draw_text(\n self, text: str, size: int, color: Tuple[int, int, int], x: int, y: int\n ) -> None:\n # TODO: Select and use a better font\n font = pg.font.Font(pg.font.get_default_font(), size)\n text_surface = font.render(text, True, color)\n text_rect = text_surface.get_rect()\n text_rect.midtop = (x, y)\n self.screen.blit(text_surface, text_rect)","async def printtext(self, ctx: discord.ext.commands.Context, *args):\n message_channel: discord.abc.Messageable = ctx.message.channel\n if len(args) == 1:\n received_string = args[0]\n if received_string.startswith('\"') and received_string.endswith('\"'):\n received_string = received_string[1:-1]\n pos = received_string.find(\"\\\\\")\n if pos != -1 and received_string[pos + 1] != \" \":\n print(\"Error:\" + received_string[pos + 1])\n return\n pos = received_string.find(\"\\\"\")\n if pos != -1:\n print(\"Error:\" + received_string[pos + 1])\n return\n final_string = \"\"\n number_emoji = self.botVariables.numbers_emoji\n for c in received_string:\n if c.isalnum():\n try:\n val = int(c)\n if val < 10:\n final_string += number_emoji[val] + \" \"\n else:\n print(\"fatal Error!!!-\" + str(val))\n except ValueError:\n c = c.lower()\n if c == \"è\" or c == \"é\" or c == \"à\" or c == \"ù\" or c == \"ì\":\n final_string += c + \" \"\n else:\n final_string += \":regional_indicator_\" + c + \":\" + \" \"\n else:\n if c == \"!\" or c == \"?\" or c == \"#\":\n if c == \"!\":\n final_string += \":exclamation:\" + \" \"\n else:\n if c == \"#\":\n final_string += \":hash:\" + \" \"\n else:\n final_string += \":question:\" + \" \"\n else:\n final_string += c + \" \"\n await message_channel.send(final_string)\n else:\n await message_channel.send(\n \"**Usage:** \" + self.command_prefix + \"printtext \\\"phrase\\\", for more see \"\n + self.command_prefix + \"help printtext\")","def print_message_nicely(message):\n print (\"\\n\\r\" + \"*\"*10 + \"\\n\" +\n \"\\rsender: \" + message[\"handle\"] + \"\\n\" +\n \"\\rmessage: \" + message[\"text\"] + \"\\n\\r\" +\n \"*\"*10 + \"\\n\")","def print_square(size):\n if not isinstance(size, int):\n raise TypeError(\"size must be an integer\")\n if (size < 0):\n raise ValueError(\"size must be >= 0\")\n if size > 0:\n print(\"\\n\".join([\"#\" * size for j in range(size)]))","def text(self, str: str, x: int, y: int, colour: int, /) -> None:","def showText(self, surface, point, text, color=None, size=20):\n if not color: color = self.color\n v = self / 2\n point = v(point)\n surface.print(text, tuple(point), color=color, size=size)","def print_square(size):\n int_err = \"size must be an integer\"\n val_err = \"size must be >= 0\"\n float_err = \"size must be an integer\"\n\n if not isinstance(size, int):\n raise TypeError(int_err)\n if size < 0:\n raise TypeError(val_err)\n if isinstance(size, float) and size < 0:\n raise TypeError(float_err)\n\n for i in range(size):\n print('#' * size)","def print_space(self,text,width,w=1,h=1):\n texlen = len(text)\n if texlen > width:\n text = text[:width]\n self.lesprint(text,width)","def print_message_center(self, message, color, size = common.FONT_SIZE):\n\n xpos = self.width / 2\n ypos = self.height / 2\n\n arcade.draw_text(\n text=message,\n start_x=xpos,\n start_y=ypos,\n anchor_x=\"center\",\n anchor_y=\"center\",\n align=\"center\",\n width=size*len(message),\n color=color,\n font_size=size,\n bold=True)","def size_pretty(size: typing.Union[str, int, float], int_only: bool = False, no_whitespace: bool = False) -> str:\n\n _size = float(size)\n wsp = \"\" if no_whitespace else \" \"\n wrap: typing.Callable[[float], typing.Union[int, float]] = lambda arg: arg if not int_only else int(round(arg))\n sz_ptn = '%.d' if int_only else '%.2f'\n\n if _size >= 0x10000000000:\n msg = (sz_ptn + '%sTB') % (wrap((_size / 0x10000000000)), wsp)\n elif _size >= 0x40000000:\n msg = (sz_ptn + '%sGB') % (wrap((_size / 0x40000000)), wsp)\n elif _size >= 0x100000:\n msg = (sz_ptn + '%sMB') % (wrap((_size / 0x100000)), wsp)\n elif _size >= 0x400:\n msg = (sz_ptn + '%sKB') % (wrap((_size / 0x400)), wsp)\n else:\n msg = ((int_only and '%s' or '%.f') + '%sBytes') % (wrap(_size), wsp)\n return msg","def take_easy():\r\n length = int(input())\r\n message = input()\r\n if length >= len(message):\r\n print(\"||||||\" + \"%.5s\" %message + \"||||||\")\r\n else:\r\n print(\" -----\")\r\n print(\"-|-|-|-|-|-----\" + \"%.4s\" %message + \")))\")\r\n print(\" -----\")","def draw_string(message, x, y, textSize):\r\n global _canvas\r\n global _current_color\r\n if _canvas == None:\r\n raise RuntimeError(\"Canvas is not open yet.\")\r\n else:\r\n t = Text(message, textSize)\r\n t.move(x, y)\r\n t.setFontColor(_current_color)\r\n _canvas.add(t)","def Print(self, text):\n pass","def _render_text(self, message, font=None):\n # Default to small font if not provided.\n if font is None:\n font = self._small_font\n return font.render(message, True, self._fgcolor, self._bgcolor)","def print_message(slogan_to_print):\r\n\r\n print(\"Your\", slogan_to_print, \"here!\")","def display_s(s, font, screen, lcd, size=5, x=0, y=0):\n i = 0\n spacing = size * .11\n s = str(s)\n char = s[0]\n char_w, char_h = font[char].size\n for c in s:\n display_c(c,font,screen,lcd,size,(int(i*spacing*char_w)+x),y)\n i += 1\n return screen","def showMessage(self, text, location, font, fontSize, colour=(255,255,255),\n input=False, secs=None):\n self.fill()\n self.text(text, location, font, fontSize, colour=colour)\n pygame.display.update()\n if input:\n currentEvent = self.input.input()\n while not self.input.checkInput(currentEvent):\n currentEvent = self.input.input()\n if not secs:\n self.timer.wait(secs)","def create_preview(message):","def _render_text_wrap(self, message, rect, font=None):\n # Default to small font if not provided.\n if font is None:\n font = self._small_font\n return self._render_textrect( message, font, rect, self._fgcolor, self._bgcolor)","def updateSizeBody(self, size): \n self.avatarConfiguration[\"bodySize\"] = size\n self.paintBody()\n self.paintShoes()\n if self.avatarConfiguration[\"gender\"] == \"boy\":\n self.paintShirt()\n self.paintTrousers()\n else:\n self.paintSkirt()","def on_size(self, event):\r\n event.Skip()\r\n self.text_info.Label = conf.InfoText\r\n wx.CallAfter(lambda: self and\r\n (self.text_info.Wrap(self.mediactrl.Size.width),\r\n self.text_info.Parent.Layout()))","def show_on_screen(self, string, location, font='Arial', font_size=20, colour=WHITE):\n msg = pygame.font.SysFont(font, font_size).render(str(string), True, colour)\n self.screen.blit(msg, location)","def show_theme_message(width):\n print_dotted_line()\n print_bold(\"Attack of The Orcs v0.0.5:\")\n msg = (\n \"\"\"\n Hrabri vitez Talion vraća se iz boja i želi predahnuti u jednom seocetu. \n U seocu se nalazi 5 kućica i želi stupiti u jednu od njih. \n Hrabri vitez ne zna da u ovom području ima neprijatelja.\n Odluči se za jedna od vrata ...\n \"\"\")\n\n print(textwrap.fill(msg, width=width))","def size_string(raw_text, size=MAX_DISPLAY_SIZE):\n if raw_text and len(raw_text) >= size:\n large_str = (\n f\"\\nFile contents truncated because file size is larger than maximum viewing size of {nice_size(size)}\\n\"\n )\n raw_text = f\"{raw_text[0:size]}{large_str}\"\n return raw_text or \"\"","def print(self, text, dpi):\r\n lines = self.__buildlines(text)\r\n return self.page(lines, dpi)","def send_size_event() -> None:\n terminal_size = self._get_terminal_size()\n width, height = terminal_size\n textual_size = Size(width, height)\n event = events.Resize(textual_size, textual_size)\n asyncio.run_coroutine_threadsafe(\n self._app._post_message(event),\n loop=loop,\n )","def display_message(self, message):\n text = self.font.render(message, True,\n self.display_states[self.display_names[self.current_display_state]]['text'])\n temp_width = text.get_rect().width\n self.gameDisplay.blit(text, ((self.SCREEN_WIDTH / 2) - (temp_width/2), 100))","def print_substep(text, style=\"\"):\n console.print(text, style=style)","def print_banner(text):\n print(Figlet(font='smslant').renderText(text))","def Print(self, message):\n self.script.append('ui_print(\"%s\");' % (message,))","def reprint() -> 'html':\n size = request.form['name']\n store(size)\n if size == '0':\n \"\"\"Empty database send back to previous page\"\"\"\n return previous()\n else:\n \"\"\"Selected file redirect to print details\"\"\"\n store(size)\n return pr(size,'From database')","def text(self, string,\n location,\n font, fontSize,\n antialias=False,\n colour=(0,0,0),\n newlinePad=5,\n screen=None):\n if not screen:\n screen = self.screen\n x = location[0]\n y = location[1]\n font = pygame.font.Font(font, fontSize)\n lines = string.split(\"\\n\")\n counter = 0\n height = 0\n for line in lines:\n fontSurface = font.render(line, antialias, colour).convert()\n if counter == 0:\n screen.blit(fontSurface, location)\n else:\n newY = y * counter + newlinePad + height\n screen.blit(fontSurface, (x, newY))\n height = font.size(line)[1] + height + newlinePad\n counter += 1","def boxTextFor(player, text = \"\"):\n pass_text = \"\"\n if isinstance( text, ( str, unicode ) ):\n pass_text = text\n return boxTextAt( pass_text, default_display_vars.borderChar_Left, default_display_vars.borderChar_Right, default_display_vars.boxText_padding, getUserScreenWidth( player ) )","def create_image_with_string(s, size, color, fontsize=10):\n from PIL import Image\n # from PIL import ImageFont\n from PIL import ImageDraw\n img = Image.new(\"RGB\", size, \"white\")\n\n draw = ImageDraw.Draw(img)\n# font = ImageFont.truetype('FreeMono', 10)\n options = [\n '/usr/local/texlive/2015/texmf-dist/fonts/truetype/public/gnu-freefont/FreeMono.ttf',\n '/usr/share/fonts/truetype/freefont/FreeMono.ttf']\n font = None\n for f in options:\n if os.path.exists(f):\n font = ImageFont.truetype(f, fontsize)\n break\n else:\n logger.info('Could not find any font in %r' % options)\n \n draw.text((0, 0), s, color, font=font)\n data = get_png(img)\n return data","def showMessage(self, message, surface=None, bg_color=None, rect=None):\r\n if surface is None:\r\n surface = self.infoPanel \r\n if bg_color is None:\r\n bg_color = gu.INFO_PANEL_COLOR\r\n if rect is None:\r\n rect = gu.INFO_RECT\r\n \r\n surface.fill(bg_color) # clear from previous messages\r\n \r\n lines = message.split(\"\\n\")\r\n font = pygame.font.Font(None, 25)\r\n dy = 20\r\n for i, line in enumerate(lines):\r\n txt_surf = font.render(line, False, gu.WHITE)\r\n new_rect = txt_surf.get_rect().move(0, i*dy)\r\n surface.blit(txt_surf, new_rect)\r\n \r\n self.screen.blit(surface, rect)\r\n self.wait()\r\n pygame.display.update()","def print_alert(text):\n print \"\\n\\n\\n\\n\"\n print text\n print \"\\n\\n\\n\\n\"","def show_text(text, args):\n return expyriment.stimuli.TextLine(text,\n text_font=args[\"--text-font\"],\n text_size=args[\"--text-size\"],\n text_colour=args[\"stimuli_color\"],\n background_colour=args[\"bg_color\"])","def print_message(message):\n print(\"-------------------------\")\n print(message)","def __draw_message(self, message):\n x_offset = (curses.COLS - len(message)) // 2\n self.message_win.addstr(0, x_offset, message)","def message(msg, type_=None, status=None, line=None):\n print('{styp}{sdelimiter}{sstatus}{slineno}{scolon}{smgs}'.format(\\\n styp=type_ if type_ is not None else '',\n sdelimiter=' ' if status is not None and status > 0 and type_ is not None else '',\n sstatus=status if status is not None and status > 0 else '',\n scolon=': ' if type_ is not None or line is not None else '',\n smgs=msg,\n slineno=' (@{:04d})'.format(line) if line is not None else '')\n , file=sys.stderr)","def displayMessage(j, s):\n if j:\n j.DisplayMessage(\"info\", s.replace(\" \", \" \").replace(\"j.\", \"\", 1))\n print(\" \" + s)","def display(self, timing, message=None, msg_color=None, timing_color=None):\n if msg_color is None:\n msg_color = self.final_color\n if timing_color is None:\n timing_color = self.final_color\n\n num_cols = int(os.popen('stty size', 'r').read().split()[1])\n max_msg_len = num_cols - len(timing)\n\n if message is None:\n # No message; entire width available for timing string\n message = \"\"\n rwidth = num_cols\n elif len(message.expandtabs()) > max_msg_len:\n # Message too long and will be truncated to show timing string\n message = message[:max_msg_len]\n rwidth = len(timing)\n else:\n rwidth = num_cols - len(message.expandtabs())\n\n # Print and reposition the cursor\n print(\"{0}{1}{2}{3:>{4:d}s}{5}\".format(\n msg_color, message, timing_color,\n timing, rwidth, self.reset_color),\n end='\\r', file=self.stream)","def devMsg(self, text):\n # Preprocess text\n lines = text.splitlines()\n\n image = self.devMsgImage.copy()\n draw = ImageDraw.Draw(image)\n # Text\n x0 = 0\n y0 = -2\n for i in range(0,len(lines)):\n draw.text((x0, y0+i*7), lines[i], font=self.font, fill=255)\n self.disp.image(image.rotate(180))\n self.disp.display()\n return","def basic_die(size = (10000, 10000),\n street_width = 100,\n street_length = 1000,\n die_name = 'chip99',\n text_size = 100,\n text_location = 'SW',\n layer = 0,\n draw_bbox = True,\n bbox_layer = 99):\n D = Device(name = 'die')\n sx, sy = size[0]/2, size[1]/2\n xpts = np.array([sx, sx, sx-street_width, sx-street_width,\n sx-street_length, sx-street_length])\n ypts = np.array([sy, sy-street_length, sy-street_length,\n sy-street_width, sy-street_width, sy])\n D.add_polygon([xpts,ypts], layer = layer)\n D.add_polygon([-xpts,ypts], layer = layer)\n D.add_polygon([xpts,-ypts], layer = layer)\n D.add_polygon([-xpts,-ypts], layer = layer)\n\n if draw_bbox is True:\n D.add_polygon([[sx,sy], [sx,-sy], [-sx,-sy], [-sx,sy]],\n layer = bbox_layer)\n D.center = (0, 0)\n t = D.add_ref(text(text = die_name, size = text_size, layer = layer))\n\n d = street_width + 20\n if type(text_location) is str:\n text_location = text_location.upper()\n if text_location == 'NW':\n t.xmin, t.ymax = [-sx + d, sy - d]\n elif text_location == 'N':\n t.x, t.ymax = [0, sy - d]\n elif text_location == 'NE':\n t.xmax, t.ymax = [sx - d, sy - d]\n if text_location == 'SW':\n t.xmin, t.ymin = [-sx + d, -sy + d]\n elif text_location == 'S':\n t.x, t.ymin = [0, -sy + d]\n elif text_location == 'SE':\n t.xmax, t.ymin = [sx - d, -sy + d]\n else:\n t.x, t.y = text_location\n\n return D","def test(self,windowsize = False):\n\n # set up a specific window to test the text in\n if windowsize:\n self.screen = pygame.display.set_mode(windowsize)\n self.screen.fill((200,200,200))\n self.screen.blit(*self.blitinfo)\n\n # if no specific window is specified create a small one around the\n # outside of the text\n else:\n self.screen = pygame.display.set_mode((self.imagewidth + 20,self.imageheight + 20))\n self.screen.fill((200,200,200))\n self.screen.blit(self.image, (10,10))\n\n pygame.display.flip()\n while True:\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n pygame.quit()\n sys.exit()","def test(self,windowsize = False):\n\n # set up a specific window to test the text in\n if windowsize:\n self.screen = pygame.display.set_mode(windowsize)\n self.screen.fill((200,200,200))\n self.screen.blit(*self.blitinfo)\n\n # if no specific window is specified create a small one around the\n # outside of the text\n else:\n self.screen = pygame.display.set_mode((self.imagewidth + 20,self.imageheight + 20))\n self.screen.fill((200,200,200))\n self.screen.blit(self.image, (10,10))\n\n pygame.display.flip()\n while True:\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n pygame.quit()\n sys.exit()","def paintText(self, text):\n return '@paint '+text * 2","def message_box_data(msg,\n colour,\n y_displace=0,\n x_displace=0,\n size='small',\n side='center'):\n\ttext_surf, text_rect = text_object(msg, colour, size)\n\tif side == 'center':\n\t\ttext_rect.center = (display_width / 2) + x_displace, \\\n\t\t (display_height / 2) + y_displace\n\telif side == 'top':\n\t\ttext_rect.midtop = (display_width / 2) + x_displace, y_displace\n\telif side == 'bottom_left':\n\t\ttext_rect.bottomleft = (x_displace,\n\t\t display_height - y_displace)\n\telif side == 'bottom_right':\n\t\ttext_rect.bottomright = (display_width - x_displace,\n\t\t display_height - y_displace)\n\n\tanswer_dict = {'Top': text_rect.top, 'Bottom': text_rect.bottom, 'Left': text_rect.left,\n\t 'Right': text_rect.right, 'Center': text_rect.center}\n\treturn answer_dict","def display_message():","def print_text(self, text1, text2):","def make(size, *toppings):\r\n print(\"The size of the pizza is \"+ str(size))\r\n for topping in toppings:\r\n print('- '+ topping)","def make_pizza(size,*args):\n print(f\"\\nMaking a {size}-inch pizza with the following toppings:\")\n for arg in args:\n print(f\"+ {arg}\")","def set_style_size_options(f, description, variable_label, node_label):\n f.write(\" #description { font-size : \" + description + \"px; }\\n\")\n f.write(\" .domain_label { font-size : \" + variable_label + \"px; }\\n\")\n f.write(\" .sideLabels, .nodeLabel, .nodeName, .edgeLabels { font-size : \" + node_label + \"px; }\\n\")\n f.write(\"</style>\\n\")","def sendMessage(self, reportText):\n print reportText","def print_square(size):\n if type(size) is float and size < 0:\n raise TypeError(\"size must be an integer\")\n if not isinstance(size, int):\n raise TypeError(\"size must be an integer\")\n if size < 0:\n raise ValueError(\"size must be >= 0\")\n for rows in range(size):\n print('#' * size)","def popup(\n msg: str, screen: str = None, x: int = None, y: int = None, output: bool = True\n) -> str:\n\n box_size = {\"x\": 0, \"y\": 0}\n\n # Calculating the box size\n for line in msg.split(\"\\n\"):\n if len(line) > box_size[\"x\"]:\n box_size[\"x\"] = len(line)\n box_size[\"y\"] += 1\n\n margin = {\"x\": 3, \"y\": 2}\n # Building the popup (list of list)\n popup = []\n popup.append([\" \", \".\", \"-\"] + [\"-\"] * box_size[\"x\"] + [\"-\", \".\", \" \"])\n popup.append([\" \", \"|\", \" \"] + [\" \"] * box_size[\"x\"] + [\" \", \"|\", \" \"])\n\n for line in msg.split(\"\\n\"):\n popup.append(\n [\" \", \"|\", \" \"]\n + list(line)\n + [\" \"] * (box_size[\"x\"] - len(line))\n + [\" \", \"|\", \" \"]\n )\n\n popup.append([\" \", \"|\", \" \"] + [\" \"] * box_size[\"x\"] + [\" \", \"|\", \" \"])\n popup.append([\" \", \"'\", \"-\"] + [\"-\"] * box_size[\"x\"] + [\"-\", \"'\", \" \"])\n\n # If no screen was given, create a blank screen the size of the popup\n if screen is None:\n screen = [ [\" \"]*80 for _ in range(box_size[\"y\"] + margin[\"y\"]*2 + 2)]\n else:\n # Converting the msg into a list of list\n # and filling the rest of the line with white spaces\n screen = [\n list(line) + [\" \"] * (MAX_SCREEN_SIZE - len(line))\n for line in screen.split(\"\\n\")\n ]\n\n\n pos = {}\n pos[\"x\"] = x if x is not None else len(screen[0]) // 2\n pos[\"y\"] = y if y is not None else len(screen) // 2\n\n # Shifting the popup position if to far on the left or to high on the top\n min_x = (box_size[\"x\"] + margin[\"x\"]) // 2 + 1\n min_y = (box_size[\"y\"] + margin[\"y\"]) // 2 + 1\n\n pos[\"x\"] = pos[\"x\"] if pos[\"x\"] >= min_x else min_x\n pos[\"y\"] = pos[\"y\"] if pos[\"y\"] >= min_y else min_y\n\n # Start cursor cannot be lower than 0\n start = {}\n start[\"x\"] = pos[\"x\"] - (box_size[\"x\"] // 2) - margin[\"x\"]\n start[\"x\"] = 0 if start[\"x\"] < 0 else start[\"x\"]\n start[\"y\"] = pos[\"y\"] - (box_size[\"y\"] // 2) - margin[\"y\"]\n start[\"y\"] = 0 if start[\"y\"] < 0 else start[\"y\"]\n\n # End cursor position cannot be greater than the screen size\n end = {}\n end[\"x\"] = start[\"x\"] + box_size[\"x\"] + margin[\"x\"]*2\n if end[\"x\"] > len(screen[0]):\n end[\"x\"] = len(screen[0])\n\n end[\"y\"] = start[\"y\"] + box_size[\"y\"] + margin[\"y\"]*2\n if end[\"y\"] > len(screen):\n end[\"y\"] = len(screen) - margin[\"y\"]\n\n # Overlapping the popup onto the screen\n line = 0\n for idx in range(start[\"y\"], end[\"y\"]+1):\n # Cropping on the y axis if too long\n if line < len(popup):\n screen[idx][start[\"x\"]: end[\"x\"]] = popup[line]\n line += 1\n\n # Cropping the excess on the x axis. Max screen size is 80 char\n for line in range(len(screen)):\n screen[line] = screen[line][0:MAX_SCREEN_SIZE]\n\n if output:\n for line in screen:\n print(\"\".join(line))\n\n screenshot = \"\"\n for line in screen:\n screenshot += \"\".join(line) + \"\\n\"\n\n return screenshot","def setScreenText(text: str, x: int, y: int):\n pass","def print_size(self, print_size):\n\n self.container['print_size'] = print_size","def printmessage(text, amount=1):\n\n # Repeat for value of amount\n for _ in range(amount):\n # Print the text\n print(text)","def test_size_pretty_whitespace(self):\n assert smdba.basegate.BaseGate.size_pretty(size=str(0x400), no_whitespace=True) == \"1.00KB\"","def my_print(self, message, type, wrap = True):\n # create newline if was in progress but failed\n if self.in_progress and type == msg_types.ERROR:\n message = '\\n' + message\n if wrap == True:\n message = message + '\\n'\n if self.gui is None:\n if type == msg_types.ERROR or type == msg_types.WARNING:\n outstream = sys.stderr\n else:\n outstream = sys.stdout\n outstream.write(message)\n else:\n self.gui.add_message(message, type)","def makeText(colour, size, text, bgcolour, textSize=15):\n sx = int((len(text)+1)*textSize/2.5)\n size = (sx, size[1])\n image = pygame.Surface(size)\n image.fill(bgcolour)\n font = pygame.font.SysFont(None, textSize)\n txtSurface = font.render(text, False, colour, bgcolour)\n tx = (image.get_width() - txtSurface.get_width())/2\n image.blit(txtSurface, (tx, size[1]/2))\n image.convert()\n return image","def text(self, string, x, y, color, *, font_name=\"font5x8.bin\", size=1):\n # determine our effective width/height, taking rotation into account\n frame_width = self.width\n frame_height = self.height\n if self.rotation in (1, 3):\n frame_width, frame_height = frame_height, frame_width\n\n for chunk in string.split(\"\\n\"):\n if not self._font or self._font.font_name != font_name:\n # load the font!\n self._font = BitmapFont(font_name)\n width = self._font.font_width\n height = self._font.font_height\n for i, char in enumerate(chunk):\n char_x = x + (i * (width + 1)) * size\n if (\n char_x + (width * size) > 0\n and char_x < frame_width\n and y + (height * size) > 0\n and y < frame_height\n ):\n self._font.draw_char(char, char_x, y, self, color, size=size)\n y += height * size"],"string":"[\n \"def make_shirt(size, message):\\n print(\\\"I need a shirt, size \\\" + size + \\\", that says \\\" + message + \\\".\\\")\",\n \"def make_shirt(size, text):\\n print('You wanted the t-shirt to be in size: ' + size)\\n print('The message you wanted on the t-shirt: ' + text)\",\n \"def make_shirt(size, message):\\n print(\\\"My t-shirt is a size \\\" + size.upper() + \\\" and says, \\\" + message + \\\".\\\")\",\n \"def make_shirt(message=\\\"I love Python\\\", size=\\\"L\\\"):\\n print(\\\"A \\\" + size + \\\" t-shirt with the following message: \\\" + message)\",\n \"def make_shirt(size, message):\\n print(\\\"\\\\nI'm going to make a \\\" + size + \\\" t-shirt.\\\")\\n print('It will say, \\\"' + message + '\\\"')\",\n \"def make_shirt(size, message):\\n print(\\\"\\\\nI'm going to make a \\\" + size + \\\" t-shirt.\\\")\\n print('It will say, \\\"' + message + '\\\"')\",\n \"def make_shirt(size='L', message='Look Away'):\\n print(\\\"I need a shirt, size \\\" + size + \\\", that says \\\" + \\\"'\\\" + message + \\\"'.\\\")\",\n \"def make_shirt2(text, size='large'):\\n print(f\\\"\\\\nI'm going to make a {size} shirt that says {text}. \\\")\",\n \"def make_shirt1(size, text):\\n print(f\\\"\\\\nI'm going to make a {size} shirt that says {text}. \\\")\",\n \"def make_shirt(size=\\\"Large\\\", message=\\\"I Love Python\\\"):\\n print(\\\"\\\\nI am going to make a \\\" + size + \\\" T-shirt \\\")\\n print(\\\"It will say,\\\" + message)\",\n \"def make_shirt(text = 'I love Python', size = 'large'):\\n\\tprint(\\\"The size of the shirt is: \\\" + size.title() + \\\".\\\")\\n\\tprint(\\\"The text printed on the shirt is: \\\" + text.title() + '\\\\n')\",\n \"def make_shirt(size='large', message='I love Python!'):\\n print(\\\"\\\\nI'm going to make a \\\" + size + \\\" t-shirt.\\\")\\n print('It will say, \\\"' + message + '\\\"')\",\n \"def make_shirt(size='large', message='I love Python!'):\\n print(\\\"\\\\nI'm going to make a \\\" + size + \\\" t-shirt.\\\")\\n print('It will say, \\\"' + message + '\\\"')\",\n \"def make_shirt(size, text):\\n print(\\\"I'll be making a \\\" + size + \\\" shirt with '\\\" + text + \\\"' written on\\\"\\n + \\\" the front of it.\\\")\",\n \"def make_shirt(text='I love Python', size='large'):\\t\\n\\tprint(f\\\"\\\\nThe size of the shirt is {size} and the printed text reads: {text}.\\\")\",\n \"def make_shirt(size='large', text='I love Python'):\\n print(\\\"\\\\nThis t-shirt is size \\\" + size + \\\" and has the word(s): \\\" + text + \\\".\\\")\",\n \"def display_message(self, text, color, text_size, coordinates):\\n\\n if text_size == \\\"large\\\":\\n text_size = 100\\n elif text_size == \\\"normal\\\":\\n text_size = 60\\n \\n text_style = pygame.font.Font(\\\"etc/Roboto-Regular.ttf\\\", text_size)\\n text_surface, text_rect = self.text_objects(text, text_style, color)\\n text_rect.center = coordinates\\n self.game_display.blit(text_surface, text_rect)\\n pygame.display.update()\",\n \"def print_message(self, message, color):\\n\\n xpos = 20\\n ypos = self.height\\n\\n size = common.FONT_SIZE\\n\\n arcade.draw_text(\\n text=message,\\n start_x=xpos,\\n start_y=ypos,\\n anchor_x=\\\"left\\\",\\n anchor_y=\\\"top\\\",\\n width=size*len(message),\\n color=color,\\n font_size=size,\\n bold=True)\",\n \"def no_size_printer(self, data=None):\\n border = self.options.border\\n filler = self.options.filler\\n spacer = self.options.spacer\\n blocker = self.options.blocker\\n # catch a blank line\\n if data is None:\\n data = spacer * int((70/len(self.options.spacer)))\\n msg = \\\"{border}{0:{filler}^{size}}{border}\\\".format(\\n data[:76], size=70, border=border, filler=filler\\n )\\n if self.options.verbose:\\n print(msg)\\n # return msg\",\n \"def showText(self, context, text, size=1, color=colors.WHITE, conversion=True):\\n context.print(text, self.components, size, color=color, conversion=conversion)\",\n \"def print(self,text,position=None,size=None,color=mycolors.WHITE,font=None,conversion=True):\\n if conversion:\\n if not position: position=(0,0)\\n if not size: size=1\\n position=self.draw.plane.getToScreen(position,self.draw.window)\\n ux,uy=self.draw.plane.units\\n size=int(size*ux/50)\\n else:\\n if not position: position=(10,10)\\n if not size: size=20\\n self.window.print(text,position,size,color,font)\",\n \"def Print(self, s, color=(229, 153, 153, 255)):\\r\\n self.screen.blit(self.font.render(s, True, color), (5, self.textLine))\\r\\n self.textLine += 15\",\n \"def message_to_screen(msg,\\n colour,\\n y_displace=0,\\n x_displace=0,\\n size='small',\\n side='center'):\\n\\ttext_surf, text_rect = text_object(msg, colour, size)\\n\\tif side == 'center':\\n\\t\\ttext_rect.center = (display_width / 2) + x_displace, \\\\\\n\\t\\t (display_height / 2) + y_displace\\n\\telif side == 'top':\\n\\t\\ttext_rect.midtop = (display_width / 2) + x_displace, y_displace\\n\\telif side == 'bottom_left':\\n\\t\\ttext_rect.bottomleft = (x_displace,\\n\\t\\t display_height - y_displace)\\n\\telif side == 'bottom_right':\\n\\t\\ttext_rect.bottomright = (display_width - x_displace,\\n\\t\\t display_height - y_displace)\\n\\telif side == 'custom_center':\\n\\t\\ttext_rect.center = x_displace, y_displace\\n\\telif side == 'custom_top':\\n\\t\\ttext_rect.midtop = x_displace, y_displace\\n\\telif side == 'custom_bottom':\\n\\t\\ttext_rect.midbottom = x_displace, y_displace\\n\\telif side == 'custom_bot_left':\\n\\t\\ttext_rect.bottomleft = x_displace, y_displace\\n\\telif side == 'custom_bot_right':\\n\\t\\ttext_rect.bottomright = x_displace, y_displace\\n\\telif side == 'custom_mid_right':\\n\\t\\ttext_rect.midright = x_displace, y_displace\\n\\telif side == 'custom_mid_left':\\n\\t\\ttext_rect.midleft = x_displace, y_displace\\n\\telse:\\n\\t\\ttext_rect.center = (display_width / 2) + x_displace, \\\\\\n\\t\\t (display_height / 2) + y_displace\\n\\tDisplay.blit(text_surf, text_rect)\",\n \"def message_display(text, loc, size, color=None):\\n # gameDisplay = pygame.display.set_mode((width, height))\\n largeText = pygame.font.Font('freesansbold.ttf', size)\\n TextSurf, TextRect = text_objects(text, largeText, color)\\n TextRect.center = (loc[0], loc[1])\\n gameDisplay.blit(TextSurf, TextRect)\\n\\n pygame.display.update()\",\n \"def esprint(self,text,w=1,h=1):\\n self.dps.set(height=h,width=w)\\n self.dps.text(text)\",\n \"def message(self, text):\\n\\n if type(text) in (bytes, str):\\n T = text\\n else:\\n # list probably:\\n T = '\\\\n'.join(text)\\n print(('-'*60))\\n print(T)\\n print(('='*60))\",\n \"def message_to_screen(msg,\\n colour,\\n y_displace=0,\\n x_displace=0,\\n size='small',\\n side='center'):\\n\\ttext_surf, text_rect = text_object(msg, colour, size)\\n\\tif side == 'center':\\n\\t\\ttext_rect.center = (display_width / 2) + x_displace, \\\\\\n\\t\\t (display_height / 2) + y_displace\\n\\telif side == 'top':\\n\\t\\ttext_rect.midtop = (display_width / 2) + x_displace, y_displace\\n\\telif side == 'bottom_left':\\n\\t\\ttext_rect.bottomleft = (x_displace,\\n\\t\\t display_height - y_displace)\\n\\telif side == 'bottom_right':\\n\\t\\ttext_rect.bottomright = (display_width - x_displace,\\n\\t\\t display_height - y_displace)\\n\\tDisplay.blit(text_surf, text_rect)\",\n \"def print_text(TINY_FONT, x, y, text, color = white):\\n text_image = TINY_FONT.render(text, True, color)\\n gameDisplay.blit(text_image, (x,y))\",\n \"def show_text(text, colour):\\n message = font_style.render(text, True, colour)\\n dis.blit(message, [game_size_x/2, game_size_y/2])\",\n \"def print(self, my_screen, text_string):\\n text_bitmap = self.font.render(text_string, True, BLACK)\\n my_screen.blit(text_bitmap, [self.x_pos, self.y_pos])\\n self.y_pos += self.line_height\",\n \"def message(msg ,font_size, color , pos):\\n font_style = pygame.font.SysFont( \\\"Times New Roman\\\" , font_size)\\n mesg = font_style.render(msg, True, color)\\n dis.blit(mesg, pos)\\n pygame.display.update()\",\n \"def changeScreen(msg, color, offset_x, offset_y, size):\\n font = pygame.font.SysFont(\\\"headlinea\\\", size) # default font\\n text = font.render(msg, True, color) \\n text_rect = text.get_rect()\\n text_x = Screen.get_width() / 2 - text_rect.width / 2 + offset_x\\n text_y = Screen.get_height() / 2 - text_rect.height / 2 + offset_y \\n Screen.blit(text, [text_x, text_y])\",\n \"async def ascii(self, ctx, *, text):\\n text = text.replace(' ', '\\\\n')\\n \\n if not text:\\n await ctx.send(f\\\"{ctx.tick(False)} You need to specify the text you want to convert!\\\")\\n \\n _fig = figlet_format(text.replace(' ', '\\\\n'))\\n \\n if len(_fig) > 1300:\\n await ctx.send(f\\\"{ctx.tick(False)} That message is too long!\\\")\\n await ctx.send(f\\\"{ctx.tick(True)} Done!\\\")\\n await ctx.send(f\\\"```{_fig}```\\\")\",\n \"def write_text(size, text):\\n img = Image.new('RGB', size, (255, 255, 255))\\n draw = ImageDraw.Draw(img)\\n font = ImageFont.truetype('/Library/Fonts/Arial.ttf', size)\\n draw.text((10,10), text, (0, 0, 0), font=font)\\n return img\",\n \"def show_message_scrabble(self, player_name):\\n\\n interface_width = self.interface.GAME_WINDOW_WIDTH;\\n interface_height = self.interface.GAME_WINDOW_HEIGHT;\\n\\n title_text = \\\"Le joueur \\\" + player_name + \\\" a fait un scrabble !!!\\\";\\n subtitle_text = \\\"Il remporte 50 points bonus !\\\";\\n\\n self.message_scrabble.set_text_title(title_text);\\n self.message_scrabble.set_text_subtitle(subtitle_text);\\n self.message_scrabble.set_horizontal_alignment(Alignment.Center);\\n self.message_scrabble.set_text_title_size(40);\\n self.message_scrabble.set_text_subtitle_size(32);\\n self.message_scrabble.set_space_between_titles(20);\\n self.message_scrabble.set_color_title((0, 0, 0));\\n self.message_scrabble.set_color_subtitle((0, 0, 0));\\n self.message_scrabble.set_border_color((0, 0, 0));\\n self.message_scrabble.set_border_thickness(4);\\n\\n self.message_scrabble.set_pos((interface_width/2, 200));\\n\\n self.message_placed_word.add_queued_message(self.message_scrabble, 3);\",\n \"def message(msg, color):\\n mesg = font_style.render(msg, True, color)\\n dis.blit(mesg, [dis_width / 3, dis_height / 2])\",\n \"def add_text(\\n self,\\n text: str,\\n size: Size = Size.Medium,\\n ) -> None: # noqa: E501\\n if not isinstance(size, Size):\\n size = Size(size)\\n\\n if size == Size.Small:\\n self._client.add_element(element=Text(text, style=\\\"bodySmall\\\"))\\n elif size == Size.Medium:\\n self._client.add_element(element=Text(text, style=\\\"bodyMedium\\\"))\\n elif size == Size.Large:\\n self._client.add_element(element=Text(text, style=\\\"bodyLarge\\\"))\",\n \"def draw_text(\\n self, text: str, size: int, color: Tuple[int, int, int], x: int, y: int\\n ) -> None:\\n # TODO: Select and use a better font\\n font = pg.font.Font(pg.font.get_default_font(), size)\\n text_surface = font.render(text, True, color)\\n text_rect = text_surface.get_rect()\\n text_rect.midtop = (x, y)\\n self.screen.blit(text_surface, text_rect)\",\n \"async def printtext(self, ctx: discord.ext.commands.Context, *args):\\n message_channel: discord.abc.Messageable = ctx.message.channel\\n if len(args) == 1:\\n received_string = args[0]\\n if received_string.startswith('\\\"') and received_string.endswith('\\\"'):\\n received_string = received_string[1:-1]\\n pos = received_string.find(\\\"\\\\\\\\\\\")\\n if pos != -1 and received_string[pos + 1] != \\\" \\\":\\n print(\\\"Error:\\\" + received_string[pos + 1])\\n return\\n pos = received_string.find(\\\"\\\\\\\"\\\")\\n if pos != -1:\\n print(\\\"Error:\\\" + received_string[pos + 1])\\n return\\n final_string = \\\"\\\"\\n number_emoji = self.botVariables.numbers_emoji\\n for c in received_string:\\n if c.isalnum():\\n try:\\n val = int(c)\\n if val < 10:\\n final_string += number_emoji[val] + \\\" \\\"\\n else:\\n print(\\\"fatal Error!!!-\\\" + str(val))\\n except ValueError:\\n c = c.lower()\\n if c == \\\"è\\\" or c == \\\"é\\\" or c == \\\"à\\\" or c == \\\"ù\\\" or c == \\\"ì\\\":\\n final_string += c + \\\" \\\"\\n else:\\n final_string += \\\":regional_indicator_\\\" + c + \\\":\\\" + \\\" \\\"\\n else:\\n if c == \\\"!\\\" or c == \\\"?\\\" or c == \\\"#\\\":\\n if c == \\\"!\\\":\\n final_string += \\\":exclamation:\\\" + \\\" \\\"\\n else:\\n if c == \\\"#\\\":\\n final_string += \\\":hash:\\\" + \\\" \\\"\\n else:\\n final_string += \\\":question:\\\" + \\\" \\\"\\n else:\\n final_string += c + \\\" \\\"\\n await message_channel.send(final_string)\\n else:\\n await message_channel.send(\\n \\\"**Usage:** \\\" + self.command_prefix + \\\"printtext \\\\\\\"phrase\\\\\\\", for more see \\\"\\n + self.command_prefix + \\\"help printtext\\\")\",\n \"def print_message_nicely(message):\\n print (\\\"\\\\n\\\\r\\\" + \\\"*\\\"*10 + \\\"\\\\n\\\" +\\n \\\"\\\\rsender: \\\" + message[\\\"handle\\\"] + \\\"\\\\n\\\" +\\n \\\"\\\\rmessage: \\\" + message[\\\"text\\\"] + \\\"\\\\n\\\\r\\\" +\\n \\\"*\\\"*10 + \\\"\\\\n\\\")\",\n \"def print_square(size):\\n if not isinstance(size, int):\\n raise TypeError(\\\"size must be an integer\\\")\\n if (size < 0):\\n raise ValueError(\\\"size must be >= 0\\\")\\n if size > 0:\\n print(\\\"\\\\n\\\".join([\\\"#\\\" * size for j in range(size)]))\",\n \"def text(self, str: str, x: int, y: int, colour: int, /) -> None:\",\n \"def showText(self, surface, point, text, color=None, size=20):\\n if not color: color = self.color\\n v = self / 2\\n point = v(point)\\n surface.print(text, tuple(point), color=color, size=size)\",\n \"def print_square(size):\\n int_err = \\\"size must be an integer\\\"\\n val_err = \\\"size must be >= 0\\\"\\n float_err = \\\"size must be an integer\\\"\\n\\n if not isinstance(size, int):\\n raise TypeError(int_err)\\n if size < 0:\\n raise TypeError(val_err)\\n if isinstance(size, float) and size < 0:\\n raise TypeError(float_err)\\n\\n for i in range(size):\\n print('#' * size)\",\n \"def print_space(self,text,width,w=1,h=1):\\n texlen = len(text)\\n if texlen > width:\\n text = text[:width]\\n self.lesprint(text,width)\",\n \"def print_message_center(self, message, color, size = common.FONT_SIZE):\\n\\n xpos = self.width / 2\\n ypos = self.height / 2\\n\\n arcade.draw_text(\\n text=message,\\n start_x=xpos,\\n start_y=ypos,\\n anchor_x=\\\"center\\\",\\n anchor_y=\\\"center\\\",\\n align=\\\"center\\\",\\n width=size*len(message),\\n color=color,\\n font_size=size,\\n bold=True)\",\n \"def size_pretty(size: typing.Union[str, int, float], int_only: bool = False, no_whitespace: bool = False) -> str:\\n\\n _size = float(size)\\n wsp = \\\"\\\" if no_whitespace else \\\" \\\"\\n wrap: typing.Callable[[float], typing.Union[int, float]] = lambda arg: arg if not int_only else int(round(arg))\\n sz_ptn = '%.d' if int_only else '%.2f'\\n\\n if _size >= 0x10000000000:\\n msg = (sz_ptn + '%sTB') % (wrap((_size / 0x10000000000)), wsp)\\n elif _size >= 0x40000000:\\n msg = (sz_ptn + '%sGB') % (wrap((_size / 0x40000000)), wsp)\\n elif _size >= 0x100000:\\n msg = (sz_ptn + '%sMB') % (wrap((_size / 0x100000)), wsp)\\n elif _size >= 0x400:\\n msg = (sz_ptn + '%sKB') % (wrap((_size / 0x400)), wsp)\\n else:\\n msg = ((int_only and '%s' or '%.f') + '%sBytes') % (wrap(_size), wsp)\\n return msg\",\n \"def take_easy():\\r\\n length = int(input())\\r\\n message = input()\\r\\n if length >= len(message):\\r\\n print(\\\"||||||\\\" + \\\"%.5s\\\" %message + \\\"||||||\\\")\\r\\n else:\\r\\n print(\\\" -----\\\")\\r\\n print(\\\"-|-|-|-|-|-----\\\" + \\\"%.4s\\\" %message + \\\")))\\\")\\r\\n print(\\\" -----\\\")\",\n \"def draw_string(message, x, y, textSize):\\r\\n global _canvas\\r\\n global _current_color\\r\\n if _canvas == None:\\r\\n raise RuntimeError(\\\"Canvas is not open yet.\\\")\\r\\n else:\\r\\n t = Text(message, textSize)\\r\\n t.move(x, y)\\r\\n t.setFontColor(_current_color)\\r\\n _canvas.add(t)\",\n \"def Print(self, text):\\n pass\",\n \"def _render_text(self, message, font=None):\\n # Default to small font if not provided.\\n if font is None:\\n font = self._small_font\\n return font.render(message, True, self._fgcolor, self._bgcolor)\",\n \"def print_message(slogan_to_print):\\r\\n\\r\\n print(\\\"Your\\\", slogan_to_print, \\\"here!\\\")\",\n \"def display_s(s, font, screen, lcd, size=5, x=0, y=0):\\n i = 0\\n spacing = size * .11\\n s = str(s)\\n char = s[0]\\n char_w, char_h = font[char].size\\n for c in s:\\n display_c(c,font,screen,lcd,size,(int(i*spacing*char_w)+x),y)\\n i += 1\\n return screen\",\n \"def showMessage(self, text, location, font, fontSize, colour=(255,255,255),\\n input=False, secs=None):\\n self.fill()\\n self.text(text, location, font, fontSize, colour=colour)\\n pygame.display.update()\\n if input:\\n currentEvent = self.input.input()\\n while not self.input.checkInput(currentEvent):\\n currentEvent = self.input.input()\\n if not secs:\\n self.timer.wait(secs)\",\n \"def create_preview(message):\",\n \"def _render_text_wrap(self, message, rect, font=None):\\n # Default to small font if not provided.\\n if font is None:\\n font = self._small_font\\n return self._render_textrect( message, font, rect, self._fgcolor, self._bgcolor)\",\n \"def updateSizeBody(self, size): \\n self.avatarConfiguration[\\\"bodySize\\\"] = size\\n self.paintBody()\\n self.paintShoes()\\n if self.avatarConfiguration[\\\"gender\\\"] == \\\"boy\\\":\\n self.paintShirt()\\n self.paintTrousers()\\n else:\\n self.paintSkirt()\",\n \"def on_size(self, event):\\r\\n event.Skip()\\r\\n self.text_info.Label = conf.InfoText\\r\\n wx.CallAfter(lambda: self and\\r\\n (self.text_info.Wrap(self.mediactrl.Size.width),\\r\\n self.text_info.Parent.Layout()))\",\n \"def show_on_screen(self, string, location, font='Arial', font_size=20, colour=WHITE):\\n msg = pygame.font.SysFont(font, font_size).render(str(string), True, colour)\\n self.screen.blit(msg, location)\",\n \"def show_theme_message(width):\\n print_dotted_line()\\n print_bold(\\\"Attack of The Orcs v0.0.5:\\\")\\n msg = (\\n \\\"\\\"\\\"\\n Hrabri vitez Talion vraća se iz boja i želi predahnuti u jednom seocetu. \\n U seocu se nalazi 5 kućica i želi stupiti u jednu od njih. \\n Hrabri vitez ne zna da u ovom području ima neprijatelja.\\n Odluči se za jedna od vrata ...\\n \\\"\\\"\\\")\\n\\n print(textwrap.fill(msg, width=width))\",\n \"def size_string(raw_text, size=MAX_DISPLAY_SIZE):\\n if raw_text and len(raw_text) >= size:\\n large_str = (\\n f\\\"\\\\nFile contents truncated because file size is larger than maximum viewing size of {nice_size(size)}\\\\n\\\"\\n )\\n raw_text = f\\\"{raw_text[0:size]}{large_str}\\\"\\n return raw_text or \\\"\\\"\",\n \"def print(self, text, dpi):\\r\\n lines = self.__buildlines(text)\\r\\n return self.page(lines, dpi)\",\n \"def send_size_event() -> None:\\n terminal_size = self._get_terminal_size()\\n width, height = terminal_size\\n textual_size = Size(width, height)\\n event = events.Resize(textual_size, textual_size)\\n asyncio.run_coroutine_threadsafe(\\n self._app._post_message(event),\\n loop=loop,\\n )\",\n \"def display_message(self, message):\\n text = self.font.render(message, True,\\n self.display_states[self.display_names[self.current_display_state]]['text'])\\n temp_width = text.get_rect().width\\n self.gameDisplay.blit(text, ((self.SCREEN_WIDTH / 2) - (temp_width/2), 100))\",\n \"def print_substep(text, style=\\\"\\\"):\\n console.print(text, style=style)\",\n \"def print_banner(text):\\n print(Figlet(font='smslant').renderText(text))\",\n \"def Print(self, message):\\n self.script.append('ui_print(\\\"%s\\\");' % (message,))\",\n \"def reprint() -> 'html':\\n size = request.form['name']\\n store(size)\\n if size == '0':\\n \\\"\\\"\\\"Empty database send back to previous page\\\"\\\"\\\"\\n return previous()\\n else:\\n \\\"\\\"\\\"Selected file redirect to print details\\\"\\\"\\\"\\n store(size)\\n return pr(size,'From database')\",\n \"def text(self, string,\\n location,\\n font, fontSize,\\n antialias=False,\\n colour=(0,0,0),\\n newlinePad=5,\\n screen=None):\\n if not screen:\\n screen = self.screen\\n x = location[0]\\n y = location[1]\\n font = pygame.font.Font(font, fontSize)\\n lines = string.split(\\\"\\\\n\\\")\\n counter = 0\\n height = 0\\n for line in lines:\\n fontSurface = font.render(line, antialias, colour).convert()\\n if counter == 0:\\n screen.blit(fontSurface, location)\\n else:\\n newY = y * counter + newlinePad + height\\n screen.blit(fontSurface, (x, newY))\\n height = font.size(line)[1] + height + newlinePad\\n counter += 1\",\n \"def boxTextFor(player, text = \\\"\\\"):\\n pass_text = \\\"\\\"\\n if isinstance( text, ( str, unicode ) ):\\n pass_text = text\\n return boxTextAt( pass_text, default_display_vars.borderChar_Left, default_display_vars.borderChar_Right, default_display_vars.boxText_padding, getUserScreenWidth( player ) )\",\n \"def create_image_with_string(s, size, color, fontsize=10):\\n from PIL import Image\\n # from PIL import ImageFont\\n from PIL import ImageDraw\\n img = Image.new(\\\"RGB\\\", size, \\\"white\\\")\\n\\n draw = ImageDraw.Draw(img)\\n# font = ImageFont.truetype('FreeMono', 10)\\n options = [\\n '/usr/local/texlive/2015/texmf-dist/fonts/truetype/public/gnu-freefont/FreeMono.ttf',\\n '/usr/share/fonts/truetype/freefont/FreeMono.ttf']\\n font = None\\n for f in options:\\n if os.path.exists(f):\\n font = ImageFont.truetype(f, fontsize)\\n break\\n else:\\n logger.info('Could not find any font in %r' % options)\\n \\n draw.text((0, 0), s, color, font=font)\\n data = get_png(img)\\n return data\",\n \"def showMessage(self, message, surface=None, bg_color=None, rect=None):\\r\\n if surface is None:\\r\\n surface = self.infoPanel \\r\\n if bg_color is None:\\r\\n bg_color = gu.INFO_PANEL_COLOR\\r\\n if rect is None:\\r\\n rect = gu.INFO_RECT\\r\\n \\r\\n surface.fill(bg_color) # clear from previous messages\\r\\n \\r\\n lines = message.split(\\\"\\\\n\\\")\\r\\n font = pygame.font.Font(None, 25)\\r\\n dy = 20\\r\\n for i, line in enumerate(lines):\\r\\n txt_surf = font.render(line, False, gu.WHITE)\\r\\n new_rect = txt_surf.get_rect().move(0, i*dy)\\r\\n surface.blit(txt_surf, new_rect)\\r\\n \\r\\n self.screen.blit(surface, rect)\\r\\n self.wait()\\r\\n pygame.display.update()\",\n \"def print_alert(text):\\n print \\\"\\\\n\\\\n\\\\n\\\\n\\\"\\n print text\\n print \\\"\\\\n\\\\n\\\\n\\\\n\\\"\",\n \"def show_text(text, args):\\n return expyriment.stimuli.TextLine(text,\\n text_font=args[\\\"--text-font\\\"],\\n text_size=args[\\\"--text-size\\\"],\\n text_colour=args[\\\"stimuli_color\\\"],\\n background_colour=args[\\\"bg_color\\\"])\",\n \"def print_message(message):\\n print(\\\"-------------------------\\\")\\n print(message)\",\n \"def __draw_message(self, message):\\n x_offset = (curses.COLS - len(message)) // 2\\n self.message_win.addstr(0, x_offset, message)\",\n \"def message(msg, type_=None, status=None, line=None):\\n print('{styp}{sdelimiter}{sstatus}{slineno}{scolon}{smgs}'.format(\\\\\\n styp=type_ if type_ is not None else '',\\n sdelimiter=' ' if status is not None and status > 0 and type_ is not None else '',\\n sstatus=status if status is not None and status > 0 else '',\\n scolon=': ' if type_ is not None or line is not None else '',\\n smgs=msg,\\n slineno=' (@{:04d})'.format(line) if line is not None else '')\\n , file=sys.stderr)\",\n \"def displayMessage(j, s):\\n if j:\\n j.DisplayMessage(\\\"info\\\", s.replace(\\\" \\\", \\\" \\\").replace(\\\"j.\\\", \\\"\\\", 1))\\n print(\\\" \\\" + s)\",\n \"def display(self, timing, message=None, msg_color=None, timing_color=None):\\n if msg_color is None:\\n msg_color = self.final_color\\n if timing_color is None:\\n timing_color = self.final_color\\n\\n num_cols = int(os.popen('stty size', 'r').read().split()[1])\\n max_msg_len = num_cols - len(timing)\\n\\n if message is None:\\n # No message; entire width available for timing string\\n message = \\\"\\\"\\n rwidth = num_cols\\n elif len(message.expandtabs()) > max_msg_len:\\n # Message too long and will be truncated to show timing string\\n message = message[:max_msg_len]\\n rwidth = len(timing)\\n else:\\n rwidth = num_cols - len(message.expandtabs())\\n\\n # Print and reposition the cursor\\n print(\\\"{0}{1}{2}{3:>{4:d}s}{5}\\\".format(\\n msg_color, message, timing_color,\\n timing, rwidth, self.reset_color),\\n end='\\\\r', file=self.stream)\",\n \"def devMsg(self, text):\\n # Preprocess text\\n lines = text.splitlines()\\n\\n image = self.devMsgImage.copy()\\n draw = ImageDraw.Draw(image)\\n # Text\\n x0 = 0\\n y0 = -2\\n for i in range(0,len(lines)):\\n draw.text((x0, y0+i*7), lines[i], font=self.font, fill=255)\\n self.disp.image(image.rotate(180))\\n self.disp.display()\\n return\",\n \"def basic_die(size = (10000, 10000),\\n street_width = 100,\\n street_length = 1000,\\n die_name = 'chip99',\\n text_size = 100,\\n text_location = 'SW',\\n layer = 0,\\n draw_bbox = True,\\n bbox_layer = 99):\\n D = Device(name = 'die')\\n sx, sy = size[0]/2, size[1]/2\\n xpts = np.array([sx, sx, sx-street_width, sx-street_width,\\n sx-street_length, sx-street_length])\\n ypts = np.array([sy, sy-street_length, sy-street_length,\\n sy-street_width, sy-street_width, sy])\\n D.add_polygon([xpts,ypts], layer = layer)\\n D.add_polygon([-xpts,ypts], layer = layer)\\n D.add_polygon([xpts,-ypts], layer = layer)\\n D.add_polygon([-xpts,-ypts], layer = layer)\\n\\n if draw_bbox is True:\\n D.add_polygon([[sx,sy], [sx,-sy], [-sx,-sy], [-sx,sy]],\\n layer = bbox_layer)\\n D.center = (0, 0)\\n t = D.add_ref(text(text = die_name, size = text_size, layer = layer))\\n\\n d = street_width + 20\\n if type(text_location) is str:\\n text_location = text_location.upper()\\n if text_location == 'NW':\\n t.xmin, t.ymax = [-sx + d, sy - d]\\n elif text_location == 'N':\\n t.x, t.ymax = [0, sy - d]\\n elif text_location == 'NE':\\n t.xmax, t.ymax = [sx - d, sy - d]\\n if text_location == 'SW':\\n t.xmin, t.ymin = [-sx + d, -sy + d]\\n elif text_location == 'S':\\n t.x, t.ymin = [0, -sy + d]\\n elif text_location == 'SE':\\n t.xmax, t.ymin = [sx - d, -sy + d]\\n else:\\n t.x, t.y = text_location\\n\\n return D\",\n \"def test(self,windowsize = False):\\n\\n # set up a specific window to test the text in\\n if windowsize:\\n self.screen = pygame.display.set_mode(windowsize)\\n self.screen.fill((200,200,200))\\n self.screen.blit(*self.blitinfo)\\n\\n # if no specific window is specified create a small one around the\\n # outside of the text\\n else:\\n self.screen = pygame.display.set_mode((self.imagewidth + 20,self.imageheight + 20))\\n self.screen.fill((200,200,200))\\n self.screen.blit(self.image, (10,10))\\n\\n pygame.display.flip()\\n while True:\\n for event in pygame.event.get():\\n if event.type == pygame.QUIT:\\n pygame.quit()\\n sys.exit()\",\n \"def test(self,windowsize = False):\\n\\n # set up a specific window to test the text in\\n if windowsize:\\n self.screen = pygame.display.set_mode(windowsize)\\n self.screen.fill((200,200,200))\\n self.screen.blit(*self.blitinfo)\\n\\n # if no specific window is specified create a small one around the\\n # outside of the text\\n else:\\n self.screen = pygame.display.set_mode((self.imagewidth + 20,self.imageheight + 20))\\n self.screen.fill((200,200,200))\\n self.screen.blit(self.image, (10,10))\\n\\n pygame.display.flip()\\n while True:\\n for event in pygame.event.get():\\n if event.type == pygame.QUIT:\\n pygame.quit()\\n sys.exit()\",\n \"def paintText(self, text):\\n return '@paint '+text * 2\",\n \"def message_box_data(msg,\\n colour,\\n y_displace=0,\\n x_displace=0,\\n size='small',\\n side='center'):\\n\\ttext_surf, text_rect = text_object(msg, colour, size)\\n\\tif side == 'center':\\n\\t\\ttext_rect.center = (display_width / 2) + x_displace, \\\\\\n\\t\\t (display_height / 2) + y_displace\\n\\telif side == 'top':\\n\\t\\ttext_rect.midtop = (display_width / 2) + x_displace, y_displace\\n\\telif side == 'bottom_left':\\n\\t\\ttext_rect.bottomleft = (x_displace,\\n\\t\\t display_height - y_displace)\\n\\telif side == 'bottom_right':\\n\\t\\ttext_rect.bottomright = (display_width - x_displace,\\n\\t\\t display_height - y_displace)\\n\\n\\tanswer_dict = {'Top': text_rect.top, 'Bottom': text_rect.bottom, 'Left': text_rect.left,\\n\\t 'Right': text_rect.right, 'Center': text_rect.center}\\n\\treturn answer_dict\",\n \"def display_message():\",\n \"def print_text(self, text1, text2):\",\n \"def make(size, *toppings):\\r\\n print(\\\"The size of the pizza is \\\"+ str(size))\\r\\n for topping in toppings:\\r\\n print('- '+ topping)\",\n \"def make_pizza(size,*args):\\n print(f\\\"\\\\nMaking a {size}-inch pizza with the following toppings:\\\")\\n for arg in args:\\n print(f\\\"+ {arg}\\\")\",\n \"def set_style_size_options(f, description, variable_label, node_label):\\n f.write(\\\" #description { font-size : \\\" + description + \\\"px; }\\\\n\\\")\\n f.write(\\\" .domain_label { font-size : \\\" + variable_label + \\\"px; }\\\\n\\\")\\n f.write(\\\" .sideLabels, .nodeLabel, .nodeName, .edgeLabels { font-size : \\\" + node_label + \\\"px; }\\\\n\\\")\\n f.write(\\\"</style>\\\\n\\\")\",\n \"def sendMessage(self, reportText):\\n print reportText\",\n \"def print_square(size):\\n if type(size) is float and size < 0:\\n raise TypeError(\\\"size must be an integer\\\")\\n if not isinstance(size, int):\\n raise TypeError(\\\"size must be an integer\\\")\\n if size < 0:\\n raise ValueError(\\\"size must be >= 0\\\")\\n for rows in range(size):\\n print('#' * size)\",\n \"def popup(\\n msg: str, screen: str = None, x: int = None, y: int = None, output: bool = True\\n) -> str:\\n\\n box_size = {\\\"x\\\": 0, \\\"y\\\": 0}\\n\\n # Calculating the box size\\n for line in msg.split(\\\"\\\\n\\\"):\\n if len(line) > box_size[\\\"x\\\"]:\\n box_size[\\\"x\\\"] = len(line)\\n box_size[\\\"y\\\"] += 1\\n\\n margin = {\\\"x\\\": 3, \\\"y\\\": 2}\\n # Building the popup (list of list)\\n popup = []\\n popup.append([\\\" \\\", \\\".\\\", \\\"-\\\"] + [\\\"-\\\"] * box_size[\\\"x\\\"] + [\\\"-\\\", \\\".\\\", \\\" \\\"])\\n popup.append([\\\" \\\", \\\"|\\\", \\\" \\\"] + [\\\" \\\"] * box_size[\\\"x\\\"] + [\\\" \\\", \\\"|\\\", \\\" \\\"])\\n\\n for line in msg.split(\\\"\\\\n\\\"):\\n popup.append(\\n [\\\" \\\", \\\"|\\\", \\\" \\\"]\\n + list(line)\\n + [\\\" \\\"] * (box_size[\\\"x\\\"] - len(line))\\n + [\\\" \\\", \\\"|\\\", \\\" \\\"]\\n )\\n\\n popup.append([\\\" \\\", \\\"|\\\", \\\" \\\"] + [\\\" \\\"] * box_size[\\\"x\\\"] + [\\\" \\\", \\\"|\\\", \\\" \\\"])\\n popup.append([\\\" \\\", \\\"'\\\", \\\"-\\\"] + [\\\"-\\\"] * box_size[\\\"x\\\"] + [\\\"-\\\", \\\"'\\\", \\\" \\\"])\\n\\n # If no screen was given, create a blank screen the size of the popup\\n if screen is None:\\n screen = [ [\\\" \\\"]*80 for _ in range(box_size[\\\"y\\\"] + margin[\\\"y\\\"]*2 + 2)]\\n else:\\n # Converting the msg into a list of list\\n # and filling the rest of the line with white spaces\\n screen = [\\n list(line) + [\\\" \\\"] * (MAX_SCREEN_SIZE - len(line))\\n for line in screen.split(\\\"\\\\n\\\")\\n ]\\n\\n\\n pos = {}\\n pos[\\\"x\\\"] = x if x is not None else len(screen[0]) // 2\\n pos[\\\"y\\\"] = y if y is not None else len(screen) // 2\\n\\n # Shifting the popup position if to far on the left or to high on the top\\n min_x = (box_size[\\\"x\\\"] + margin[\\\"x\\\"]) // 2 + 1\\n min_y = (box_size[\\\"y\\\"] + margin[\\\"y\\\"]) // 2 + 1\\n\\n pos[\\\"x\\\"] = pos[\\\"x\\\"] if pos[\\\"x\\\"] >= min_x else min_x\\n pos[\\\"y\\\"] = pos[\\\"y\\\"] if pos[\\\"y\\\"] >= min_y else min_y\\n\\n # Start cursor cannot be lower than 0\\n start = {}\\n start[\\\"x\\\"] = pos[\\\"x\\\"] - (box_size[\\\"x\\\"] // 2) - margin[\\\"x\\\"]\\n start[\\\"x\\\"] = 0 if start[\\\"x\\\"] < 0 else start[\\\"x\\\"]\\n start[\\\"y\\\"] = pos[\\\"y\\\"] - (box_size[\\\"y\\\"] // 2) - margin[\\\"y\\\"]\\n start[\\\"y\\\"] = 0 if start[\\\"y\\\"] < 0 else start[\\\"y\\\"]\\n\\n # End cursor position cannot be greater than the screen size\\n end = {}\\n end[\\\"x\\\"] = start[\\\"x\\\"] + box_size[\\\"x\\\"] + margin[\\\"x\\\"]*2\\n if end[\\\"x\\\"] > len(screen[0]):\\n end[\\\"x\\\"] = len(screen[0])\\n\\n end[\\\"y\\\"] = start[\\\"y\\\"] + box_size[\\\"y\\\"] + margin[\\\"y\\\"]*2\\n if end[\\\"y\\\"] > len(screen):\\n end[\\\"y\\\"] = len(screen) - margin[\\\"y\\\"]\\n\\n # Overlapping the popup onto the screen\\n line = 0\\n for idx in range(start[\\\"y\\\"], end[\\\"y\\\"]+1):\\n # Cropping on the y axis if too long\\n if line < len(popup):\\n screen[idx][start[\\\"x\\\"]: end[\\\"x\\\"]] = popup[line]\\n line += 1\\n\\n # Cropping the excess on the x axis. Max screen size is 80 char\\n for line in range(len(screen)):\\n screen[line] = screen[line][0:MAX_SCREEN_SIZE]\\n\\n if output:\\n for line in screen:\\n print(\\\"\\\".join(line))\\n\\n screenshot = \\\"\\\"\\n for line in screen:\\n screenshot += \\\"\\\".join(line) + \\\"\\\\n\\\"\\n\\n return screenshot\",\n \"def setScreenText(text: str, x: int, y: int):\\n pass\",\n \"def print_size(self, print_size):\\n\\n self.container['print_size'] = print_size\",\n \"def printmessage(text, amount=1):\\n\\n # Repeat for value of amount\\n for _ in range(amount):\\n # Print the text\\n print(text)\",\n \"def test_size_pretty_whitespace(self):\\n assert smdba.basegate.BaseGate.size_pretty(size=str(0x400), no_whitespace=True) == \\\"1.00KB\\\"\",\n \"def my_print(self, message, type, wrap = True):\\n # create newline if was in progress but failed\\n if self.in_progress and type == msg_types.ERROR:\\n message = '\\\\n' + message\\n if wrap == True:\\n message = message + '\\\\n'\\n if self.gui is None:\\n if type == msg_types.ERROR or type == msg_types.WARNING:\\n outstream = sys.stderr\\n else:\\n outstream = sys.stdout\\n outstream.write(message)\\n else:\\n self.gui.add_message(message, type)\",\n \"def makeText(colour, size, text, bgcolour, textSize=15):\\n sx = int((len(text)+1)*textSize/2.5)\\n size = (sx, size[1])\\n image = pygame.Surface(size)\\n image.fill(bgcolour)\\n font = pygame.font.SysFont(None, textSize)\\n txtSurface = font.render(text, False, colour, bgcolour)\\n tx = (image.get_width() - txtSurface.get_width())/2\\n image.blit(txtSurface, (tx, size[1]/2))\\n image.convert()\\n return image\",\n \"def text(self, string, x, y, color, *, font_name=\\\"font5x8.bin\\\", size=1):\\n # determine our effective width/height, taking rotation into account\\n frame_width = self.width\\n frame_height = self.height\\n if self.rotation in (1, 3):\\n frame_width, frame_height = frame_height, frame_width\\n\\n for chunk in string.split(\\\"\\\\n\\\"):\\n if not self._font or self._font.font_name != font_name:\\n # load the font!\\n self._font = BitmapFont(font_name)\\n width = self._font.font_width\\n height = self._font.font_height\\n for i, char in enumerate(chunk):\\n char_x = x + (i * (width + 1)) * size\\n if (\\n char_x + (width * size) > 0\\n and char_x < frame_width\\n and y + (height * size) > 0\\n and y < frame_height\\n ):\\n self._font.draw_char(char, char_x, y, self, color, size=size)\\n y += height * size\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7987473","0.7964641","0.7890728","0.7831767","0.7787454","0.7787454","0.7602366","0.7577227","0.75480956","0.7529585","0.73977256","0.7383219","0.7383219","0.7379657","0.73002464","0.71007955","0.6245159","0.61845994","0.5964087","0.59391963","0.58867604","0.58830225","0.5813801","0.5811241","0.57973003","0.57193106","0.5711807","0.56517863","0.5543751","0.5539895","0.55328196","0.5509563","0.5503612","0.5476406","0.54732436","0.54496086","0.5393806","0.53916144","0.537173","0.53623265","0.53616583","0.5360635","0.5336316","0.53178823","0.53108895","0.5297355","0.52857333","0.5279086","0.5274971","0.5269014","0.52641183","0.5263809","0.5251919","0.52315533","0.520789","0.5200704","0.5186938","0.5186718","0.5181537","0.5171284","0.5160495","0.5147249","0.5145932","0.51399404","0.5132602","0.51293355","0.51290876","0.5123897","0.5123434","0.5116372","0.5110011","0.5098361","0.50951624","0.5092068","0.5083177","0.5075332","0.5073185","0.5062435","0.50601125","0.5058223","0.50552344","0.5051624","0.5051624","0.5048547","0.5037653","0.50371206","0.50348234","0.5033602","0.50300515","0.50177556","0.50163895","0.50094056","0.5005609","0.50050163","0.50025994","0.49914566","0.49913058","0.49795663","0.49775118","0.49734557"],"string":"[\n \"0.7987473\",\n \"0.7964641\",\n \"0.7890728\",\n \"0.7831767\",\n \"0.7787454\",\n \"0.7787454\",\n \"0.7602366\",\n \"0.7577227\",\n \"0.75480956\",\n \"0.7529585\",\n \"0.73977256\",\n \"0.7383219\",\n \"0.7383219\",\n \"0.7379657\",\n \"0.73002464\",\n \"0.71007955\",\n \"0.6245159\",\n \"0.61845994\",\n \"0.5964087\",\n \"0.59391963\",\n \"0.58867604\",\n \"0.58830225\",\n \"0.5813801\",\n \"0.5811241\",\n \"0.57973003\",\n \"0.57193106\",\n \"0.5711807\",\n \"0.56517863\",\n \"0.5543751\",\n \"0.5539895\",\n \"0.55328196\",\n \"0.5509563\",\n \"0.5503612\",\n \"0.5476406\",\n \"0.54732436\",\n \"0.54496086\",\n \"0.5393806\",\n \"0.53916144\",\n \"0.537173\",\n \"0.53623265\",\n \"0.53616583\",\n \"0.5360635\",\n \"0.5336316\",\n \"0.53178823\",\n \"0.53108895\",\n \"0.5297355\",\n \"0.52857333\",\n \"0.5279086\",\n \"0.5274971\",\n \"0.5269014\",\n \"0.52641183\",\n \"0.5263809\",\n \"0.5251919\",\n \"0.52315533\",\n \"0.520789\",\n \"0.5200704\",\n \"0.5186938\",\n \"0.5186718\",\n \"0.5181537\",\n \"0.5171284\",\n \"0.5160495\",\n \"0.5147249\",\n \"0.5145932\",\n \"0.51399404\",\n \"0.5132602\",\n \"0.51293355\",\n \"0.51290876\",\n \"0.5123897\",\n \"0.5123434\",\n \"0.5116372\",\n \"0.5110011\",\n \"0.5098361\",\n \"0.50951624\",\n \"0.5092068\",\n \"0.5083177\",\n \"0.5075332\",\n \"0.5073185\",\n \"0.5062435\",\n \"0.50601125\",\n \"0.5058223\",\n \"0.50552344\",\n \"0.5051624\",\n \"0.5051624\",\n \"0.5048547\",\n \"0.5037653\",\n \"0.50371206\",\n \"0.50348234\",\n \"0.5033602\",\n \"0.50300515\",\n \"0.50177556\",\n \"0.50163895\",\n \"0.50094056\",\n \"0.5005609\",\n \"0.50050163\",\n \"0.50025994\",\n \"0.49914566\",\n \"0.49913058\",\n \"0.49795663\",\n \"0.49775118\",\n \"0.49734557\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76433444"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":83171,"cells":{"query":{"kind":"string","value":"Accepts a size and text of a message to print on a shirt. Defaults to size large."},"document":{"kind":"string","value":"def make_shirt(text='I love Python', size='large'):\t\n\tprint(f\"\\nThe size of the shirt is {size} and the printed text reads: {text}.\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def make_shirt(size, message):\n print(\"I need a shirt, size \" + size + \", that says \" + message + \".\")","def make_shirt(message=\"I love Python\", size=\"L\"):\n print(\"A \" + size + \" t-shirt with the following message: \" + message)","def make_shirt(size, message):\n print(\"My t-shirt is a size \" + size.upper() + \" and says, \" + message + \".\")","def make_shirt(size, text):\n print('You wanted the t-shirt to be in size: ' + size)\n print('The message you wanted on the t-shirt: ' + text)","def make_shirt(size, message):\n print(\"\\nI'm going to make a \" + size + \" t-shirt.\")\n print('It will say, \"' + message + '\"')","def make_shirt(size, message):\n print(\"\\nI'm going to make a \" + size + \" t-shirt.\")\n print('It will say, \"' + message + '\"')","def make_shirt(size='L', message='Look Away'):\n print(\"I need a shirt, size \" + size + \", that says \" + \"'\" + message + \"'.\")","def make_shirt(size=\"Large\", message=\"I Love Python\"):\n print(\"\\nI am going to make a \" + size + \" T-shirt \")\n print(\"It will say,\" + message)","def make_shirt2(text, size='large'):\n print(f\"\\nI'm going to make a {size} shirt that says {text}. \")","def make_shirt(size='large', message='I love Python!'):\n print(\"\\nI'm going to make a \" + size + \" t-shirt.\")\n print('It will say, \"' + message + '\"')","def make_shirt(size='large', message='I love Python!'):\n print(\"\\nI'm going to make a \" + size + \" t-shirt.\")\n print('It will say, \"' + message + '\"')","def make_shirt(size, text):\n\tprint(f\"\\nThe size of the shirt is {size} and the printed text reads: {text}.\")","def make_shirt(text = 'I love Python', size = 'large'):\n\tprint(\"The size of the shirt is: \" + size.title() + \".\")\n\tprint(\"The text printed on the shirt is: \" + text.title() + '\\n')","def make_shirt1(size, text):\n print(f\"\\nI'm going to make a {size} shirt that says {text}. \")","def make_shirt(size, text):\n print(\"I'll be making a \" + size + \" shirt with '\" + text + \"' written on\"\n + \" the front of it.\")","def make_shirt(size='large', text='I love Python'):\n print(\"\\nThis t-shirt is size \" + size + \" and has the word(s): \" + text + \".\")","def no_size_printer(self, data=None):\n border = self.options.border\n filler = self.options.filler\n spacer = self.options.spacer\n blocker = self.options.blocker\n # catch a blank line\n if data is None:\n data = spacer * int((70/len(self.options.spacer)))\n msg = \"{border}{0:{filler}^{size}}{border}\".format(\n data[:76], size=70, border=border, filler=filler\n )\n if self.options.verbose:\n print(msg)\n # return msg","def size_pretty(size: typing.Union[str, int, float], int_only: bool = False, no_whitespace: bool = False) -> str:\n\n _size = float(size)\n wsp = \"\" if no_whitespace else \" \"\n wrap: typing.Callable[[float], typing.Union[int, float]] = lambda arg: arg if not int_only else int(round(arg))\n sz_ptn = '%.d' if int_only else '%.2f'\n\n if _size >= 0x10000000000:\n msg = (sz_ptn + '%sTB') % (wrap((_size / 0x10000000000)), wsp)\n elif _size >= 0x40000000:\n msg = (sz_ptn + '%sGB') % (wrap((_size / 0x40000000)), wsp)\n elif _size >= 0x100000:\n msg = (sz_ptn + '%sMB') % (wrap((_size / 0x100000)), wsp)\n elif _size >= 0x400:\n msg = (sz_ptn + '%sKB') % (wrap((_size / 0x400)), wsp)\n else:\n msg = ((int_only and '%s' or '%.f') + '%sBytes') % (wrap(_size), wsp)\n return msg","def display_message(self, text, color, text_size, coordinates):\n\n if text_size == \"large\":\n text_size = 100\n elif text_size == \"normal\":\n text_size = 60\n \n text_style = pygame.font.Font(\"etc/Roboto-Regular.ttf\", text_size)\n text_surface, text_rect = self.text_objects(text, text_style, color)\n text_rect.center = coordinates\n self.game_display.blit(text_surface, text_rect)\n pygame.display.update()","def size_string(raw_text, size=MAX_DISPLAY_SIZE):\n if raw_text and len(raw_text) >= size:\n large_str = (\n f\"\\nFile contents truncated because file size is larger than maximum viewing size of {nice_size(size)}\\n\"\n )\n raw_text = f\"{raw_text[0:size]}{large_str}\"\n return raw_text or \"\"","def pretty_size(size):\n assert (isinstance(size, torch.Size))\n return \" × \".join(map(str, size))","def print_size(self, print_size):\n\n self.container['print_size'] = print_size","def pretty_size(size):\n assert(isinstance(size, torch.Size))\n return \" × \".join(map(str, size))","def set_style_size_options(f, description, variable_label, node_label):\n f.write(\" #description { font-size : \" + description + \"px; }\\n\")\n f.write(\" .domain_label { font-size : \" + variable_label + \"px; }\\n\")\n f.write(\" .sideLabels, .nodeLabel, .nodeName, .edgeLabels { font-size : \" + node_label + \"px; }\\n\")\n f.write(\"</style>\\n\")","def get_printable_size(self):\n size = self.size\n prefix = ''\n for (s, l) in [(1024*1024*1024, 'GB'), (1024*1024, 'MB'), (1024, 'KB')]:\n if (size>s):\n size = float(size)/s\n prefix = l\n\n return '%10.2f %s' % (size, prefix)","def test_size_pretty_whitespace(self):\n assert smdba.basegate.BaseGate.size_pretty(size=str(0x400), no_whitespace=True) == \"1.00KB\"","def print_square(size):\n if not isinstance(size, int):\n raise TypeError(\"size must be an integer\")\n if (size < 0):\n raise ValueError(\"size must be >= 0\")\n if size > 0:\n print(\"\\n\".join([\"#\" * size for j in range(size)]))","def send_size_event() -> None:\n terminal_size = self._get_terminal_size()\n width, height = terminal_size\n textual_size = Size(width, height)\n event = events.Resize(textual_size, textual_size)\n asyncio.run_coroutine_threadsafe(\n self._app._post_message(event),\n loop=loop,\n )","def sizeFormat(size):\n import math\n if opt.human:\n sizeUnit = ['B', 'K', 'M', 'G']\n try:\n length = float(size)\n scale = int(math.log(length) / math.log(1024))\n length = \"%.0f%s\" % (length / (1024.0 ** scale), sizeUnit[scale])\n except:\n length = str(size)\n else:\n length = str(int(size))\n return \"%12s \" % (length)","def set_font_size(*args):\n size = font_size.get()\n message_inp.configure(font=f'TKDefault {size}')","def print_square(size):\n int_err = \"size must be an integer\"\n val_err = \"size must be >= 0\"\n float_err = \"size must be an integer\"\n\n if not isinstance(size, int):\n raise TypeError(int_err)\n if size < 0:\n raise TypeError(val_err)\n if isinstance(size, float) and size < 0:\n raise TypeError(float_err)\n\n for i in range(size):\n print('#' * size)","def add_text(\n self,\n text: str,\n size: Size = Size.Medium,\n ) -> None: # noqa: E501\n if not isinstance(size, Size):\n size = Size(size)\n\n if size == Size.Small:\n self._client.add_element(element=Text(text, style=\"bodySmall\"))\n elif size == Size.Medium:\n self._client.add_element(element=Text(text, style=\"bodyMedium\"))\n elif size == Size.Large:\n self._client.add_element(element=Text(text, style=\"bodyLarge\"))","def set_size(self, value='S'):\n upper = value.upper()\n\n if upper == 'M': # Medium: double height\n # size = 0x01\n # charHeight = 48\n # maxColumn = 32\n self.double_height_on()\n self.double_width_off()\n elif upper == 'L': # Large: double width and height\n # size = 0x11\n # charHeight = 48\n # maxColumn = 16\n self.double_height_on()\n self.double_width_on()\n else: # Small: standard width and height\n # size = 0x00\n # charHeight = 24\n # maxColumn = 32\n self.double_width_off()\n self.double_height_off()\n # writeBytes(ASCII_GS, '!', size)\n # prevByte = '\\n' # Setting the size adds a linefeed","def format_size(size):\n size_mb = float(size)/1048576\n size_str = '%10.2f MiB' % size_mb\n if size_mb > 1024:\n size_gb = size_mb/1024\n size_str = '%10.2f GiB' % size_gb\n else:\n return size_str.strip()\n if size_gb > 1024:\n size_tb = size_gb/1024\n size_str = '%10.2f TiB' % size_tb\n return size_str.strip()","def bb_size(hit):\n \n size = hit.group(1)\n text = hit.group(2)\n \n minimum = getattr(settings, 'BBCODE_MINIMUM', 6)\n maximum = getattr(settings, 'BBCODE_MAXIMUM', 50)\n \n # Size needs to be controlled, and may vary depending on the CSS on the site. We don't want\n # Users requesting a size too small to be visible, or too large and take up the whole screen!\n # This could eventually go into the settings.py file, hehe.\n if(int(size) < minimum):\n return '<font style=\"font-size: %dpx\">%s [Too Small, Upscaled To 6]</font>' % (minimum, text)\n\n if(int(size) > maximum):\n return '<font style=\"font-size: %dpx\">%s [Too Large, Reduced To 50]</font>' % (maximum, text)\n\n # Return the normal text size\n return '<font style=\"font-size: %dpx\">%s</font>' % (int(size), text)","def updateSizeBody(self, size): \n self.avatarConfiguration[\"bodySize\"] = size\n self.paintBody()\n self.paintShoes()\n if self.avatarConfiguration[\"gender\"] == \"boy\":\n self.paintShirt()\n self.paintTrousers()\n else:\n self.paintSkirt()","def print_message(self, message, color):\n\n xpos = 20\n ypos = self.height\n\n size = common.FONT_SIZE\n\n arcade.draw_text(\n text=message,\n start_x=xpos,\n start_y=ypos,\n anchor_x=\"left\",\n anchor_y=\"top\",\n width=size*len(message),\n color=color,\n font_size=size,\n bold=True)","def on_size(self, event):\r\n event.Skip()\r\n self.text_info.Label = conf.InfoText\r\n wx.CallAfter(lambda: self and\r\n (self.text_info.Wrap(self.mediactrl.Size.width),\r\n self.text_info.Parent.Layout()))","def limit_size(msg, max_size, trunc_symbol=\"...\"):\n if len(msg) > max_size:\n msg = msg[:max_size - len(trunc_symbol)] + trunc_symbol\n return msg","def validate_size(size):\n if not size.lower().endswith(('kb', 'mb', 'gb', 'tb'\n )) or not size[:-2].isdigit():\n msg = ('Invalid format for size. \\n'\n 'Valid sizes must be of form X[kKmMgGtT]b where X is an'\n 'integer. Default = 100mb')\n raise ValidationError(msg)","def write_get_message_size(s, spec, search_path):\n\n with Indent(s):\n s.write('static getMessageSize(object) {')\n msg_size = get_message_fixed_size(spec, search_path)\n if msg_size is not None:\n with Indent(s):\n s.write('return {};'.format(msg_size))\n else:\n def get_dynamic_field_length_line(field, query):\n if field.is_builtin:\n if not is_string(field.base_type):\n raise Exception('Unexpected field {} with type {} has unknown length'.format(field.name, field.base_type))\n # it's a string array!\n return 'length += 4 + {}.length;'.format(query)\n # else\n (package, msg_type) = field.base_type.split('/')\n samePackage = spec.package == package\n if samePackage:\n return 'length += {}.getMessageSize({});'.format(msg_type, query)\n else:\n return 'length += {}.msg.{}.getMessageSize({});'.format(package, msg_type, query)\n\n with Indent(s):\n s.write('let length = 0;')\n # certain fields will always have the same size\n # calculate that here instead of dynamically every time\n len_constant_length_fields = 0;\n for f in spec.parsed_fields():\n field_size = None\n if f.is_builtin:\n field_size = get_type_size(f.base_type)\n else:\n field_msg_context = MsgContext.create_default()\n field_spec = genmsg.msg_loader.load_msg_by_type(field_msg_context, f.base_type, search_path)\n field_size = get_message_fixed_size(field_spec, search_path)\n\n if f.is_array:\n if f.array_len and field_size is not None:\n len_constant_length_fields += (field_size * f.array_len)\n continue\n elif not f.array_len:\n len_constant_length_fields += 4\n\n if field_size == 1:\n s.write('length += object.{}.length;'.format(f.name))\n elif field_size is not None:\n s.write('length += {} * object.{}.length;'.format(field_size, f.name))\n else:\n if f.is_builtin:\n if not is_string(f.base_type):\n raise Exception('Unexpected field {} with type {} has unknown length'.format(f.name, f.base_type))\n # it's a string array!\n line_to_write = 'length += 4 + _getByteLength(val);'\n else:\n (package, msg_type) = f.base_type.split('/')\n samePackage = spec.package == package\n if samePackage:\n line_to_write = 'length += {}.getMessageSize(val);'.format(msg_type,)\n else:\n line_to_write = 'length += {}.msg.{}.getMessageSize(val);'.format(package, msg_type)\n s.write('object.{}.forEach((val) => {{'.format(f.name))\n with Indent(s):\n s.write(line_to_write)\n s.write('});')\n elif field_size is not None:\n len_constant_length_fields += field_size\n else:\n # field size is dynamic!\n if f.is_builtin:\n if not is_string(f.base_type):\n raise Exception('Unexpected field {} with type {} has unknown length'.format(f.name, f.base_type))\n # it's a string array!\n len_constant_length_fields += 4\n line_to_write = 'length += _getByteLength(object.{});'.format(f.name)\n else:\n (package, msg_type) = f.base_type.split('/')\n samePackage = spec.package == package\n if samePackage:\n line_to_write = 'length += {}.getMessageSize(object.{});'.format(msg_type, f.name)\n else:\n line_to_write = 'length += {}.msg.{}.getMessageSize(object.{});'.format(package, msg_type, f.name)\n s.write(line_to_write)\n\n if len_constant_length_fields > 0:\n s.write('return length + {};'.format(len_constant_length_fields))\n else:\n s.write('return length;')\n s.write('}')\n s.newline()","def __print_size_warning(ow, oh, w, h):\n if not hasattr(__print_size_warning, 'has_printed'):\n logging.warning(\n f\"The loaded image size was ({ow}, {oh}), so it was adjusted to ({w}, {h}).This adjustment will be done to all label2ImagePaths\")\n __print_size_warning.has_printed = True","def test_size_pretty_intonly(self):\n assert smdba.basegate.BaseGate.size_pretty(size=str(0x19000000000), int_only=True) == \"2 TB\"\n assert smdba.basegate.BaseGate.size_pretty(size=str(0x19000000000), int_only=False) == \"1.56 TB\"","def setSize(size):\n turtleTmp.penSize(max(1, min(size, 100)))","def size(self, size_input: Tuple[str, str]):\n self.isize = [UIMetric.parse(size_input[0]),\n UIMetric.parse(size_input[1])]","def message_display(text, loc, size, color=None):\n # gameDisplay = pygame.display.set_mode((width, height))\n largeText = pygame.font.Font('freesansbold.ttf', size)\n TextSurf, TextRect = text_objects(text, largeText, color)\n TextRect.center = (loc[0], loc[1])\n gameDisplay.blit(TextSurf, TextRect)\n\n pygame.display.update()","def pretty_print_file_size(size: float) -> str:\n for x in [\"bytes\", \"KB\", \"MB\", \"GB\", \"TB\"]:\n if size < 1024.0:\n return f\"{size:3.1f} {x}\"\n size /= 1024.0\n return str(size)","def size(self,*args):\n if len(args) == 2:\n x,y = map(int,args)\n else:\n x,y = map(int,args[0])\n self.check_size(x,y)\n self.data['chs'] = '%dx%d'%(x,y)","def _prettifySize(self, size) -> str:\n iteration = 0\n while size >= 1024:\n size /= 1024\n iteration += 1\n size = f'{size:.2f}'.rstrip('0').rstrip('.').rjust(6) # 6 is maximal number of digits of any input\n return f'{size} {self._SIZES_SUFFIX[iteration]}'","def fontSize(size):\n\t\treturn int(-size * (InterfaceTools.getCanvasSize()[0] / height))","def __human_size(size, padding = True):\n # the spaces after the base unit 'B' are for alignment\n powers = { 0 : \"B \", 1 : \"KiB\", 2 : \"MiB\", 3 : \"GiB\", 4 : \"TiB\", 5 : \"PiB\", 6 : \"EiB\" }\n i = 0\n orig_size = size\n size = float(size)\n while size >= 1024:\n i += 1\n size /= 1024\n if i > 6:\n print(\"Not prepared to handle this number: {:d}\".format(orig_size))\n return \"NaN\"\n val = str(round(size, 1)) + ' ' + powers[i]\n if padding: val = \" \"*(MAX_SIZE-len(val)) + val\n return val","def print_square(size):\n if type(size) is float and size < 0:\n raise TypeError(\"size must be an integer\")\n if not isinstance(size, int):\n raise TypeError(\"size must be an integer\")\n if size < 0:\n raise ValueError(\"size must be >= 0\")\n for rows in range(size):\n print('#' * size)","def write_text(size, text):\n img = Image.new('RGB', size, (255, 255, 255))\n draw = ImageDraw.Draw(img)\n font = ImageFont.truetype('/Library/Fonts/Arial.ttf', size)\n draw.text((10,10), text, (0, 0, 0), font=font)\n return img","def showText(self, context, text, size=1, color=colors.WHITE, conversion=True):\n context.print(text, self.components, size, color=color, conversion=conversion)","def test_pretty_size(self):\n cases = [\n (0, '0 B'),\n (233, '233 B'),\n (1023, '1023 B'),\n (1024, '1 KB'),\n (1024 ** 2 - 1, '1 MB'),\n (12345678, '12 MB'),\n (1024 ** 3 + 100, '1 GB'),\n (1024 ** 4 + 1, '1 TB'),\n (1024 ** 5 * 2, '2048 TB'),\n ]\n\n for v, expected in cases:\n actual = utils.pretty_size(v)\n self.assertEqual(actual, expected)","def size(self, size):\n # type: (string_types) -> None\n\n if size is not None:\n if not isinstance(size, string_types):\n raise TypeError(\"Invalid type for `size`, type has to be `string_types`\")\n\n self._size = size","def printSize(sz, unit=1000):\n\n fmt10 = [\"%dB\", \"%dKiB\", \"%dMiB\", \"%dGiB\", \"%dTiB\", \"%dPiB\"]\n fmt2 = [\"%dB\", \"%dKB\", \"%dMB\", \"%dGB\", \"%dTB\", \"%dPB\"]\n fmt = fmt10 if unit == 1000 else fmt2\n i = 0\n while i < len(fmt):\n if sz < unit:\n break\n sz /= unit\n i += 1\n return fmt[i] % (sz)","def Print(self, s, color=(229, 153, 153, 255)):\r\n self.screen.blit(self.font.render(s, True, color), (5, self.textLine))\r\n self.textLine += 15","def readable_size(n: int) -> str:\n sizes = ['K', 'M', 'G']\n fmt = ''\n size = n\n for i, s in enumerate(sizes):\n nn = n / (1000 ** (i + 1))\n if nn >= 1:\n size = nn\n fmt = sizes[i]\n else:\n break\n return '%.2f%s' % (size, fmt)","def formatMemorySize(size):\n\n # ClassAds report memory in KB, so start with K\n suffixes = ['K', 'M', 'G', 'T', 'P']\n\n for i in range(len(suffixes)):\n if size/(10**(i*3)) < 1000:\n break\n\n size = size/float(10**(i*3))\n suffix = suffixes[i]\n\n return '{0:.1f} {1}'.format(size, suffix)","def human_size(size_bytes):\n if size_bytes == 1:\n # because I really hate unnecessary plurals\n return \"1 byte\"\n\n suffixes_table = [('bytes', 0), ('KB', 0), ('MB', 1), ('GB', 2), ('TB', 2), ('PB', 2)]\n\n num = float(0 if size_bytes is None else size_bytes)\n for suffix, precision in suffixes_table:\n if num < 1024.0:\n break\n num /= 1024.0\n\n if precision == 0:\n formatted_size = \"%d\" % num\n else:\n formatted_size = str(round(num, ndigits=precision))\n\n return \"%s %s\" % (formatted_size, suffix)","def esprint(self,text,w=1,h=1):\n self.dps.set(height=h,width=w)\n self.dps.text(text)","def __init__(self, size=None):\n if size is None:\n size = plt.rcParams[\"font.size\"]\n self.size = size","def _format_string(value, size):\n\n return '{:<{}}'.format(value, size)","def __size_restriction_incorrect_string_number(self):\n\n strTestName = 'String size lower than a number (incorrect)'\n RxCSObject = _RxCSobject()\n\n RxCSObject.paramAddMan('parameter1', 'String parameter')\n RxCSObject.paramType('parameter1', str)\n RxCSObject.paramSizHE('parameter1', 4, mul=2, add=3)\n\n RxCSObject.parameter1 = 'aaa'\n\n self.__parametersCheck_error(RxCSObject, SizeError, strTestName)","def textSize(self, height=1, width=1):\n if not(0 < height < 17) or type(height) is not int:\n raise ValueError('height must be a int between 1 and 16')\n if not(0 < width < 17) or type(width) is not int:\n raise ValueError('textWidth must be a int between 1 and 16')\n else:\n size = (width - 1) << 4 | (height - 1)\n self._write(self.__class__.__GS + '!' + chr(size))","def print(self,text,position=None,size=None,color=mycolors.WHITE,font=None,conversion=True):\n if conversion:\n if not position: position=(0,0)\n if not size: size=1\n position=self.draw.plane.getToScreen(position,self.draw.window)\n ux,uy=self.draw.plane.units\n size=int(size*ux/50)\n else:\n if not position: position=(10,10)\n if not size: size=20\n self.window.print(text,position,size,color,font)","def large_text(self):\n pass","def human_size(size_bytes):\n if (size_bytes == 1):\n # because I really hate unnecessary plurals\n return \"1 byte\"\n\n suffixes_table = [('bytes',0),('KB',0),('MB',1),('GB',2),('TB',2), ('PB',2)]\n\n num = float(size_bytes)\n for suffix, precision in suffixes_table:\n if (num < 1024.0):\n break\n num /= 1024.0\n\n if (precision == 0):\n formatted_size = \"%d\" % num\n else:\n formatted_size = str(round(num, ndigits=precision))\n\n return \"%s %s\" % (formatted_size, suffix)","def print_square(size):\n if type(size) is not int:\n raise TypeError(\"size must be an integer\")\n if size < 0:\n raise ValueError(\"size must be >= 0\")\n row = \"#\" * size\n for i in range(size):\n print(\"{}\".format(row))","def arbitrary_string(size=4, base_text=None):\n\n if (base_text is None) or (base_text == ''):\n base_text = 'test'\n\n if size <= 0:\n return ''\n\n extra = size % len(base_text)\n body = ''\n\n if extra == 0:\n body = base_text * size\n\n if extra == size:\n body = base_text[:size]\n\n if extra > 0 and extra < size:\n body = (size / len(base_text)) * base_text + base_text[:extra]\n\n return body","def size(self, width, height):\n self._p('[size] {} {}'.format(width, height))","def html_line(size):\n return '<hr noshade size=\"' + str(size) + '\">'","def pretty_size_print(num_bytes):\n if num_bytes is None:\n return\n\n KiB = 1024\n MiB = KiB * KiB\n GiB = KiB * MiB\n TiB = KiB * GiB\n PiB = KiB * TiB\n EiB = KiB * PiB\n ZiB = KiB * EiB\n YiB = KiB * ZiB\n\n if num_bytes > YiB:\n output = \"%.3g YB\" % (num_bytes / YiB)\n elif num_bytes > ZiB:\n output = \"%.3g ZB\" % (num_bytes / ZiB)\n elif num_bytes > EiB:\n output = \"%.3g EB\" % (num_bytes / EiB)\n elif num_bytes > PiB:\n output = \"%.3g PB\" % (num_bytes / PiB)\n elif num_bytes > TiB:\n output = \"%.3g TB\" % (num_bytes / TiB)\n elif num_bytes > GiB:\n output = \"%.3g GB\" % (num_bytes / GiB)\n elif num_bytes > MiB:\n output = \"%.3g MB\" % (num_bytes / MiB)\n elif num_bytes > KiB:\n output = \"%.3g KB\" % (num_bytes / KiB)\n else:\n output = \"%.3g Bytes\" % (num_bytes)\n\n return output","def format_size(size):\n suffixes = ['B', 'KB', 'MB', 'GB']\n i = 0\n while size >= 1024 and i < len(suffixes) - 1:\n size = size / 1024\n i += 1\n return f\"{size:.2f} {suffixes[i]}\"","def get_file_size_str(size):\n if size < 128: return f'{size}B' # only show bytes for really small < 0.1 KB sizes\n if size < (1024*1024): return f'{size/1024:.1f}KB'\n if size < (1024*1024*1024): return f'{size/(1024*1024):.1f}MB'\n return f'{size/(1024*1024):.2}GB'","def make_human_readable_size(size, decimals=2):\n for unit in [\"B\",\"KB\",\"MB\",\"GB\",\"TB\"]:\n if size < 1024.0:\n break\n size /= 1024.0\n return f\"{size:.{decimals}f} {unit}\"","def format_size(size):\n size = float(size)\n for unit in ['bit','Kibit','Mibit','Gibit']:\n if size < 1024.0:\n return \"{size:3.2f}{unit}\".format(size=size, unit=unit)\n size /= 1024.0\n return \"{size:.2f}{unit}\".format(size=size, unit='TiB')","def humanize_imperial_size(size): # noqa: D301, WPS342\n if not size:\n return None\n\n total_inches = round(size / 25.4)\n feet = int(total_inches / 12)\n inches = int(total_inches % 12)\n\n if feet > 10:\n # Round inches for long boats\n if inches == 1:\n inches = 0\n elif inches == 11:\n inches = 0\n feet += 1\n\n size = \"{0}'\".format(feet) if feet else ''\n if inches:\n return '{0} {1}\"'.format(size, inches).strip()\n return size","def make_pizza(size,*args):\n print(f\"\\nMaking a {size}-inch pizza with the following toppings:\")\n for arg in args:\n print(f\"+ {arg}\")","def test_size_pretty_round(self):\n for size, res in ((0x40, \"64 Bytes\"), (0xff, \"255 Bytes\"),\n (0x400, \"1.00 KB\"), (0x800, \"2.00 KB\"), (0x10000, \"64.00 KB\"),\n (0xffff, \"64.00 KB\"), (0xfffff, \"1024.00 KB\"),\n (0x100000, \"1.00 MB\"), (0x40000000, \"1.00 GB\"),\n (0x10000000000, \"1.00 TB\"), (0x19000000000, \"1.56 TB\")):\n assert smdba.basegate.BaseGate.size_pretty(size=str(size)) == res","def size(self, new_size):\n if type(new_size) is str:\n new_size = new_size.replace(\" \", \"\").upper()\n new_size = new_size.replace(\")\", \"\")\n new_size = new_size.replace(\"(\", \"\")\n new_size = new_size.replace(\",\", \".\")\n new_size = new_size.replace(\"B\", \"\").strip()\n target_unit = None\n multiplier = 1\n is_bytes = False\n try:\n float(new_size)\n target_unit = \"B\"\n is_bytes = True\n except Exception as e:\n pass\n\n if not is_bytes:\n multiplier *= 1024\n for unit in [\"K\", \"M\", \"G\", \"T\", \"P\", \"E\", \"Z\", \"Y\"]:\n if not target_unit and unit in new_size:\n target_unit = unit\n multiplier *= 1024\n # Reject double units\n elif target_unit and unit in new_size:\n target_unit = None\n break\n\n if target_unit:\n new_size = new_size.replace(target_unit, \"\").strip()\n try:\n self._size = int(float(new_size) * multiplier)\n except Exception as e:\n logger.error(f\"Failed to set a size from \\\"{new_size}\\\"\")\n logger.error(e)\n\n elif type(new_size) is int:\n self._size = new_size\n\n else:\n raise Exception(\"Wrong size type provided ({type(new_size)})\")\n\n if not self._size:\n logger.warn(f\"Failed to set a size from \\\"{new_size}\\\"\")","def h_size(size: int, units: list = None):\n if units is None:\n units = H_SIZE_ABBREVIATIONS\n return f'{size} {units[0]}' if size < 1024 else h_size(size >> 10, units[1:])","def size(name):","def test_small_message(self):\n message = \"few characters\"\n message_displayed = truncate_message(message, limit=50)\n\n self.assertLessEqual(len(message_displayed), 50)\n self.assertEqual(message_displayed, \"few characters\")","def bytes_for_humans(size, suffix=\"B\"):\n for prefix in BYTES_PREFIXES:\n if size < PREFIX_FACTOR_BYTES:\n if prefix == \"\":\n return \"{}{}\".format(size, suffix)\n return \"{:.2f}{}{}\".format(size, prefix, suffix)\n size /= PREFIX_FACTOR_BYTES\n return \"{:.2f}{}{}\".format(size, \"P\", suffix)","def message(self, text):\n\n if type(text) in (bytes, str):\n T = text\n else:\n # list probably:\n T = '\\n'.join(text)\n print(('-'*60))\n print(T)\n print(('='*60))","def human_readable(size):\n if size < 1024**2:\n hreadable = float(size)/1024.0\n return \"%.0fK\" % hreadable\n elif size < (1024**3):\n hreadable = float(size)/(1024**2)\n return \"%.1fM\" % round(hreadable, 1)\n else:\n hreadable = float(size)/(1024.0**3)\n return \"%.2fG\" % round(hreadable, 2)","def changeScreen(msg, color, offset_x, offset_y, size):\n font = pygame.font.SysFont(\"headlinea\", size) # default font\n text = font.render(msg, True, color) \n text_rect = text.get_rect()\n text_x = Screen.get_width() / 2 - text_rect.width / 2 + offset_x\n text_y = Screen.get_height() / 2 - text_rect.height / 2 + offset_y \n Screen.blit(text, [text_x, text_y])","def message(msg ,font_size, color , pos):\n font_style = pygame.font.SysFont( \"Times New Roman\" , font_size)\n mesg = font_style.render(msg, True, color)\n dis.blit(mesg, pos)\n pygame.display.update()","def sizeformat(size):\n for unit in ['bytes', 'KB', 'MB', 'GB', 'TB']:\n if size < 1024.0:\n if unit == \"bytes\":\n return \"%1.0f %s\" % (size, unit)\n else:\n return \"%3.1f %s\" % (size, unit)\n size /= 1024.0\n return \"%.1f PB\" % size","def human_readable(size, precision=1):\n suffixes = ['B', 'KB', 'MB', 'GB', 'TB']\n suffixIndex = 0\n while size > 1024 and suffixIndex < 4:\n suffixIndex += 1\n size = size / 1024.0\n return \"%.*f%s\" % (precision, size, suffixes[suffixIndex])","def format(self,size):\n if self.__units is None:\n # Human-readable\n return bcf_utils.format_file_size(size)\n elif self.__units == 'bytes':\n # Raw bytes\n return size\n else:\n return bcf_utils.format_file_size(size,units=self.__units)[0:-1]","def make(size, *toppings):\r\n print(\"The size of the pizza is \"+ str(size))\r\n for topping in toppings:\r\n print('- '+ topping)","def size_str(num):\n if num > 2 ** 30:\n return \"%0.2fGB\" % (num / 2 ** 30)\n elif num > 2 ** 20:\n return \"%0.2fMB\" % (num / 2 ** 20)\n elif num > 2 ** 10:\n return \"%0.2fkB\" % (num / 2 ** 10)\n else:\n return \"%d bytes\" % num","def SizeCheck():\n while True:\n try:\n curses.echo() # Enable echoing of characters\n stdscr.addstr(0, 0, \"Give a table square row/column size : \")\n stdscr.move(0, 38)\n size = stdscr.getstr(0, 38, 2)\n size = int(size)\n curses.noecho()\n if size < 2:\n raise ValueError\n return size\n except ValueError:\n stdscr.addstr(1, 0, \"That is not a valid choice\")","def get_std_size(size_text):\r\n std_size = None\r\n # Find the color in the full dictionary\r\n size_code = SIZE_FULL.get(size_text)\r\n if size_code is not None:\r\n std_size = SIZE_STANDARD[size_code]\r\n return std_size","def setBoxsize(length,width,height):\n return length,width,height","def _SizeStats(self, size_info=None):\n size_info = size_info or self._size_infos[0]\n describe.WriteLines(data_quality.DescribeSizeInfoCoverage(size_info),\n sys.stdout.write)","def humanize_metric_size(size):\n if not size:\n return None\n\n meters = '{0:.2f}'.format(size / 1000.0).rstrip('0').rstrip('.')\n return str(_('{meters} m')).format(meters=meters)"],"string":"[\n \"def make_shirt(size, message):\\n print(\\\"I need a shirt, size \\\" + size + \\\", that says \\\" + message + \\\".\\\")\",\n \"def make_shirt(message=\\\"I love Python\\\", size=\\\"L\\\"):\\n print(\\\"A \\\" + size + \\\" t-shirt with the following message: \\\" + message)\",\n \"def make_shirt(size, message):\\n print(\\\"My t-shirt is a size \\\" + size.upper() + \\\" and says, \\\" + message + \\\".\\\")\",\n \"def make_shirt(size, text):\\n print('You wanted the t-shirt to be in size: ' + size)\\n print('The message you wanted on the t-shirt: ' + text)\",\n \"def make_shirt(size, message):\\n print(\\\"\\\\nI'm going to make a \\\" + size + \\\" t-shirt.\\\")\\n print('It will say, \\\"' + message + '\\\"')\",\n \"def make_shirt(size, message):\\n print(\\\"\\\\nI'm going to make a \\\" + size + \\\" t-shirt.\\\")\\n print('It will say, \\\"' + message + '\\\"')\",\n \"def make_shirt(size='L', message='Look Away'):\\n print(\\\"I need a shirt, size \\\" + size + \\\", that says \\\" + \\\"'\\\" + message + \\\"'.\\\")\",\n \"def make_shirt(size=\\\"Large\\\", message=\\\"I Love Python\\\"):\\n print(\\\"\\\\nI am going to make a \\\" + size + \\\" T-shirt \\\")\\n print(\\\"It will say,\\\" + message)\",\n \"def make_shirt2(text, size='large'):\\n print(f\\\"\\\\nI'm going to make a {size} shirt that says {text}. \\\")\",\n \"def make_shirt(size='large', message='I love Python!'):\\n print(\\\"\\\\nI'm going to make a \\\" + size + \\\" t-shirt.\\\")\\n print('It will say, \\\"' + message + '\\\"')\",\n \"def make_shirt(size='large', message='I love Python!'):\\n print(\\\"\\\\nI'm going to make a \\\" + size + \\\" t-shirt.\\\")\\n print('It will say, \\\"' + message + '\\\"')\",\n \"def make_shirt(size, text):\\n\\tprint(f\\\"\\\\nThe size of the shirt is {size} and the printed text reads: {text}.\\\")\",\n \"def make_shirt(text = 'I love Python', size = 'large'):\\n\\tprint(\\\"The size of the shirt is: \\\" + size.title() + \\\".\\\")\\n\\tprint(\\\"The text printed on the shirt is: \\\" + text.title() + '\\\\n')\",\n \"def make_shirt1(size, text):\\n print(f\\\"\\\\nI'm going to make a {size} shirt that says {text}. \\\")\",\n \"def make_shirt(size, text):\\n print(\\\"I'll be making a \\\" + size + \\\" shirt with '\\\" + text + \\\"' written on\\\"\\n + \\\" the front of it.\\\")\",\n \"def make_shirt(size='large', text='I love Python'):\\n print(\\\"\\\\nThis t-shirt is size \\\" + size + \\\" and has the word(s): \\\" + text + \\\".\\\")\",\n \"def no_size_printer(self, data=None):\\n border = self.options.border\\n filler = self.options.filler\\n spacer = self.options.spacer\\n blocker = self.options.blocker\\n # catch a blank line\\n if data is None:\\n data = spacer * int((70/len(self.options.spacer)))\\n msg = \\\"{border}{0:{filler}^{size}}{border}\\\".format(\\n data[:76], size=70, border=border, filler=filler\\n )\\n if self.options.verbose:\\n print(msg)\\n # return msg\",\n \"def size_pretty(size: typing.Union[str, int, float], int_only: bool = False, no_whitespace: bool = False) -> str:\\n\\n _size = float(size)\\n wsp = \\\"\\\" if no_whitespace else \\\" \\\"\\n wrap: typing.Callable[[float], typing.Union[int, float]] = lambda arg: arg if not int_only else int(round(arg))\\n sz_ptn = '%.d' if int_only else '%.2f'\\n\\n if _size >= 0x10000000000:\\n msg = (sz_ptn + '%sTB') % (wrap((_size / 0x10000000000)), wsp)\\n elif _size >= 0x40000000:\\n msg = (sz_ptn + '%sGB') % (wrap((_size / 0x40000000)), wsp)\\n elif _size >= 0x100000:\\n msg = (sz_ptn + '%sMB') % (wrap((_size / 0x100000)), wsp)\\n elif _size >= 0x400:\\n msg = (sz_ptn + '%sKB') % (wrap((_size / 0x400)), wsp)\\n else:\\n msg = ((int_only and '%s' or '%.f') + '%sBytes') % (wrap(_size), wsp)\\n return msg\",\n \"def display_message(self, text, color, text_size, coordinates):\\n\\n if text_size == \\\"large\\\":\\n text_size = 100\\n elif text_size == \\\"normal\\\":\\n text_size = 60\\n \\n text_style = pygame.font.Font(\\\"etc/Roboto-Regular.ttf\\\", text_size)\\n text_surface, text_rect = self.text_objects(text, text_style, color)\\n text_rect.center = coordinates\\n self.game_display.blit(text_surface, text_rect)\\n pygame.display.update()\",\n \"def size_string(raw_text, size=MAX_DISPLAY_SIZE):\\n if raw_text and len(raw_text) >= size:\\n large_str = (\\n f\\\"\\\\nFile contents truncated because file size is larger than maximum viewing size of {nice_size(size)}\\\\n\\\"\\n )\\n raw_text = f\\\"{raw_text[0:size]}{large_str}\\\"\\n return raw_text or \\\"\\\"\",\n \"def pretty_size(size):\\n assert (isinstance(size, torch.Size))\\n return \\\" × \\\".join(map(str, size))\",\n \"def print_size(self, print_size):\\n\\n self.container['print_size'] = print_size\",\n \"def pretty_size(size):\\n assert(isinstance(size, torch.Size))\\n return \\\" × \\\".join(map(str, size))\",\n \"def set_style_size_options(f, description, variable_label, node_label):\\n f.write(\\\" #description { font-size : \\\" + description + \\\"px; }\\\\n\\\")\\n f.write(\\\" .domain_label { font-size : \\\" + variable_label + \\\"px; }\\\\n\\\")\\n f.write(\\\" .sideLabels, .nodeLabel, .nodeName, .edgeLabels { font-size : \\\" + node_label + \\\"px; }\\\\n\\\")\\n f.write(\\\"</style>\\\\n\\\")\",\n \"def get_printable_size(self):\\n size = self.size\\n prefix = ''\\n for (s, l) in [(1024*1024*1024, 'GB'), (1024*1024, 'MB'), (1024, 'KB')]:\\n if (size>s):\\n size = float(size)/s\\n prefix = l\\n\\n return '%10.2f %s' % (size, prefix)\",\n \"def test_size_pretty_whitespace(self):\\n assert smdba.basegate.BaseGate.size_pretty(size=str(0x400), no_whitespace=True) == \\\"1.00KB\\\"\",\n \"def print_square(size):\\n if not isinstance(size, int):\\n raise TypeError(\\\"size must be an integer\\\")\\n if (size < 0):\\n raise ValueError(\\\"size must be >= 0\\\")\\n if size > 0:\\n print(\\\"\\\\n\\\".join([\\\"#\\\" * size for j in range(size)]))\",\n \"def send_size_event() -> None:\\n terminal_size = self._get_terminal_size()\\n width, height = terminal_size\\n textual_size = Size(width, height)\\n event = events.Resize(textual_size, textual_size)\\n asyncio.run_coroutine_threadsafe(\\n self._app._post_message(event),\\n loop=loop,\\n )\",\n \"def sizeFormat(size):\\n import math\\n if opt.human:\\n sizeUnit = ['B', 'K', 'M', 'G']\\n try:\\n length = float(size)\\n scale = int(math.log(length) / math.log(1024))\\n length = \\\"%.0f%s\\\" % (length / (1024.0 ** scale), sizeUnit[scale])\\n except:\\n length = str(size)\\n else:\\n length = str(int(size))\\n return \\\"%12s \\\" % (length)\",\n \"def set_font_size(*args):\\n size = font_size.get()\\n message_inp.configure(font=f'TKDefault {size}')\",\n \"def print_square(size):\\n int_err = \\\"size must be an integer\\\"\\n val_err = \\\"size must be >= 0\\\"\\n float_err = \\\"size must be an integer\\\"\\n\\n if not isinstance(size, int):\\n raise TypeError(int_err)\\n if size < 0:\\n raise TypeError(val_err)\\n if isinstance(size, float) and size < 0:\\n raise TypeError(float_err)\\n\\n for i in range(size):\\n print('#' * size)\",\n \"def add_text(\\n self,\\n text: str,\\n size: Size = Size.Medium,\\n ) -> None: # noqa: E501\\n if not isinstance(size, Size):\\n size = Size(size)\\n\\n if size == Size.Small:\\n self._client.add_element(element=Text(text, style=\\\"bodySmall\\\"))\\n elif size == Size.Medium:\\n self._client.add_element(element=Text(text, style=\\\"bodyMedium\\\"))\\n elif size == Size.Large:\\n self._client.add_element(element=Text(text, style=\\\"bodyLarge\\\"))\",\n \"def set_size(self, value='S'):\\n upper = value.upper()\\n\\n if upper == 'M': # Medium: double height\\n # size = 0x01\\n # charHeight = 48\\n # maxColumn = 32\\n self.double_height_on()\\n self.double_width_off()\\n elif upper == 'L': # Large: double width and height\\n # size = 0x11\\n # charHeight = 48\\n # maxColumn = 16\\n self.double_height_on()\\n self.double_width_on()\\n else: # Small: standard width and height\\n # size = 0x00\\n # charHeight = 24\\n # maxColumn = 32\\n self.double_width_off()\\n self.double_height_off()\\n # writeBytes(ASCII_GS, '!', size)\\n # prevByte = '\\\\n' # Setting the size adds a linefeed\",\n \"def format_size(size):\\n size_mb = float(size)/1048576\\n size_str = '%10.2f MiB' % size_mb\\n if size_mb > 1024:\\n size_gb = size_mb/1024\\n size_str = '%10.2f GiB' % size_gb\\n else:\\n return size_str.strip()\\n if size_gb > 1024:\\n size_tb = size_gb/1024\\n size_str = '%10.2f TiB' % size_tb\\n return size_str.strip()\",\n \"def bb_size(hit):\\n \\n size = hit.group(1)\\n text = hit.group(2)\\n \\n minimum = getattr(settings, 'BBCODE_MINIMUM', 6)\\n maximum = getattr(settings, 'BBCODE_MAXIMUM', 50)\\n \\n # Size needs to be controlled, and may vary depending on the CSS on the site. We don't want\\n # Users requesting a size too small to be visible, or too large and take up the whole screen!\\n # This could eventually go into the settings.py file, hehe.\\n if(int(size) < minimum):\\n return '<font style=\\\"font-size: %dpx\\\">%s [Too Small, Upscaled To 6]</font>' % (minimum, text)\\n\\n if(int(size) > maximum):\\n return '<font style=\\\"font-size: %dpx\\\">%s [Too Large, Reduced To 50]</font>' % (maximum, text)\\n\\n # Return the normal text size\\n return '<font style=\\\"font-size: %dpx\\\">%s</font>' % (int(size), text)\",\n \"def updateSizeBody(self, size): \\n self.avatarConfiguration[\\\"bodySize\\\"] = size\\n self.paintBody()\\n self.paintShoes()\\n if self.avatarConfiguration[\\\"gender\\\"] == \\\"boy\\\":\\n self.paintShirt()\\n self.paintTrousers()\\n else:\\n self.paintSkirt()\",\n \"def print_message(self, message, color):\\n\\n xpos = 20\\n ypos = self.height\\n\\n size = common.FONT_SIZE\\n\\n arcade.draw_text(\\n text=message,\\n start_x=xpos,\\n start_y=ypos,\\n anchor_x=\\\"left\\\",\\n anchor_y=\\\"top\\\",\\n width=size*len(message),\\n color=color,\\n font_size=size,\\n bold=True)\",\n \"def on_size(self, event):\\r\\n event.Skip()\\r\\n self.text_info.Label = conf.InfoText\\r\\n wx.CallAfter(lambda: self and\\r\\n (self.text_info.Wrap(self.mediactrl.Size.width),\\r\\n self.text_info.Parent.Layout()))\",\n \"def limit_size(msg, max_size, trunc_symbol=\\\"...\\\"):\\n if len(msg) > max_size:\\n msg = msg[:max_size - len(trunc_symbol)] + trunc_symbol\\n return msg\",\n \"def validate_size(size):\\n if not size.lower().endswith(('kb', 'mb', 'gb', 'tb'\\n )) or not size[:-2].isdigit():\\n msg = ('Invalid format for size. \\\\n'\\n 'Valid sizes must be of form X[kKmMgGtT]b where X is an'\\n 'integer. Default = 100mb')\\n raise ValidationError(msg)\",\n \"def write_get_message_size(s, spec, search_path):\\n\\n with Indent(s):\\n s.write('static getMessageSize(object) {')\\n msg_size = get_message_fixed_size(spec, search_path)\\n if msg_size is not None:\\n with Indent(s):\\n s.write('return {};'.format(msg_size))\\n else:\\n def get_dynamic_field_length_line(field, query):\\n if field.is_builtin:\\n if not is_string(field.base_type):\\n raise Exception('Unexpected field {} with type {} has unknown length'.format(field.name, field.base_type))\\n # it's a string array!\\n return 'length += 4 + {}.length;'.format(query)\\n # else\\n (package, msg_type) = field.base_type.split('/')\\n samePackage = spec.package == package\\n if samePackage:\\n return 'length += {}.getMessageSize({});'.format(msg_type, query)\\n else:\\n return 'length += {}.msg.{}.getMessageSize({});'.format(package, msg_type, query)\\n\\n with Indent(s):\\n s.write('let length = 0;')\\n # certain fields will always have the same size\\n # calculate that here instead of dynamically every time\\n len_constant_length_fields = 0;\\n for f in spec.parsed_fields():\\n field_size = None\\n if f.is_builtin:\\n field_size = get_type_size(f.base_type)\\n else:\\n field_msg_context = MsgContext.create_default()\\n field_spec = genmsg.msg_loader.load_msg_by_type(field_msg_context, f.base_type, search_path)\\n field_size = get_message_fixed_size(field_spec, search_path)\\n\\n if f.is_array:\\n if f.array_len and field_size is not None:\\n len_constant_length_fields += (field_size * f.array_len)\\n continue\\n elif not f.array_len:\\n len_constant_length_fields += 4\\n\\n if field_size == 1:\\n s.write('length += object.{}.length;'.format(f.name))\\n elif field_size is not None:\\n s.write('length += {} * object.{}.length;'.format(field_size, f.name))\\n else:\\n if f.is_builtin:\\n if not is_string(f.base_type):\\n raise Exception('Unexpected field {} with type {} has unknown length'.format(f.name, f.base_type))\\n # it's a string array!\\n line_to_write = 'length += 4 + _getByteLength(val);'\\n else:\\n (package, msg_type) = f.base_type.split('/')\\n samePackage = spec.package == package\\n if samePackage:\\n line_to_write = 'length += {}.getMessageSize(val);'.format(msg_type,)\\n else:\\n line_to_write = 'length += {}.msg.{}.getMessageSize(val);'.format(package, msg_type)\\n s.write('object.{}.forEach((val) => {{'.format(f.name))\\n with Indent(s):\\n s.write(line_to_write)\\n s.write('});')\\n elif field_size is not None:\\n len_constant_length_fields += field_size\\n else:\\n # field size is dynamic!\\n if f.is_builtin:\\n if not is_string(f.base_type):\\n raise Exception('Unexpected field {} with type {} has unknown length'.format(f.name, f.base_type))\\n # it's a string array!\\n len_constant_length_fields += 4\\n line_to_write = 'length += _getByteLength(object.{});'.format(f.name)\\n else:\\n (package, msg_type) = f.base_type.split('/')\\n samePackage = spec.package == package\\n if samePackage:\\n line_to_write = 'length += {}.getMessageSize(object.{});'.format(msg_type, f.name)\\n else:\\n line_to_write = 'length += {}.msg.{}.getMessageSize(object.{});'.format(package, msg_type, f.name)\\n s.write(line_to_write)\\n\\n if len_constant_length_fields > 0:\\n s.write('return length + {};'.format(len_constant_length_fields))\\n else:\\n s.write('return length;')\\n s.write('}')\\n s.newline()\",\n \"def __print_size_warning(ow, oh, w, h):\\n if not hasattr(__print_size_warning, 'has_printed'):\\n logging.warning(\\n f\\\"The loaded image size was ({ow}, {oh}), so it was adjusted to ({w}, {h}).This adjustment will be done to all label2ImagePaths\\\")\\n __print_size_warning.has_printed = True\",\n \"def test_size_pretty_intonly(self):\\n assert smdba.basegate.BaseGate.size_pretty(size=str(0x19000000000), int_only=True) == \\\"2 TB\\\"\\n assert smdba.basegate.BaseGate.size_pretty(size=str(0x19000000000), int_only=False) == \\\"1.56 TB\\\"\",\n \"def setSize(size):\\n turtleTmp.penSize(max(1, min(size, 100)))\",\n \"def size(self, size_input: Tuple[str, str]):\\n self.isize = [UIMetric.parse(size_input[0]),\\n UIMetric.parse(size_input[1])]\",\n \"def message_display(text, loc, size, color=None):\\n # gameDisplay = pygame.display.set_mode((width, height))\\n largeText = pygame.font.Font('freesansbold.ttf', size)\\n TextSurf, TextRect = text_objects(text, largeText, color)\\n TextRect.center = (loc[0], loc[1])\\n gameDisplay.blit(TextSurf, TextRect)\\n\\n pygame.display.update()\",\n \"def pretty_print_file_size(size: float) -> str:\\n for x in [\\\"bytes\\\", \\\"KB\\\", \\\"MB\\\", \\\"GB\\\", \\\"TB\\\"]:\\n if size < 1024.0:\\n return f\\\"{size:3.1f} {x}\\\"\\n size /= 1024.0\\n return str(size)\",\n \"def size(self,*args):\\n if len(args) == 2:\\n x,y = map(int,args)\\n else:\\n x,y = map(int,args[0])\\n self.check_size(x,y)\\n self.data['chs'] = '%dx%d'%(x,y)\",\n \"def _prettifySize(self, size) -> str:\\n iteration = 0\\n while size >= 1024:\\n size /= 1024\\n iteration += 1\\n size = f'{size:.2f}'.rstrip('0').rstrip('.').rjust(6) # 6 is maximal number of digits of any input\\n return f'{size} {self._SIZES_SUFFIX[iteration]}'\",\n \"def fontSize(size):\\n\\t\\treturn int(-size * (InterfaceTools.getCanvasSize()[0] / height))\",\n \"def __human_size(size, padding = True):\\n # the spaces after the base unit 'B' are for alignment\\n powers = { 0 : \\\"B \\\", 1 : \\\"KiB\\\", 2 : \\\"MiB\\\", 3 : \\\"GiB\\\", 4 : \\\"TiB\\\", 5 : \\\"PiB\\\", 6 : \\\"EiB\\\" }\\n i = 0\\n orig_size = size\\n size = float(size)\\n while size >= 1024:\\n i += 1\\n size /= 1024\\n if i > 6:\\n print(\\\"Not prepared to handle this number: {:d}\\\".format(orig_size))\\n return \\\"NaN\\\"\\n val = str(round(size, 1)) + ' ' + powers[i]\\n if padding: val = \\\" \\\"*(MAX_SIZE-len(val)) + val\\n return val\",\n \"def print_square(size):\\n if type(size) is float and size < 0:\\n raise TypeError(\\\"size must be an integer\\\")\\n if not isinstance(size, int):\\n raise TypeError(\\\"size must be an integer\\\")\\n if size < 0:\\n raise ValueError(\\\"size must be >= 0\\\")\\n for rows in range(size):\\n print('#' * size)\",\n \"def write_text(size, text):\\n img = Image.new('RGB', size, (255, 255, 255))\\n draw = ImageDraw.Draw(img)\\n font = ImageFont.truetype('/Library/Fonts/Arial.ttf', size)\\n draw.text((10,10), text, (0, 0, 0), font=font)\\n return img\",\n \"def showText(self, context, text, size=1, color=colors.WHITE, conversion=True):\\n context.print(text, self.components, size, color=color, conversion=conversion)\",\n \"def test_pretty_size(self):\\n cases = [\\n (0, '0 B'),\\n (233, '233 B'),\\n (1023, '1023 B'),\\n (1024, '1 KB'),\\n (1024 ** 2 - 1, '1 MB'),\\n (12345678, '12 MB'),\\n (1024 ** 3 + 100, '1 GB'),\\n (1024 ** 4 + 1, '1 TB'),\\n (1024 ** 5 * 2, '2048 TB'),\\n ]\\n\\n for v, expected in cases:\\n actual = utils.pretty_size(v)\\n self.assertEqual(actual, expected)\",\n \"def size(self, size):\\n # type: (string_types) -> None\\n\\n if size is not None:\\n if not isinstance(size, string_types):\\n raise TypeError(\\\"Invalid type for `size`, type has to be `string_types`\\\")\\n\\n self._size = size\",\n \"def printSize(sz, unit=1000):\\n\\n fmt10 = [\\\"%dB\\\", \\\"%dKiB\\\", \\\"%dMiB\\\", \\\"%dGiB\\\", \\\"%dTiB\\\", \\\"%dPiB\\\"]\\n fmt2 = [\\\"%dB\\\", \\\"%dKB\\\", \\\"%dMB\\\", \\\"%dGB\\\", \\\"%dTB\\\", \\\"%dPB\\\"]\\n fmt = fmt10 if unit == 1000 else fmt2\\n i = 0\\n while i < len(fmt):\\n if sz < unit:\\n break\\n sz /= unit\\n i += 1\\n return fmt[i] % (sz)\",\n \"def Print(self, s, color=(229, 153, 153, 255)):\\r\\n self.screen.blit(self.font.render(s, True, color), (5, self.textLine))\\r\\n self.textLine += 15\",\n \"def readable_size(n: int) -> str:\\n sizes = ['K', 'M', 'G']\\n fmt = ''\\n size = n\\n for i, s in enumerate(sizes):\\n nn = n / (1000 ** (i + 1))\\n if nn >= 1:\\n size = nn\\n fmt = sizes[i]\\n else:\\n break\\n return '%.2f%s' % (size, fmt)\",\n \"def formatMemorySize(size):\\n\\n # ClassAds report memory in KB, so start with K\\n suffixes = ['K', 'M', 'G', 'T', 'P']\\n\\n for i in range(len(suffixes)):\\n if size/(10**(i*3)) < 1000:\\n break\\n\\n size = size/float(10**(i*3))\\n suffix = suffixes[i]\\n\\n return '{0:.1f} {1}'.format(size, suffix)\",\n \"def human_size(size_bytes):\\n if size_bytes == 1:\\n # because I really hate unnecessary plurals\\n return \\\"1 byte\\\"\\n\\n suffixes_table = [('bytes', 0), ('KB', 0), ('MB', 1), ('GB', 2), ('TB', 2), ('PB', 2)]\\n\\n num = float(0 if size_bytes is None else size_bytes)\\n for suffix, precision in suffixes_table:\\n if num < 1024.0:\\n break\\n num /= 1024.0\\n\\n if precision == 0:\\n formatted_size = \\\"%d\\\" % num\\n else:\\n formatted_size = str(round(num, ndigits=precision))\\n\\n return \\\"%s %s\\\" % (formatted_size, suffix)\",\n \"def esprint(self,text,w=1,h=1):\\n self.dps.set(height=h,width=w)\\n self.dps.text(text)\",\n \"def __init__(self, size=None):\\n if size is None:\\n size = plt.rcParams[\\\"font.size\\\"]\\n self.size = size\",\n \"def _format_string(value, size):\\n\\n return '{:<{}}'.format(value, size)\",\n \"def __size_restriction_incorrect_string_number(self):\\n\\n strTestName = 'String size lower than a number (incorrect)'\\n RxCSObject = _RxCSobject()\\n\\n RxCSObject.paramAddMan('parameter1', 'String parameter')\\n RxCSObject.paramType('parameter1', str)\\n RxCSObject.paramSizHE('parameter1', 4, mul=2, add=3)\\n\\n RxCSObject.parameter1 = 'aaa'\\n\\n self.__parametersCheck_error(RxCSObject, SizeError, strTestName)\",\n \"def textSize(self, height=1, width=1):\\n if not(0 < height < 17) or type(height) is not int:\\n raise ValueError('height must be a int between 1 and 16')\\n if not(0 < width < 17) or type(width) is not int:\\n raise ValueError('textWidth must be a int between 1 and 16')\\n else:\\n size = (width - 1) << 4 | (height - 1)\\n self._write(self.__class__.__GS + '!' + chr(size))\",\n \"def print(self,text,position=None,size=None,color=mycolors.WHITE,font=None,conversion=True):\\n if conversion:\\n if not position: position=(0,0)\\n if not size: size=1\\n position=self.draw.plane.getToScreen(position,self.draw.window)\\n ux,uy=self.draw.plane.units\\n size=int(size*ux/50)\\n else:\\n if not position: position=(10,10)\\n if not size: size=20\\n self.window.print(text,position,size,color,font)\",\n \"def large_text(self):\\n pass\",\n \"def human_size(size_bytes):\\n if (size_bytes == 1):\\n # because I really hate unnecessary plurals\\n return \\\"1 byte\\\"\\n\\n suffixes_table = [('bytes',0),('KB',0),('MB',1),('GB',2),('TB',2), ('PB',2)]\\n\\n num = float(size_bytes)\\n for suffix, precision in suffixes_table:\\n if (num < 1024.0):\\n break\\n num /= 1024.0\\n\\n if (precision == 0):\\n formatted_size = \\\"%d\\\" % num\\n else:\\n formatted_size = str(round(num, ndigits=precision))\\n\\n return \\\"%s %s\\\" % (formatted_size, suffix)\",\n \"def print_square(size):\\n if type(size) is not int:\\n raise TypeError(\\\"size must be an integer\\\")\\n if size < 0:\\n raise ValueError(\\\"size must be >= 0\\\")\\n row = \\\"#\\\" * size\\n for i in range(size):\\n print(\\\"{}\\\".format(row))\",\n \"def arbitrary_string(size=4, base_text=None):\\n\\n if (base_text is None) or (base_text == ''):\\n base_text = 'test'\\n\\n if size <= 0:\\n return ''\\n\\n extra = size % len(base_text)\\n body = ''\\n\\n if extra == 0:\\n body = base_text * size\\n\\n if extra == size:\\n body = base_text[:size]\\n\\n if extra > 0 and extra < size:\\n body = (size / len(base_text)) * base_text + base_text[:extra]\\n\\n return body\",\n \"def size(self, width, height):\\n self._p('[size] {} {}'.format(width, height))\",\n \"def html_line(size):\\n return '<hr noshade size=\\\"' + str(size) + '\\\">'\",\n \"def pretty_size_print(num_bytes):\\n if num_bytes is None:\\n return\\n\\n KiB = 1024\\n MiB = KiB * KiB\\n GiB = KiB * MiB\\n TiB = KiB * GiB\\n PiB = KiB * TiB\\n EiB = KiB * PiB\\n ZiB = KiB * EiB\\n YiB = KiB * ZiB\\n\\n if num_bytes > YiB:\\n output = \\\"%.3g YB\\\" % (num_bytes / YiB)\\n elif num_bytes > ZiB:\\n output = \\\"%.3g ZB\\\" % (num_bytes / ZiB)\\n elif num_bytes > EiB:\\n output = \\\"%.3g EB\\\" % (num_bytes / EiB)\\n elif num_bytes > PiB:\\n output = \\\"%.3g PB\\\" % (num_bytes / PiB)\\n elif num_bytes > TiB:\\n output = \\\"%.3g TB\\\" % (num_bytes / TiB)\\n elif num_bytes > GiB:\\n output = \\\"%.3g GB\\\" % (num_bytes / GiB)\\n elif num_bytes > MiB:\\n output = \\\"%.3g MB\\\" % (num_bytes / MiB)\\n elif num_bytes > KiB:\\n output = \\\"%.3g KB\\\" % (num_bytes / KiB)\\n else:\\n output = \\\"%.3g Bytes\\\" % (num_bytes)\\n\\n return output\",\n \"def format_size(size):\\n suffixes = ['B', 'KB', 'MB', 'GB']\\n i = 0\\n while size >= 1024 and i < len(suffixes) - 1:\\n size = size / 1024\\n i += 1\\n return f\\\"{size:.2f} {suffixes[i]}\\\"\",\n \"def get_file_size_str(size):\\n if size < 128: return f'{size}B' # only show bytes for really small < 0.1 KB sizes\\n if size < (1024*1024): return f'{size/1024:.1f}KB'\\n if size < (1024*1024*1024): return f'{size/(1024*1024):.1f}MB'\\n return f'{size/(1024*1024):.2}GB'\",\n \"def make_human_readable_size(size, decimals=2):\\n for unit in [\\\"B\\\",\\\"KB\\\",\\\"MB\\\",\\\"GB\\\",\\\"TB\\\"]:\\n if size < 1024.0:\\n break\\n size /= 1024.0\\n return f\\\"{size:.{decimals}f} {unit}\\\"\",\n \"def format_size(size):\\n size = float(size)\\n for unit in ['bit','Kibit','Mibit','Gibit']:\\n if size < 1024.0:\\n return \\\"{size:3.2f}{unit}\\\".format(size=size, unit=unit)\\n size /= 1024.0\\n return \\\"{size:.2f}{unit}\\\".format(size=size, unit='TiB')\",\n \"def humanize_imperial_size(size): # noqa: D301, WPS342\\n if not size:\\n return None\\n\\n total_inches = round(size / 25.4)\\n feet = int(total_inches / 12)\\n inches = int(total_inches % 12)\\n\\n if feet > 10:\\n # Round inches for long boats\\n if inches == 1:\\n inches = 0\\n elif inches == 11:\\n inches = 0\\n feet += 1\\n\\n size = \\\"{0}'\\\".format(feet) if feet else ''\\n if inches:\\n return '{0} {1}\\\"'.format(size, inches).strip()\\n return size\",\n \"def make_pizza(size,*args):\\n print(f\\\"\\\\nMaking a {size}-inch pizza with the following toppings:\\\")\\n for arg in args:\\n print(f\\\"+ {arg}\\\")\",\n \"def test_size_pretty_round(self):\\n for size, res in ((0x40, \\\"64 Bytes\\\"), (0xff, \\\"255 Bytes\\\"),\\n (0x400, \\\"1.00 KB\\\"), (0x800, \\\"2.00 KB\\\"), (0x10000, \\\"64.00 KB\\\"),\\n (0xffff, \\\"64.00 KB\\\"), (0xfffff, \\\"1024.00 KB\\\"),\\n (0x100000, \\\"1.00 MB\\\"), (0x40000000, \\\"1.00 GB\\\"),\\n (0x10000000000, \\\"1.00 TB\\\"), (0x19000000000, \\\"1.56 TB\\\")):\\n assert smdba.basegate.BaseGate.size_pretty(size=str(size)) == res\",\n \"def size(self, new_size):\\n if type(new_size) is str:\\n new_size = new_size.replace(\\\" \\\", \\\"\\\").upper()\\n new_size = new_size.replace(\\\")\\\", \\\"\\\")\\n new_size = new_size.replace(\\\"(\\\", \\\"\\\")\\n new_size = new_size.replace(\\\",\\\", \\\".\\\")\\n new_size = new_size.replace(\\\"B\\\", \\\"\\\").strip()\\n target_unit = None\\n multiplier = 1\\n is_bytes = False\\n try:\\n float(new_size)\\n target_unit = \\\"B\\\"\\n is_bytes = True\\n except Exception as e:\\n pass\\n\\n if not is_bytes:\\n multiplier *= 1024\\n for unit in [\\\"K\\\", \\\"M\\\", \\\"G\\\", \\\"T\\\", \\\"P\\\", \\\"E\\\", \\\"Z\\\", \\\"Y\\\"]:\\n if not target_unit and unit in new_size:\\n target_unit = unit\\n multiplier *= 1024\\n # Reject double units\\n elif target_unit and unit in new_size:\\n target_unit = None\\n break\\n\\n if target_unit:\\n new_size = new_size.replace(target_unit, \\\"\\\").strip()\\n try:\\n self._size = int(float(new_size) * multiplier)\\n except Exception as e:\\n logger.error(f\\\"Failed to set a size from \\\\\\\"{new_size}\\\\\\\"\\\")\\n logger.error(e)\\n\\n elif type(new_size) is int:\\n self._size = new_size\\n\\n else:\\n raise Exception(\\\"Wrong size type provided ({type(new_size)})\\\")\\n\\n if not self._size:\\n logger.warn(f\\\"Failed to set a size from \\\\\\\"{new_size}\\\\\\\"\\\")\",\n \"def h_size(size: int, units: list = None):\\n if units is None:\\n units = H_SIZE_ABBREVIATIONS\\n return f'{size} {units[0]}' if size < 1024 else h_size(size >> 10, units[1:])\",\n \"def size(name):\",\n \"def test_small_message(self):\\n message = \\\"few characters\\\"\\n message_displayed = truncate_message(message, limit=50)\\n\\n self.assertLessEqual(len(message_displayed), 50)\\n self.assertEqual(message_displayed, \\\"few characters\\\")\",\n \"def bytes_for_humans(size, suffix=\\\"B\\\"):\\n for prefix in BYTES_PREFIXES:\\n if size < PREFIX_FACTOR_BYTES:\\n if prefix == \\\"\\\":\\n return \\\"{}{}\\\".format(size, suffix)\\n return \\\"{:.2f}{}{}\\\".format(size, prefix, suffix)\\n size /= PREFIX_FACTOR_BYTES\\n return \\\"{:.2f}{}{}\\\".format(size, \\\"P\\\", suffix)\",\n \"def message(self, text):\\n\\n if type(text) in (bytes, str):\\n T = text\\n else:\\n # list probably:\\n T = '\\\\n'.join(text)\\n print(('-'*60))\\n print(T)\\n print(('='*60))\",\n \"def human_readable(size):\\n if size < 1024**2:\\n hreadable = float(size)/1024.0\\n return \\\"%.0fK\\\" % hreadable\\n elif size < (1024**3):\\n hreadable = float(size)/(1024**2)\\n return \\\"%.1fM\\\" % round(hreadable, 1)\\n else:\\n hreadable = float(size)/(1024.0**3)\\n return \\\"%.2fG\\\" % round(hreadable, 2)\",\n \"def changeScreen(msg, color, offset_x, offset_y, size):\\n font = pygame.font.SysFont(\\\"headlinea\\\", size) # default font\\n text = font.render(msg, True, color) \\n text_rect = text.get_rect()\\n text_x = Screen.get_width() / 2 - text_rect.width / 2 + offset_x\\n text_y = Screen.get_height() / 2 - text_rect.height / 2 + offset_y \\n Screen.blit(text, [text_x, text_y])\",\n \"def message(msg ,font_size, color , pos):\\n font_style = pygame.font.SysFont( \\\"Times New Roman\\\" , font_size)\\n mesg = font_style.render(msg, True, color)\\n dis.blit(mesg, pos)\\n pygame.display.update()\",\n \"def sizeformat(size):\\n for unit in ['bytes', 'KB', 'MB', 'GB', 'TB']:\\n if size < 1024.0:\\n if unit == \\\"bytes\\\":\\n return \\\"%1.0f %s\\\" % (size, unit)\\n else:\\n return \\\"%3.1f %s\\\" % (size, unit)\\n size /= 1024.0\\n return \\\"%.1f PB\\\" % size\",\n \"def human_readable(size, precision=1):\\n suffixes = ['B', 'KB', 'MB', 'GB', 'TB']\\n suffixIndex = 0\\n while size > 1024 and suffixIndex < 4:\\n suffixIndex += 1\\n size = size / 1024.0\\n return \\\"%.*f%s\\\" % (precision, size, suffixes[suffixIndex])\",\n \"def format(self,size):\\n if self.__units is None:\\n # Human-readable\\n return bcf_utils.format_file_size(size)\\n elif self.__units == 'bytes':\\n # Raw bytes\\n return size\\n else:\\n return bcf_utils.format_file_size(size,units=self.__units)[0:-1]\",\n \"def make(size, *toppings):\\r\\n print(\\\"The size of the pizza is \\\"+ str(size))\\r\\n for topping in toppings:\\r\\n print('- '+ topping)\",\n \"def size_str(num):\\n if num > 2 ** 30:\\n return \\\"%0.2fGB\\\" % (num / 2 ** 30)\\n elif num > 2 ** 20:\\n return \\\"%0.2fMB\\\" % (num / 2 ** 20)\\n elif num > 2 ** 10:\\n return \\\"%0.2fkB\\\" % (num / 2 ** 10)\\n else:\\n return \\\"%d bytes\\\" % num\",\n \"def SizeCheck():\\n while True:\\n try:\\n curses.echo() # Enable echoing of characters\\n stdscr.addstr(0, 0, \\\"Give a table square row/column size : \\\")\\n stdscr.move(0, 38)\\n size = stdscr.getstr(0, 38, 2)\\n size = int(size)\\n curses.noecho()\\n if size < 2:\\n raise ValueError\\n return size\\n except ValueError:\\n stdscr.addstr(1, 0, \\\"That is not a valid choice\\\")\",\n \"def get_std_size(size_text):\\r\\n std_size = None\\r\\n # Find the color in the full dictionary\\r\\n size_code = SIZE_FULL.get(size_text)\\r\\n if size_code is not None:\\r\\n std_size = SIZE_STANDARD[size_code]\\r\\n return std_size\",\n \"def setBoxsize(length,width,height):\\n return length,width,height\",\n \"def _SizeStats(self, size_info=None):\\n size_info = size_info or self._size_infos[0]\\n describe.WriteLines(data_quality.DescribeSizeInfoCoverage(size_info),\\n sys.stdout.write)\",\n \"def humanize_metric_size(size):\\n if not size:\\n return None\\n\\n meters = '{0:.2f}'.format(size / 1000.0).rstrip('0').rstrip('.')\\n return str(_('{meters} m')).format(meters=meters)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7936069","0.79013073","0.78979605","0.773878","0.7711005","0.7711005","0.761596","0.75709385","0.7525627","0.74698335","0.74698335","0.746105","0.7382213","0.7262654","0.7155463","0.70711285","0.6359491","0.6280973","0.6197354","0.6151389","0.6046193","0.60298765","0.59832895","0.5969782","0.59375316","0.5882573","0.58414644","0.58264995","0.58199126","0.57541585","0.573652","0.5694172","0.56767243","0.5663704","0.5656327","0.56252533","0.56185067","0.5610329","0.5601953","0.55961895","0.5584568","0.5562378","0.55479985","0.554645","0.55377513","0.5527227","0.5496448","0.5478693","0.5463563","0.5452221","0.5451504","0.5450172","0.5445246","0.54436976","0.5439461","0.543727","0.5428728","0.5425565","0.5417727","0.5412901","0.5405439","0.539895","0.53879946","0.5384954","0.53809327","0.53756016","0.53663677","0.53528804","0.5351961","0.5333449","0.5314645","0.53109944","0.5305977","0.52978617","0.5289383","0.52839285","0.5282252","0.5280714","0.5259387","0.52416754","0.52416676","0.5241137","0.5235386","0.52317595","0.52296835","0.52247345","0.5224475","0.52233565","0.5220878","0.52187866","0.5218191","0.52174854","0.5216014","0.5214532","0.5208494","0.5204881","0.52028775","0.5198315","0.5192044","0.5186027"],"string":"[\n \"0.7936069\",\n \"0.79013073\",\n \"0.78979605\",\n \"0.773878\",\n \"0.7711005\",\n \"0.7711005\",\n \"0.761596\",\n \"0.75709385\",\n \"0.7525627\",\n \"0.74698335\",\n \"0.74698335\",\n \"0.746105\",\n \"0.7382213\",\n \"0.7262654\",\n \"0.7155463\",\n \"0.70711285\",\n \"0.6359491\",\n \"0.6280973\",\n \"0.6197354\",\n \"0.6151389\",\n \"0.6046193\",\n \"0.60298765\",\n \"0.59832895\",\n \"0.5969782\",\n \"0.59375316\",\n \"0.5882573\",\n \"0.58414644\",\n \"0.58264995\",\n \"0.58199126\",\n \"0.57541585\",\n \"0.573652\",\n \"0.5694172\",\n \"0.56767243\",\n \"0.5663704\",\n \"0.5656327\",\n \"0.56252533\",\n \"0.56185067\",\n \"0.5610329\",\n \"0.5601953\",\n \"0.55961895\",\n \"0.5584568\",\n \"0.5562378\",\n \"0.55479985\",\n \"0.554645\",\n \"0.55377513\",\n \"0.5527227\",\n \"0.5496448\",\n \"0.5478693\",\n \"0.5463563\",\n \"0.5452221\",\n \"0.5451504\",\n \"0.5450172\",\n \"0.5445246\",\n \"0.54436976\",\n \"0.5439461\",\n \"0.543727\",\n \"0.5428728\",\n \"0.5425565\",\n \"0.5417727\",\n \"0.5412901\",\n \"0.5405439\",\n \"0.539895\",\n \"0.53879946\",\n \"0.5384954\",\n \"0.53809327\",\n \"0.53756016\",\n \"0.53663677\",\n \"0.53528804\",\n \"0.5351961\",\n \"0.5333449\",\n \"0.5314645\",\n \"0.53109944\",\n \"0.5305977\",\n \"0.52978617\",\n \"0.5289383\",\n \"0.52839285\",\n \"0.5282252\",\n \"0.5280714\",\n \"0.5259387\",\n \"0.52416754\",\n \"0.52416676\",\n \"0.5241137\",\n \"0.5235386\",\n \"0.52317595\",\n \"0.52296835\",\n \"0.52247345\",\n \"0.5224475\",\n \"0.52233565\",\n \"0.5220878\",\n \"0.52187866\",\n \"0.5218191\",\n \"0.52174854\",\n \"0.5216014\",\n \"0.5214532\",\n \"0.5208494\",\n \"0.5204881\",\n \"0.52028775\",\n \"0.5198315\",\n \"0.5192044\",\n \"0.5186027\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72824085"},"document_rank":{"kind":"string","value":"13"}}},{"rowIdx":83172,"cells":{"query":{"kind":"string","value":"Accepts a city and a country and prints a simple sentence with those values."},"document":{"kind":"string","value":"def describe_city(city, country='New Zealand'):\n\tprint(f\"\\nThe city of {city} is in {country}.\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def city_country(city, country):\n print(f'\"{city.title()}, {country.title()}\"\\n')","def describe_city(city, country='canada'):\n print(f\"{city.title()} is in {country.title()}.\")","def describe_city(city, country='Germany'):\n\tprint(f'{city.title()} is in {country.title()}.')","def describe_city(name, country='united kingdom'):\n print(f\"\\n{name.title()} is in {country.title()}.\")","def describe_city(city, country='Japan'):\n print(city.title() + \" is in \" + country.title() + \".\")","def city_country(city, country):\n place = f\"{city}, {country}\"\n return place.title()","def city_country(city, country, population):\n output_string = f\"{city.title()}, {country.title()}\"\n output_string += f\" -population {population}\"\n return output_string","def city_country(city, country):\n c_c = '\"' + city + \", \" + country + '\"'\n return c_c.title()","def city_country(city, country):\n city_and_country = city + ', ' + country\n return city_and_country.title()","def city_country(city, country):\n return city.title() + \", \" + country.title()","def city_country(city, country):\n return f\"{city.title()}, {country.title()}\"","def city_country(city, country):\n return f\"{city.title()}, {country.title()}\"","def city_country(city, country):\r\n\treturn(city.title() + ', ' + country.title())","def city_country(city, country):\n full_city = city + \", \" + country\n return full_city.title()","def city_country(city, country):\n return(city.title() + \", \" + country.title())","def city_country(city, country):\n pair = f\"{city.title()}, {country.title()}\"\n return pair","def city_country(city_name, country_name):\n combi = f\"{city_name.title()}, {country_name.title()}\"\n return combi.title()","def city_names(city, country):\n place = f\"{city}, {country}\"\n return place.title()","def city_country(city_name, country):\n formatted_string = f\"{city_name.title()}, {country.title()}\"\n return formatted_string","def city_country(city, country):\n return(city + ', ' + country)","def city_country(city, country):\n formatted_city_country = city.title() + \", \" + country.title() + \".\"\n return formatted_city_country","def city_country(city_name, country_name):\n city_country_combo = city_name + ', ' + country_name\n return city_country_combo.title()","def city_country(city, country, population=0):\n if population:\n formatted_city_country = city.title() + \", \" + country.title() + \" - \"\n formatted_city_country += \"population \" + str(population)\n else:\n formatted_city_country = city.title() + \", \" + country.title()\n return formatted_city_country","def get_city_country(city, country, population=''):\n if population:\n location = city + ' ' + country + ' ' + str(population)\n return location.title()\n\n else:\n location = city + ' ' + country\n return location.title()","def get_city_country(city, country, population=''):\n if population:\n city_country = f\"{city}, {country} - population {population}\"\n else:\n city_country = f\"{city}, {country}\"\n return city_country.title()","def get_formatted_location(city, country):\n\tformatted_location = city + \", \" + country\n\treturn formatted_location.title()","def city_location(city, country, population = None):\n if population:\n full_str = f\"{city.title()}, {country.title()} - population {population}\"\n else:\n full_str = f\"{city.title()}, {country.title()}\"\n return full_str","def get_formatted_place(city, country):\n place = f\"{city} {country}\"\n return place.title()","def get_location(city, country, population=\"\"):\n\tdetails = city.title() + \", \" + country.title()\n\t#if population is specified i.e. not default value, append\n\tif population:\n\t\tdetails += \" - population \" + str(population)\n\t#in either case, return details\n\treturn details","def test_city_country(self):\n formatted_city = get_full_city(\"santiago\", \"chile\")\n self.assertEqual(formatted_city, \"Santiago, Chile\")","def test_city_country(self):\n formatted_name = city_country('santiago', 'chile')\n self.assertEqual(formatted_name, 'Santiago, Chile')","def test_city_country(self):\n\t\tformatted_address = city_country('santiago', 'chile')\n\t\tself.assertEqual(formatted_address, 'Santiago, Chile')","def get_formatted_city(city, country, population=None):\n if population:\n city_country = f\"{city.title()}, {country.title()} - population {population}.\"\n else:\n city_country = f\"{city.title()}, {country.title()}.\"\n\n return city_country","def country() -> str:","def _get_countries():\n print('-c, -C [country]\\\n \\n [country]=\\\n \\n AR\\t: Argentina\\\n \\n AT\\t: Austria\\\n \\n BR\\t: Brazil\\\n \\n BY\\t: Belarus\\\n \\n CA\\t: Canda\\\n \\n DE\\t: Germany\\\n \\n FR\\t: France\\\n \\n GB\\t: Great Britain\\\n \\n GH\\t: Ghana\\\n \\n HU\\t: Hungary\\\n \\n ID\\t: Indonesia\\\n \\n IL\\t: Israel\\\n \\n JP\\t: Japan\\\n \\n KR\\t: Korea\\\n \\n MA\\t: Morocco\\\n \\n MY\\t: Malaysia\\\n \\n NL\\t: Netherlands\\\n \\n NO\\t: Norway\\\n \\n OM\\t: Oman\\\n \\n PK\\t: Pakistan\\\n \\n RU\\t: Russia\\\n \\n SA\\t: Saudi Arabia\\\n \\n TH\\t: Thailand\\\n \\n TW\\t: Taiwan\\\n \\n UA\\t: Ukraine\\\n \\n US\\t: United States\\\n \\n UY\\t: Uruguay\\\n \\n VE\\t: Venezuela\\\n \\n VN\\t: Vietnam\\\n \\n .....\\n common usage: opengate -c JP')","def test_city_country(self):\n santiago_chile = get_city_name('santiago', 'chile')\n self.assertEqual(santiago_chile, 'Santiago, Chile')","def test_city_country(self):\n santiago_chile = city_country('santiago', 'chile')\n self.assertEqual(santiago_chile, 'Santiago, Chile')","def test_city_country(self):\n santiago_chile = city_country('santiago', 'chile')\n self.assertEqual(santiago_chile, 'Santiago, Chile')","def test_city_country(self):\n santiago_chile = city_country('santiago', 'chile')\n self.assertEqual(santiago_chile, 'Santiago, Chile')","def get_city_country(city, country, population=''):\n\tif population:\n\t\tcity_country = city.title() + ', ' + country.title() + \" - population \" + str(population)\n\telse:\n\t\tcity_country = city.title() + ', ' + country.title()\n\treturn city_country","def test_city_country(self):\n dublin_ireland = city_country('dublin', 'ireland')\n self.assertEqual(dublin_ireland, 'Dublin, Ireland')","def print_cities() -> None:\n city_list = get_cities()\n i = 1\n for a,b,c,d,e in zip(city_list[::5], city_list[1::5], city_list[2::5], city_list[3::5], city_list[4::5]):\n a = str(i) + f\".{a}\"\n i += 1\n b = str(i) + f\".{b}\"\n i += 1\n c = str(i) + f\".{c}\"\n i += 1\n d = str(i) + f\".{d}\"\n i += 1\n e = str(i) + f\".{e}\"\n i += 1\n if e == '410.youngstown':\n print(\"{:<20}{:<20}{:<20}{:<20}{:<}\".format(a,b,c,d,e))\n a = str(i) + f\".{city_list[i-1]}\"\n b = str(i+1) + f\".{city_list[i]}\"\n i += 1\n c = c = str(i+1) + f\".{city_list[i]}\"\n print(\"{:<20}{:<20}{:<}\".format(a,b,c))\n else:\n print(\"{:<20}{:<20}{:<20}{:<20}{:<}\".format(a,b,c,d,e))","def test_city_country(self):\n formatted_name = make_formatted_name('santiago', 'chile')\n self.assertEqual(formatted_name, 'Santiago, Chile')","def Raw_Data(city,month,day):\n print(\"The city you have entered is: \",city)\n print(\"The month you have entered is: \",month)\n print(\"The day you have entered is: \",day)","def test_city_country_population(self):\n\t\tformatted_address = city_country(\n\t\t\t'santiago', 'chile', '5000000')\n\t\tself.assertEqual(formatted_address, \n\t\t\t'Santiago, Chile - Population 5000000')","def get_state_info(city, state, population=''):\n if population:\n city_info = city + ' ' + state + ' - ' + population\n city_info.title()\n else:\n city_info = city + ' ' + state\n city_info.title()\n return city_info","def get_city_info(g, city_name):\n flag = 0\n for key in g.city_dict:\n if(g.city_dict[key].get_name() == city_name):\n print g.city_dict[key].get_info()\n flag = 1\n \n if(flag == 0):\n print (\"Invalid Input\")","def test_city_country_population(self):\n your_location = location_name(\"lviv\", \"ukraine\", \"123\")\n self.assertEqual(your_location, \"Lviv, Ukraine - Population 123\")","def test_city_country_population(self):\n formatted_name = make_formatted_name('santiago', 'chile', 5000000)\n self.assertEqual(formatted_name, 'Santiago, Chile - population 5000000')","def test_city_country_population(self):\n santiago_chile = get_city_name('santiago', 'chile','5000000')\n self.assertEqual(santiago_chile, 'Santiago, Chile - population 5000000')","def select_city():\r\n city = input('Enter the city name for which you want to explore BikeShare data.'\r\n 'Would you like to see data for Chicago, New York, or Washington?\\n').title()\r\n if city.lower() == 'chicago' or city.lower() == 'c':\r\n\r\n return \"chicago\"\r\n\r\n elif city.lower() == 'new york' or city.lower() == 'n':\r\n\r\n return \"new york\"\r\n\r\n elif city.lower() == 'washington' or city.lower() == 'w':\r\n\r\n return \"washington\"\r\n\r\n else:\r\n\r\n print(\"\\nI'm sorry, I'm not sure which city you're referring to. Let's try again.\")\r\n\r\n return select_city()","def city():\n\n print(\"Welcome to my weather API\")\n\n yourcity = input(\"Enter A known City name: \")\n api_key = (\"077936f695f61908cd19a5a2452a97fb\") \n #our public Api-key \n response = requests.get(\"http://api.openweathermap.org/data/2.5/weather?q={0}&appid=077936f695f61908cd19a5a2452a97fb\".format(yourcity, api_key)) #api call\n weather = response.json()\n print(\"The current weather in {0} is {1}\".format(yourcity, weather[\"weather\"][0][\"description\"])) #the result","def _build_city(db, place):\n location = get_main_location(db, place)\n county = location.get(PlaceType.COUNTY)\n # Build a title description string that will work for Eniro\n city_descr = _build_area(db, place)\n if county:\n city_descr += ', ' + county\n return _strip_leading_comma(city_descr)","def to_location(city: str = None, state: str = None) -> str:\n if city is None and state is None:\n return \"USA\"\n elif city is None or state is None:\n return f\"{city or ''}{state or ''}, USA\"\n return f\"{city}, {state} USA\"","def day_009_2():\n travel_log = [\n {\n \"country\": \"France\",\n \"visits\": 12,\n \"cities\": [\"Paris\", \"Lille\", \"Dijon\"]\n },\n {\n \"country\": \"Germany\",\n \"visits\": 5,\n \"cities\": [\"Berlin\", \"Hamburg\", \"Stuttgart\"]\n },\n ]\n\n def add_new_country(country, visits, cities):\n # Add new information to the travel log\n travel_log.append({\"country\": country, \"visits\": visits, \"cities\": cities})\n\n # Print the new information in readable syntax.\n print(f\"You've visited {country} {visits} times.\")\n\n # Assemble readable output for the list using commas, 'and', and a period.\n output_string = \"\"\n num_cities = len(cities)\n for city in cities:\n if num_cities == len(cities):\n # If this is our first city, just add it to the output string.\n output_string = city\n elif num_cities > 1:\n # If this is not the first city OR the last city, add it with a comma.\n output_string = output_string + f\", {city}\"\n else:\n # If this is our last city, use the word 'and' and end with a period.\n output_string = output_string + f\" and {city}.\"\n num_cities = num_cities - 1\n # Print the cities added to the travel log\n print(f\"You've been to {output_string}\")\n\n add_new_country(\"Russia\", 2, [\"Moscow\", \"Saint Petersburg\"])\n print(travel_log)","def main(city: str, language: str, interval: str):\n data = get_weather_info(city, language, interval)\n pretty_print(data)","def description(self):\n\t\treturn \"%s, %s\" % (self.name, self.country)","def test_city_country(self):\n your_location = location_name(\"lviv\", \"ukraine\")\n self.assertEqual(your_location, \"Lviv, Ukraine\")","def test_city_country_population(self):\n \tdublin_ireland = city_country('dublin', 'ireland', population=500000)\n \tself.assertEqual(dublin_ireland, 'Dublin, Ireland - Population 500000')","def name():\n fname = input(\"Enter your first name:\")\n lname = input(\"Enter your last name:\")\n city = input(\"Enter the city you live in:\")\n state = input(\"Enter the state you live in:\")\n\n fullname = fname+ \" \"+ lname\n city_state = city +\", \" +state\n print(\"Your name is:\",fullname)\n print(\"You live in:\",city_state)","def print_data(**kwargs):\n return f'Имя: {kwargs.get(\"name\")}, Фамилия: {kwargs.get(\"surname\")}, Год рождения: {kwargs.get(\"birth_year\")},' \\\n f' Город проживания: {kwargs.get(\"city\")}, Адрес эл. почты: {kwargs.get(\"email\")},' \\\n f' Номер телефона: {kwargs.get(\"phone\")}.'","def convert_country(country):\n if (country and 'China' in country) or \\\n country == 'Chin' or country == 'CHINA':\n country = 'China'\n elif country and 'Brazil' in country or \\\n country == 'Brasil' or \\\n country == 'ITA - Instituto Tecnologico de Aeronautica (':\n country = 'Brazil'\n elif country and 'Argentina' in country:\n country = 'Argentina'\n elif country == 'Czechia':\n country = 'Czech Republic'\n elif 'Norwegian' in country:\n country = 'Norway'\n elif country and 'United Kingdom' in country:\n country = 'United Kingdom'\n elif country and 'Hong Kong' in country:\n country = 'Hong Kong'\n elif country == 'Cameroun':\n country = 'Cameroon'\n elif (country and 'Chile' in country) or country == 'CHILE':\n country = 'Chile'\n elif (country and 'United States of America' in \\\n country) or country == 'United States' or country \\\n == 'USA' or 'Florida' in country or \\\n 'California' in country or\\\n country == 'National Reference Centre for' or \\\n country == 'United State of America' or \\\n country == 'U.S.A.' or \\\n country == 'Virginia':\n country = 'United States of America'\n elif country=='Republic of Panamá' or country=='Panamá' or 'Panama' in country:\n country = 'Panama'\n elif 'Canada' in country:\n country = 'Canada'\n elif 'Colombia' in country:\n country = 'Colombia'\n elif 'Spain' in country or country=='España':\n country = 'Spain'\n elif 'Iran' in country:\n country = 'Iran'\n elif 'Saudi Arabia' in country:\n country = 'Saudi Arabia'\n elif 'Italy' in country:\n country = 'Italy'\n elif 'Japan' in country:\n country = 'Japan'\n elif 'Germany' in country:\n country = 'Germany'\n elif 'Luxembourg' in country:\n country = 'Luxembourg'\n elif ('France' in country) or country == 'Marseille':\n country = 'France'\n elif country == 'ROC' or country == 'R. O. C':\n country = 'Taiwan'\n elif country == 'Brasil':\n country = 'Brazil'\n elif country == 'México' or 'Mexico' in country:\n country = 'Mexico'\n elif 'Slowakia' in country:\n country = 'Slowakia'\n elif country == 'Korea' or 'Republic of Korea' in country:\n country = 'South Korea'\n elif country == 'United Kindgom':\n country = 'United Kingdom'\n elif country and 'Netherlands' in country:\n country = 'Netherlands'\n elif country == 'Commonwealth of Australia' or 'Australia' in country:\n country = 'Australia'\n elif 'Singapore' in country:\n country = 'Singapore'\n elif country and (country[0].isdigit() or country[0] == '+'):\n country = 'N/A'\n return country","def audience_simple(country):\r\n if country == 'US':\r\n return 'USA'\r\n elif country == 'IN':\r\n return 'India'\r\n else:\r\n return 'Other'","def test_single_word_boston(self):\n result = location.lookup_location('Boston GB')\n\n self.assertEqual(result['country'], 'GB')","def get_country_details(self,country):\n try:\n country_obj = pycountry.countries.get(name=country)\n if country_obj is None:\n c = pycountry.countries.search_fuzzy(country)\n country_obj = c[0]\n continent_code = pc.country_alpha2_to_continent_code(country_obj.alpha_2)\n continent = pc.convert_continent_code_to_continent_name(continent_code)\n return country_obj.alpha_3, continent\n except:\n if 'Congo' in country:\n country = 'Congo'\n elif country == 'Diamond Princess' or country == 'Laos' or country == 'MS Zaandam' or country == 'Holy See' or country == 'Timor-Leste':\n return country, country\n elif country == 'Korea, South' or country == 'South Korea':\n country = 'Korea, Republic of'\n elif country == 'Taiwan*':\n country = 'Taiwan'\n elif country == 'Burma':\n country = 'Myanmar'\n elif country == 'West Bank and Gaza':\n country = 'Gaza'\n else:\n return country, country\n country_obj = pycountry.countries.search_fuzzy(country)\n continent_code = pc.country_alpha2_to_continent_code(country_obj[0].alpha_2)\n continent = pc.convert_continent_code_to_continent_name(continent_code)\n return country_obj[0].alpha_3, continent","def countryInput(self, prompt):\n while True:\n name = input(prompt)\n if name not in self.travel_db.countries:\n print(\"Invalid country name. Please make sure name is capitalized.\")\n else:\n return name","def print_cities(road_map): \n\n print('*** THE ORIGINAL MAP (TOTAL DISTANCE {}) ***'.format(compute_total_distance(road_map)))\n print('')\n for i, location in enumerate(road_map):\n try:\n print('- {}, {}: ({},{})'.format(location[1], \\\n location[0], round(location[2],1), round(location[3],1)))\n except Exception as e:\n print('Error with print_cities: '+str(e))\n print('____________________________________________________________________')\n print('')","def func(self):\n account = self.account\n city_name = 'Phoenix' if not self.args else self.args\n a = Astral()\n a.solar_depression = 'civil'\n city = a[city_name]\n if not city:\n return\n timezone = city.timezone\n sun = city.sun(date=datetime.date.today(), local=True)\n\n account.msg('Information for %s/%s\\n' % (city_name, city.region))\n account.msg('Timezone: %s' % timezone)\n account.msg('Latitude: %.02f; Longitude: %.02f' % (city.latitude, city.longitude))\n account.msg('Dawn: %s' % str(sun['dawn']))\n account.msg('Sunrise: %s' % str(sun['sunrise']))\n account.msg('Noon: %s' % str(sun['noon']))\n account.msg('Sunset: %s' % str(sun['sunset']))\n account.msg('Dusk: %s' % str(sun['dusk']))","def get_human_readable_choice(city, month, day):\n current_data_string = \"You have selected to view data from \" + CITIES[city].title()\n if month != 0:\n current_data_string += \" in \" + MONTHS[month].title()\n\n if day != 7:\n current_data_string += \" on a \" + DAY_OF_WEEK[day].title()\n\n return current_data_string","def get_country_info(country):\n return GoogleV3().geocode(country)","def GetCityByUser():\n City = str(input())\n if (City == \"\"):\n exit()\n Weather = GetWeatherByCity(City)\n print(\"The weather in \" + City + \" is:\\n\")\n PrintWeather(Weather) \n return 1","def get_weather_report():\n try:\n lat, long = None, None\n option = input(\"Get weather report of City \\n1.Select from database \\n2.Enter manually\\n\")\n if option == '1':\n lat, long = get_by_city()\n elif option == '2':\n lat, long = get_by_altitute()\n print(\"~~~~~~~~~~~~~~~~~~~~~~~Getting the weather report for the city~~~~~~~~~~~~~~~~~~~~\")\n response = requests.get(BASE_URL.format(lat, long, API_KEYS), verify=True)\n print(json.dumps(json.loads(response.text), indent=4))\n except ValueError:\n print(\"Select correct option.\")","def test_single_word_exeter(self):\n result = location.lookup_location('Exeter GB')\n\n self.assertEqual(result['country'], 'GB')","def get_city_from_user():\n while True:\n city = input('Select the city you want to explore. \\n1. Chicago\\n2. New york city\\n3. Washington\\n Press 1,'\n '2 or 3 to select the city: ')\n\n if city in VALID_CITIES.keys():\n confirm = input(\"You have selected {}. Press 'y' to confirm: \".format(VALID_CITIES[city]))\n\n if confirm == 'y':\n break\n else:\n print(\"Try again.\\n\")\n else:\n print(\"Invalid input: {}. Try again.\\n\".format(city))\n return city","def return_city(n):\n if n == 1:\n return \"San Francisco\"\n elif n == 2:\n return \"Los Angeles\"\n elif n == 3:\n return \"Las Vegas\"\n elif n == 4:\n return \"Portland\"\n elif n == 5:\n return \"San Diego\"\n else:\n return \"Seattle\"","def take_input():\r\n from_country = input(\"From Country: \")\r\n to_country = input(\"TO Country: \")\r\n amount = float(input(\"Amount: \"))\r\n return from_country, to_country, amount","def get_filters():\n print('Hello! Let\\'s explore some US bikeshare data!')\n # get user input for city (chicago, new york city, washington). \n # ask user to determine city \n \n while True:\n city = input(\"choose city you want to explore from ('chicago', 'new york city', 'washington')\")\n if city.lower()in ['chicago', 'new york city', 'washington']:\n break\n else:\n print(\"{} invalid input\".format(city))\n \n \n \n # get user input for month (all, january, february, ... , june)\n while True:\n month = input(\"choose the month you want to explore from ('jan','feb','mar','apr','may','jun','all')\")\n if month.lower()in['jan','feb','mar','apr','may','jun','all']:\n break \n else:\n print(\"{}invalid input\".format(month))\n \n \n # get user input for day of week (all, monday, tuesday, ... sunday)\n while True:\n day = input(\"choose the day you want to explore from ('saturday','sunday','monday','tuesday','wednesday','thursday','friday','all')\")\n if day.lower() in ['saturday','sunday','monday','tuesday','wednesday','thursday','friday','all']:\n break\n else:\n print(\"{}invalid input\".format(day))\n \n \n\n\n print('-'*40)\n return city.lower(), month.lower(), day.lower()","async def countryinfo_command(self, ctx, *, countryname: str):\n async with aiohttp.ClientSession() as session:\n async with session.get(\n f\"https://restcountries.eu/rest/v2/name/{countryname}\"\n ) as resp:\n info = await resp.json()\n countryName = info[0][\"name\"]\n topLevelDomainn = info[0][\"topLevelDomain\"]\n topLevelDomain = \",\".join(topLevelDomainn)\n alpha2Code = info[0][\"alpha2Code\"]\n callingCodesList = info[0][\"callingCodes\"]\n callingCodes = \",\".join(callingCodesList)\n capital = info[0][\"capital\"]\n region = info[0][\"region\"]\n population = info[0][\"population\"]\n nativeName = info[0][\"nativeName\"]\n timeZonesList = info[0][\"timezones\"]\n timeZones = \",\".join(timeZonesList)\n currencies = info[0][\"currencies\"]\n currency_code = currencies[0][\"code\"]\n currency_symbol = currencies[0][\"symbol\"]\n alternativeSpellingsList = info[0][\"altSpellings\"]\n alternativeSpellings = \",\".join(alternativeSpellingsList)\n\n embed = Embed(\n color=Color.blurple(),\n timestamp=datetime.utcnow(),\n description=f\"**Name** - {countryName}\\n**Top Level Domain** - {topLevelDomain}\\n**Alpha2 Code** - {alpha2Code}\\n**Calling Codes** - {callingCodes}\\n**Capital** - {capital}\\n **Region** - {region}\\n**Population** - {population}\\n**Native Name** - {nativeName}\\n**Time Zones** - {timeZones}\\n**Currency Code** - {currency_code}\\n**Currency Symbol** - {currency_symbol}\\n**Alternative Spellings** - {alternativeSpellings}\",\n )\n embed.set_author(name=f\"Info of {countryName}\")\n embed.set_thumbnail(\n url=f\"https://flagcdn.com/w80/{str(alpha2Code).lower()}.png\"\n )\n embed.set_footer(text=f\"Requested by {ctx.author}\")\n await ctx.send(embed=embed)","def get_by_city():\n while True:\n try:\n for key in CITY_DICT:\n print(key)\n city = input(\"Enter city name: \")\n lat, long = CITY_DICT.get(city.capitalize())\n return lat, long\n except TypeError:\n print(\"~\" * 50)\n print(\"Please enter the city name correctly\")","def GetCity():\n IPinfoRequest = requests.get('https://ipinfo.io/')\n IPinfo = IPinfoRequest.json()\n City = IPinfo['city']\n return(City)","def get_filters():\n\n cities = CITY_DATA.keys()\n months = ('all', 'january', 'february','march', 'april', 'may', 'june')\n days = ('all', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday')\n print('Hello! Let\\'s explore some US bikeshare data!')\n\n # TO DO: get user input for city (chicago, new york city, washington). HINT: Use a while loop to handle invalid inputs\n city_name= \"chicago, new york city or washington\"\n while True:\n city = input('Which city would you like to view:{}?\\n'.format(city_name)).lower()\n if city not in cities:\n print('Invalid response, please try again.')\n continue\n else:\n break\n\n # TO DO: get user input for month (all, january, february, ... , june)\n month_list=\"all, january, february, march, april, may or june\"\n while True:\n month = input('Which month would you like to view: {}?\\n'.format(month_list)).lower()\n if month not in months:\n print('Invalid response, please try again.')\n continue\n else:\n break\n\n # TO DO: get user input for day of week (all, monday, tuesday, ... sunday)\n week_days= \"all, monday, tuesday, wednesday, thursday, friday, saturday or sunday\"\n while True:\n day = input('Which day of the week would you like to view:{}?\\n'.format(week_days)).lower()\n if day not in days:\n print('Invalid response, please try again.')\n continue\n else:\n break\n\n print('-'*40)\n return city, month, day","def hometown_greeting(hometown, first_name, last_name):\n\n\tif is_hometown(hometown):\n\t\tprint \"Hi \" + full_name(first_name, last_name) + \", we're from the same place!\"\n\telse:\n\t\tprint \"Hi \" + full_name(first_name, last_name) + \", where are you from?\"","def test_single_word_swanage(self):\n result = location.lookup_location('Swanage GB')\n\n self.assertEqual(result['country'], 'GB')","def filter_city(input_city: str) -> str:\n # input_city = string.capwords(input_city.lower())\n result = filterString(input_city).cities\n return result","def show_sample_city (city_record):\n sample = copy.deepcopy(city_record)\n data = xpath(sample, 'data' )\n data[1:] = [ '... other similar dicts ...']\n pprint.pprint (sample)","def get_filters():\n print('Hello! Let\\'s explore some US bikeshare data!')\n\n city = get_city_from_user()\n print('-' * 10)\n\n # get user input for month (all, january, february, ... , june)\n month = get_month_from_user()\n print('-' * 10)\n\n # get user input for day of week (all, monday, tuesday, ... sunday)\n day = get_day_of_week_from_user()\n print('-' * 40)\n return city, month, day","def print_cities(g):\n cities = []\n for key in g.city_dict:\n cities.append(g.city_dict[key].get_name())\n return cities","def searchCountry(host):\n process = subprocess.Popen(\"geoiplookup \"+host,stdout=subprocess.PIPE, shell=True)\n (output, err) = process.communicate()\n secondPart = output.split(\"GeoIP Country Edition: \", 1)[1]\n country = secondPart.split(\"\\nGeoIP City Edition\", 1)[0]\n return country","def check_born_place(input_string: str) -> tuple:\n c = input_string[0]\n if c == 'A':\n return 'Taipei City', 10\n elif c == 'B':\n return 'Taichung City', 11\n elif c == 'C':\n return 'Keelung City', 12\n elif c == 'D':\n return 'Tainan City', 13\n elif c == 'E':\n return 'Kaohsiung City', 14\n elif c == 'F':\n return 'New Taipei City', 15\n elif c == 'G':\n return 'Yilan County', 16\n elif c == 'H':\n return 'Taoyuan City', 17\n elif c == 'I':\n return 'Chiayi City', 34\n elif c == 'J':\n return 'Hsinchu County', 18\n elif c == 'K':\n return 'Miaoli County', 19\n elif c == 'L':\n return 'Taichung County', 20\n elif c == 'M':\n return 'Nantou County', 21\n elif c == 'N':\n return 'Changhua County', 22\n elif c == 'O':\n return 'Hsinchu City', 35\n elif c == 'P':\n return 'Yunlin County', 23\n elif c == 'Q':\n return 'Chiayi County', 24\n elif c == 'R':\n return 'Tainan County', 25\n elif c == 'S':\n return 'Kaohsiung County', 26\n elif c == 'T':\n return 'Pingtung County', 27\n elif c == 'U':\n return 'Hualien County', 28\n elif c == 'V':\n return 'Taitung County', 29\n elif c == 'W':\n return 'Kinmen County', 32\n elif c == 'X':\n return 'Penghu County', 30\n elif c == 'Y':\n return 'Yangmingshan Management Bureau', 31\n elif c == 'Z':\n return 'Lienchiang County', 33\n else:\n # Should not happen\n return None, None # The return value is a tuple containing two values","def get_filters():\n print('Hello! Let\\'s explore some US bikeshare data!')\n\n while True:\n city = input('Are you from Washington, New York City or Chicago: ').lower()\n if city in cities:\n break\n print('You selected: ', city)\n#fixed the missing loop and case sensitivity in 'month' and 'day' input\n while True:\n month = input('Which month would you like to filter, choose \"all\" if you do not want to filter: ').lower()\n if month in months:\n break\n print('You selected')\n\n while True:\n day = input('Which day would you like to filter, choose \"all\" if you do not want to filter: ').lower()\n if day in days:\n break\n\n print('-'*40)\n return city, month, day","def test_addr_city_good_values(self):\n for input_val, output_val in self.known_values:\n self.line._parse_addr_city(input_val)\n self.assertEqual(output_val, self.line.addr_city)","def ad_rep_city_state(obj):\n return '%s, %s' % (obj.ad_rep.geolocation_object.us_city.name,\n obj.ad_rep.geolocation_object.us_state.abbreviation)","def get(world, country, json):\n if world:\n dt = data.get_global_data()\n pretty_print(dt, json)\n if country:\n dt = data.get_country_data(country)\n pretty_print(dt, json)","def get_filters():\n print('Hello! Let\\'s explore some US bikeshare data!')\n # TO DO: get user input for city (chicago, new york city, washington). HINT: Use a while loop to handle invalid inputs\n while True:\n city = input(\"Enter the city name: \").lower()\n if city not in ('chicago', 'new york city', 'washington'):\n print('Not found the city name. Try again!')\n continue\n else:\n break\n \n # TO DO: get user input for month (all, january, february, ... , june)\n while True:\n month = input(\"Enter the month: \").lower()\n if month not in ('january', 'february', 'march', 'april', 'may', 'june', 'all'):\n print('Not found the month')\n continue\n else:\n break\n \n # TO DO: get user input for day of week (all, monday, tuesday, ... sunday)\n while True:\n day = input('Enter the day: ').lower()\n if day not in ('monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday'):\n print('Not found the day')\n continue\n else:\n break\n \n print('-'*40)\n return city, month, day","def get_filters():\n print('Hello! Let\\'s explore some US bikeshare data!')\n # TO DO: get user input for city (chicago, new york city, washington). HINT: Use a while loop to handle invalid inputs\n cities= ['chicago','new york city','washington']\n \n while True:\n city =input(\"Please Enter City: \").lower()\n if city in cities:\n break\n else:\n print(\"Please enter right input!\")\n \n # TO DO: get user input for month (all, january, february, ... , june)\n months=['all','january','february','march','april','june']\n \n while True:\n month=input(\"Please Enter month: \").lower()\n if month in months:\n break\n else:\n \n print(\"Please enter right input!\")\n\n\n # TO DO: get user input for day of week (all, monday, tuesday, ... sunday)\n days=['all','monday','tuesday','wednesday','thursday','friday','saturday','sunday']\n \n while True:\n \n day=input(\"Please Enter Day: \").lower()\n if day in days:\n break\n else:\n print(\"Please enter right input!\")\n\n print('-'*40)\n return city, month, day","def get_filters():\n print('Hello! Let\\'s explore some US bikeshare data!')\n # get user input for city (chicago, new york city, washington). HINT: Use a while loop to handle invalid inputs\n cities = ('chicago', 'new york', 'washington')\n while True:\n city = input(\"Which city would you like to look at? Chicago, New York, or Washington? \\n\").lower()\n\n if city in cities:\n break\n\n # get user input for month (all, january, february, ... , june)\n months = ('all', 'january', 'february', 'march', 'april', 'may', 'june')\n while True:\n month = (input(\"Which month would you like to look at? You can choose january through june. Or type 'all' for all of them\\n\")).lower()\n\n if month in months:\n break\n\n # get user input for day of week (all, monday, tuesday, ... sunday)\n days = ('all', 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday')\n while True:\n day = (input(\"Which day would you like to select? Type in the name of the day or all to select all days. \\n\")).lower()\n\n if day in days:\n break\n\n print('-'*40)\n return city, month, day","def printNameAndAge(name: str, age: int) -> None:\n print(f\"Name: {name} and age: {age}\")","def AllCountries():\n print(\"TOUS LES PAYS\\n\")\n for x in countries:\n nom = countries[x]['name']\n capital = countries[x]['capital']\n continent = countries[x]['location']\n independance = countries[x]['independance']\n president = countries[x]['president']\n langue = countries[x]['langue']\n superficie = countries[x]['superficie']\n haditant = countries[x]['population']\n pib = countries[x]['pib']\n\n print(f\"Nom ==> {nom}\")\n print(f\"Capital ==> {capital}\")\n print(f\"Continent ==> {continent}\")\n print(f\"Date Independance ==> {independance}\")\n print(f\"Nom President Actuel ==> {president}\")\n print(f\"Langue Offielle ==> {langue}\")\n print(f\"Superficie ==> {superficie}\")\n print(f\"Nombre d'habitants ==> {haditant}\")\n print(f\"PIB ==> {pib}\")","def main():\n word = input(\"Give me a word! \\n\\n\")\n vowels = ['a', 'e', 'i', 'o', 'u']\n if word[0].lower() in vowels:\n print(f\"\\n\\nPig latin: {word}way\")\n else:\n print(f\"\\n\\nPig latin: {word[1:]}{word[0]}ay\")","def test_addr_country_good_values(self):\n for input_val, output_val in self.known_values:\n self.line._parse_addr_country(input_val)\n self.assertEqual(output_val, self.line.addr_country)"],"string":"[\n \"def city_country(city, country):\\n print(f'\\\"{city.title()}, {country.title()}\\\"\\\\n')\",\n \"def describe_city(city, country='canada'):\\n print(f\\\"{city.title()} is in {country.title()}.\\\")\",\n \"def describe_city(city, country='Germany'):\\n\\tprint(f'{city.title()} is in {country.title()}.')\",\n \"def describe_city(name, country='united kingdom'):\\n print(f\\\"\\\\n{name.title()} is in {country.title()}.\\\")\",\n \"def describe_city(city, country='Japan'):\\n print(city.title() + \\\" is in \\\" + country.title() + \\\".\\\")\",\n \"def city_country(city, country):\\n place = f\\\"{city}, {country}\\\"\\n return place.title()\",\n \"def city_country(city, country, population):\\n output_string = f\\\"{city.title()}, {country.title()}\\\"\\n output_string += f\\\" -population {population}\\\"\\n return output_string\",\n \"def city_country(city, country):\\n c_c = '\\\"' + city + \\\", \\\" + country + '\\\"'\\n return c_c.title()\",\n \"def city_country(city, country):\\n city_and_country = city + ', ' + country\\n return city_and_country.title()\",\n \"def city_country(city, country):\\n return city.title() + \\\", \\\" + country.title()\",\n \"def city_country(city, country):\\n return f\\\"{city.title()}, {country.title()}\\\"\",\n \"def city_country(city, country):\\n return f\\\"{city.title()}, {country.title()}\\\"\",\n \"def city_country(city, country):\\r\\n\\treturn(city.title() + ', ' + country.title())\",\n \"def city_country(city, country):\\n full_city = city + \\\", \\\" + country\\n return full_city.title()\",\n \"def city_country(city, country):\\n return(city.title() + \\\", \\\" + country.title())\",\n \"def city_country(city, country):\\n pair = f\\\"{city.title()}, {country.title()}\\\"\\n return pair\",\n \"def city_country(city_name, country_name):\\n combi = f\\\"{city_name.title()}, {country_name.title()}\\\"\\n return combi.title()\",\n \"def city_names(city, country):\\n place = f\\\"{city}, {country}\\\"\\n return place.title()\",\n \"def city_country(city_name, country):\\n formatted_string = f\\\"{city_name.title()}, {country.title()}\\\"\\n return formatted_string\",\n \"def city_country(city, country):\\n return(city + ', ' + country)\",\n \"def city_country(city, country):\\n formatted_city_country = city.title() + \\\", \\\" + country.title() + \\\".\\\"\\n return formatted_city_country\",\n \"def city_country(city_name, country_name):\\n city_country_combo = city_name + ', ' + country_name\\n return city_country_combo.title()\",\n \"def city_country(city, country, population=0):\\n if population:\\n formatted_city_country = city.title() + \\\", \\\" + country.title() + \\\" - \\\"\\n formatted_city_country += \\\"population \\\" + str(population)\\n else:\\n formatted_city_country = city.title() + \\\", \\\" + country.title()\\n return formatted_city_country\",\n \"def get_city_country(city, country, population=''):\\n if population:\\n location = city + ' ' + country + ' ' + str(population)\\n return location.title()\\n\\n else:\\n location = city + ' ' + country\\n return location.title()\",\n \"def get_city_country(city, country, population=''):\\n if population:\\n city_country = f\\\"{city}, {country} - population {population}\\\"\\n else:\\n city_country = f\\\"{city}, {country}\\\"\\n return city_country.title()\",\n \"def get_formatted_location(city, country):\\n\\tformatted_location = city + \\\", \\\" + country\\n\\treturn formatted_location.title()\",\n \"def city_location(city, country, population = None):\\n if population:\\n full_str = f\\\"{city.title()}, {country.title()} - population {population}\\\"\\n else:\\n full_str = f\\\"{city.title()}, {country.title()}\\\"\\n return full_str\",\n \"def get_formatted_place(city, country):\\n place = f\\\"{city} {country}\\\"\\n return place.title()\",\n \"def get_location(city, country, population=\\\"\\\"):\\n\\tdetails = city.title() + \\\", \\\" + country.title()\\n\\t#if population is specified i.e. not default value, append\\n\\tif population:\\n\\t\\tdetails += \\\" - population \\\" + str(population)\\n\\t#in either case, return details\\n\\treturn details\",\n \"def test_city_country(self):\\n formatted_city = get_full_city(\\\"santiago\\\", \\\"chile\\\")\\n self.assertEqual(formatted_city, \\\"Santiago, Chile\\\")\",\n \"def test_city_country(self):\\n formatted_name = city_country('santiago', 'chile')\\n self.assertEqual(formatted_name, 'Santiago, Chile')\",\n \"def test_city_country(self):\\n\\t\\tformatted_address = city_country('santiago', 'chile')\\n\\t\\tself.assertEqual(formatted_address, 'Santiago, Chile')\",\n \"def get_formatted_city(city, country, population=None):\\n if population:\\n city_country = f\\\"{city.title()}, {country.title()} - population {population}.\\\"\\n else:\\n city_country = f\\\"{city.title()}, {country.title()}.\\\"\\n\\n return city_country\",\n \"def country() -> str:\",\n \"def _get_countries():\\n print('-c, -C [country]\\\\\\n \\\\n [country]=\\\\\\n \\\\n AR\\\\t: Argentina\\\\\\n \\\\n AT\\\\t: Austria\\\\\\n \\\\n BR\\\\t: Brazil\\\\\\n \\\\n BY\\\\t: Belarus\\\\\\n \\\\n CA\\\\t: Canda\\\\\\n \\\\n DE\\\\t: Germany\\\\\\n \\\\n FR\\\\t: France\\\\\\n \\\\n GB\\\\t: Great Britain\\\\\\n \\\\n GH\\\\t: Ghana\\\\\\n \\\\n HU\\\\t: Hungary\\\\\\n \\\\n ID\\\\t: Indonesia\\\\\\n \\\\n IL\\\\t: Israel\\\\\\n \\\\n JP\\\\t: Japan\\\\\\n \\\\n KR\\\\t: Korea\\\\\\n \\\\n MA\\\\t: Morocco\\\\\\n \\\\n MY\\\\t: Malaysia\\\\\\n \\\\n NL\\\\t: Netherlands\\\\\\n \\\\n NO\\\\t: Norway\\\\\\n \\\\n OM\\\\t: Oman\\\\\\n \\\\n PK\\\\t: Pakistan\\\\\\n \\\\n RU\\\\t: Russia\\\\\\n \\\\n SA\\\\t: Saudi Arabia\\\\\\n \\\\n TH\\\\t: Thailand\\\\\\n \\\\n TW\\\\t: Taiwan\\\\\\n \\\\n UA\\\\t: Ukraine\\\\\\n \\\\n US\\\\t: United States\\\\\\n \\\\n UY\\\\t: Uruguay\\\\\\n \\\\n VE\\\\t: Venezuela\\\\\\n \\\\n VN\\\\t: Vietnam\\\\\\n \\\\n .....\\\\n common usage: opengate -c JP')\",\n \"def test_city_country(self):\\n santiago_chile = get_city_name('santiago', 'chile')\\n self.assertEqual(santiago_chile, 'Santiago, Chile')\",\n \"def test_city_country(self):\\n santiago_chile = city_country('santiago', 'chile')\\n self.assertEqual(santiago_chile, 'Santiago, Chile')\",\n \"def test_city_country(self):\\n santiago_chile = city_country('santiago', 'chile')\\n self.assertEqual(santiago_chile, 'Santiago, Chile')\",\n \"def test_city_country(self):\\n santiago_chile = city_country('santiago', 'chile')\\n self.assertEqual(santiago_chile, 'Santiago, Chile')\",\n \"def get_city_country(city, country, population=''):\\n\\tif population:\\n\\t\\tcity_country = city.title() + ', ' + country.title() + \\\" - population \\\" + str(population)\\n\\telse:\\n\\t\\tcity_country = city.title() + ', ' + country.title()\\n\\treturn city_country\",\n \"def test_city_country(self):\\n dublin_ireland = city_country('dublin', 'ireland')\\n self.assertEqual(dublin_ireland, 'Dublin, Ireland')\",\n \"def print_cities() -> None:\\n city_list = get_cities()\\n i = 1\\n for a,b,c,d,e in zip(city_list[::5], city_list[1::5], city_list[2::5], city_list[3::5], city_list[4::5]):\\n a = str(i) + f\\\".{a}\\\"\\n i += 1\\n b = str(i) + f\\\".{b}\\\"\\n i += 1\\n c = str(i) + f\\\".{c}\\\"\\n i += 1\\n d = str(i) + f\\\".{d}\\\"\\n i += 1\\n e = str(i) + f\\\".{e}\\\"\\n i += 1\\n if e == '410.youngstown':\\n print(\\\"{:<20}{:<20}{:<20}{:<20}{:<}\\\".format(a,b,c,d,e))\\n a = str(i) + f\\\".{city_list[i-1]}\\\"\\n b = str(i+1) + f\\\".{city_list[i]}\\\"\\n i += 1\\n c = c = str(i+1) + f\\\".{city_list[i]}\\\"\\n print(\\\"{:<20}{:<20}{:<}\\\".format(a,b,c))\\n else:\\n print(\\\"{:<20}{:<20}{:<20}{:<20}{:<}\\\".format(a,b,c,d,e))\",\n \"def test_city_country(self):\\n formatted_name = make_formatted_name('santiago', 'chile')\\n self.assertEqual(formatted_name, 'Santiago, Chile')\",\n \"def Raw_Data(city,month,day):\\n print(\\\"The city you have entered is: \\\",city)\\n print(\\\"The month you have entered is: \\\",month)\\n print(\\\"The day you have entered is: \\\",day)\",\n \"def test_city_country_population(self):\\n\\t\\tformatted_address = city_country(\\n\\t\\t\\t'santiago', 'chile', '5000000')\\n\\t\\tself.assertEqual(formatted_address, \\n\\t\\t\\t'Santiago, Chile - Population 5000000')\",\n \"def get_state_info(city, state, population=''):\\n if population:\\n city_info = city + ' ' + state + ' - ' + population\\n city_info.title()\\n else:\\n city_info = city + ' ' + state\\n city_info.title()\\n return city_info\",\n \"def get_city_info(g, city_name):\\n flag = 0\\n for key in g.city_dict:\\n if(g.city_dict[key].get_name() == city_name):\\n print g.city_dict[key].get_info()\\n flag = 1\\n \\n if(flag == 0):\\n print (\\\"Invalid Input\\\")\",\n \"def test_city_country_population(self):\\n your_location = location_name(\\\"lviv\\\", \\\"ukraine\\\", \\\"123\\\")\\n self.assertEqual(your_location, \\\"Lviv, Ukraine - Population 123\\\")\",\n \"def test_city_country_population(self):\\n formatted_name = make_formatted_name('santiago', 'chile', 5000000)\\n self.assertEqual(formatted_name, 'Santiago, Chile - population 5000000')\",\n \"def test_city_country_population(self):\\n santiago_chile = get_city_name('santiago', 'chile','5000000')\\n self.assertEqual(santiago_chile, 'Santiago, Chile - population 5000000')\",\n \"def select_city():\\r\\n city = input('Enter the city name for which you want to explore BikeShare data.'\\r\\n 'Would you like to see data for Chicago, New York, or Washington?\\\\n').title()\\r\\n if city.lower() == 'chicago' or city.lower() == 'c':\\r\\n\\r\\n return \\\"chicago\\\"\\r\\n\\r\\n elif city.lower() == 'new york' or city.lower() == 'n':\\r\\n\\r\\n return \\\"new york\\\"\\r\\n\\r\\n elif city.lower() == 'washington' or city.lower() == 'w':\\r\\n\\r\\n return \\\"washington\\\"\\r\\n\\r\\n else:\\r\\n\\r\\n print(\\\"\\\\nI'm sorry, I'm not sure which city you're referring to. Let's try again.\\\")\\r\\n\\r\\n return select_city()\",\n \"def city():\\n\\n print(\\\"Welcome to my weather API\\\")\\n\\n yourcity = input(\\\"Enter A known City name: \\\")\\n api_key = (\\\"077936f695f61908cd19a5a2452a97fb\\\") \\n #our public Api-key \\n response = requests.get(\\\"http://api.openweathermap.org/data/2.5/weather?q={0}&appid=077936f695f61908cd19a5a2452a97fb\\\".format(yourcity, api_key)) #api call\\n weather = response.json()\\n print(\\\"The current weather in {0} is {1}\\\".format(yourcity, weather[\\\"weather\\\"][0][\\\"description\\\"])) #the result\",\n \"def _build_city(db, place):\\n location = get_main_location(db, place)\\n county = location.get(PlaceType.COUNTY)\\n # Build a title description string that will work for Eniro\\n city_descr = _build_area(db, place)\\n if county:\\n city_descr += ', ' + county\\n return _strip_leading_comma(city_descr)\",\n \"def to_location(city: str = None, state: str = None) -> str:\\n if city is None and state is None:\\n return \\\"USA\\\"\\n elif city is None or state is None:\\n return f\\\"{city or ''}{state or ''}, USA\\\"\\n return f\\\"{city}, {state} USA\\\"\",\n \"def day_009_2():\\n travel_log = [\\n {\\n \\\"country\\\": \\\"France\\\",\\n \\\"visits\\\": 12,\\n \\\"cities\\\": [\\\"Paris\\\", \\\"Lille\\\", \\\"Dijon\\\"]\\n },\\n {\\n \\\"country\\\": \\\"Germany\\\",\\n \\\"visits\\\": 5,\\n \\\"cities\\\": [\\\"Berlin\\\", \\\"Hamburg\\\", \\\"Stuttgart\\\"]\\n },\\n ]\\n\\n def add_new_country(country, visits, cities):\\n # Add new information to the travel log\\n travel_log.append({\\\"country\\\": country, \\\"visits\\\": visits, \\\"cities\\\": cities})\\n\\n # Print the new information in readable syntax.\\n print(f\\\"You've visited {country} {visits} times.\\\")\\n\\n # Assemble readable output for the list using commas, 'and', and a period.\\n output_string = \\\"\\\"\\n num_cities = len(cities)\\n for city in cities:\\n if num_cities == len(cities):\\n # If this is our first city, just add it to the output string.\\n output_string = city\\n elif num_cities > 1:\\n # If this is not the first city OR the last city, add it with a comma.\\n output_string = output_string + f\\\", {city}\\\"\\n else:\\n # If this is our last city, use the word 'and' and end with a period.\\n output_string = output_string + f\\\" and {city}.\\\"\\n num_cities = num_cities - 1\\n # Print the cities added to the travel log\\n print(f\\\"You've been to {output_string}\\\")\\n\\n add_new_country(\\\"Russia\\\", 2, [\\\"Moscow\\\", \\\"Saint Petersburg\\\"])\\n print(travel_log)\",\n \"def main(city: str, language: str, interval: str):\\n data = get_weather_info(city, language, interval)\\n pretty_print(data)\",\n \"def description(self):\\n\\t\\treturn \\\"%s, %s\\\" % (self.name, self.country)\",\n \"def test_city_country(self):\\n your_location = location_name(\\\"lviv\\\", \\\"ukraine\\\")\\n self.assertEqual(your_location, \\\"Lviv, Ukraine\\\")\",\n \"def test_city_country_population(self):\\n \\tdublin_ireland = city_country('dublin', 'ireland', population=500000)\\n \\tself.assertEqual(dublin_ireland, 'Dublin, Ireland - Population 500000')\",\n \"def name():\\n fname = input(\\\"Enter your first name:\\\")\\n lname = input(\\\"Enter your last name:\\\")\\n city = input(\\\"Enter the city you live in:\\\")\\n state = input(\\\"Enter the state you live in:\\\")\\n\\n fullname = fname+ \\\" \\\"+ lname\\n city_state = city +\\\", \\\" +state\\n print(\\\"Your name is:\\\",fullname)\\n print(\\\"You live in:\\\",city_state)\",\n \"def print_data(**kwargs):\\n return f'Имя: {kwargs.get(\\\"name\\\")}, Фамилия: {kwargs.get(\\\"surname\\\")}, Год рождения: {kwargs.get(\\\"birth_year\\\")},' \\\\\\n f' Город проживания: {kwargs.get(\\\"city\\\")}, Адрес эл. почты: {kwargs.get(\\\"email\\\")},' \\\\\\n f' Номер телефона: {kwargs.get(\\\"phone\\\")}.'\",\n \"def convert_country(country):\\n if (country and 'China' in country) or \\\\\\n country == 'Chin' or country == 'CHINA':\\n country = 'China'\\n elif country and 'Brazil' in country or \\\\\\n country == 'Brasil' or \\\\\\n country == 'ITA - Instituto Tecnologico de Aeronautica (':\\n country = 'Brazil'\\n elif country and 'Argentina' in country:\\n country = 'Argentina'\\n elif country == 'Czechia':\\n country = 'Czech Republic'\\n elif 'Norwegian' in country:\\n country = 'Norway'\\n elif country and 'United Kingdom' in country:\\n country = 'United Kingdom'\\n elif country and 'Hong Kong' in country:\\n country = 'Hong Kong'\\n elif country == 'Cameroun':\\n country = 'Cameroon'\\n elif (country and 'Chile' in country) or country == 'CHILE':\\n country = 'Chile'\\n elif (country and 'United States of America' in \\\\\\n country) or country == 'United States' or country \\\\\\n == 'USA' or 'Florida' in country or \\\\\\n 'California' in country or\\\\\\n country == 'National Reference Centre for' or \\\\\\n country == 'United State of America' or \\\\\\n country == 'U.S.A.' or \\\\\\n country == 'Virginia':\\n country = 'United States of America'\\n elif country=='Republic of Panamá' or country=='Panamá' or 'Panama' in country:\\n country = 'Panama'\\n elif 'Canada' in country:\\n country = 'Canada'\\n elif 'Colombia' in country:\\n country = 'Colombia'\\n elif 'Spain' in country or country=='España':\\n country = 'Spain'\\n elif 'Iran' in country:\\n country = 'Iran'\\n elif 'Saudi Arabia' in country:\\n country = 'Saudi Arabia'\\n elif 'Italy' in country:\\n country = 'Italy'\\n elif 'Japan' in country:\\n country = 'Japan'\\n elif 'Germany' in country:\\n country = 'Germany'\\n elif 'Luxembourg' in country:\\n country = 'Luxembourg'\\n elif ('France' in country) or country == 'Marseille':\\n country = 'France'\\n elif country == 'ROC' or country == 'R. O. C':\\n country = 'Taiwan'\\n elif country == 'Brasil':\\n country = 'Brazil'\\n elif country == 'México' or 'Mexico' in country:\\n country = 'Mexico'\\n elif 'Slowakia' in country:\\n country = 'Slowakia'\\n elif country == 'Korea' or 'Republic of Korea' in country:\\n country = 'South Korea'\\n elif country == 'United Kindgom':\\n country = 'United Kingdom'\\n elif country and 'Netherlands' in country:\\n country = 'Netherlands'\\n elif country == 'Commonwealth of Australia' or 'Australia' in country:\\n country = 'Australia'\\n elif 'Singapore' in country:\\n country = 'Singapore'\\n elif country and (country[0].isdigit() or country[0] == '+'):\\n country = 'N/A'\\n return country\",\n \"def audience_simple(country):\\r\\n if country == 'US':\\r\\n return 'USA'\\r\\n elif country == 'IN':\\r\\n return 'India'\\r\\n else:\\r\\n return 'Other'\",\n \"def test_single_word_boston(self):\\n result = location.lookup_location('Boston GB')\\n\\n self.assertEqual(result['country'], 'GB')\",\n \"def get_country_details(self,country):\\n try:\\n country_obj = pycountry.countries.get(name=country)\\n if country_obj is None:\\n c = pycountry.countries.search_fuzzy(country)\\n country_obj = c[0]\\n continent_code = pc.country_alpha2_to_continent_code(country_obj.alpha_2)\\n continent = pc.convert_continent_code_to_continent_name(continent_code)\\n return country_obj.alpha_3, continent\\n except:\\n if 'Congo' in country:\\n country = 'Congo'\\n elif country == 'Diamond Princess' or country == 'Laos' or country == 'MS Zaandam' or country == 'Holy See' or country == 'Timor-Leste':\\n return country, country\\n elif country == 'Korea, South' or country == 'South Korea':\\n country = 'Korea, Republic of'\\n elif country == 'Taiwan*':\\n country = 'Taiwan'\\n elif country == 'Burma':\\n country = 'Myanmar'\\n elif country == 'West Bank and Gaza':\\n country = 'Gaza'\\n else:\\n return country, country\\n country_obj = pycountry.countries.search_fuzzy(country)\\n continent_code = pc.country_alpha2_to_continent_code(country_obj[0].alpha_2)\\n continent = pc.convert_continent_code_to_continent_name(continent_code)\\n return country_obj[0].alpha_3, continent\",\n \"def countryInput(self, prompt):\\n while True:\\n name = input(prompt)\\n if name not in self.travel_db.countries:\\n print(\\\"Invalid country name. Please make sure name is capitalized.\\\")\\n else:\\n return name\",\n \"def print_cities(road_map): \\n\\n print('*** THE ORIGINAL MAP (TOTAL DISTANCE {}) ***'.format(compute_total_distance(road_map)))\\n print('')\\n for i, location in enumerate(road_map):\\n try:\\n print('- {}, {}: ({},{})'.format(location[1], \\\\\\n location[0], round(location[2],1), round(location[3],1)))\\n except Exception as e:\\n print('Error with print_cities: '+str(e))\\n print('____________________________________________________________________')\\n print('')\",\n \"def func(self):\\n account = self.account\\n city_name = 'Phoenix' if not self.args else self.args\\n a = Astral()\\n a.solar_depression = 'civil'\\n city = a[city_name]\\n if not city:\\n return\\n timezone = city.timezone\\n sun = city.sun(date=datetime.date.today(), local=True)\\n\\n account.msg('Information for %s/%s\\\\n' % (city_name, city.region))\\n account.msg('Timezone: %s' % timezone)\\n account.msg('Latitude: %.02f; Longitude: %.02f' % (city.latitude, city.longitude))\\n account.msg('Dawn: %s' % str(sun['dawn']))\\n account.msg('Sunrise: %s' % str(sun['sunrise']))\\n account.msg('Noon: %s' % str(sun['noon']))\\n account.msg('Sunset: %s' % str(sun['sunset']))\\n account.msg('Dusk: %s' % str(sun['dusk']))\",\n \"def get_human_readable_choice(city, month, day):\\n current_data_string = \\\"You have selected to view data from \\\" + CITIES[city].title()\\n if month != 0:\\n current_data_string += \\\" in \\\" + MONTHS[month].title()\\n\\n if day != 7:\\n current_data_string += \\\" on a \\\" + DAY_OF_WEEK[day].title()\\n\\n return current_data_string\",\n \"def get_country_info(country):\\n return GoogleV3().geocode(country)\",\n \"def GetCityByUser():\\n City = str(input())\\n if (City == \\\"\\\"):\\n exit()\\n Weather = GetWeatherByCity(City)\\n print(\\\"The weather in \\\" + City + \\\" is:\\\\n\\\")\\n PrintWeather(Weather) \\n return 1\",\n \"def get_weather_report():\\n try:\\n lat, long = None, None\\n option = input(\\\"Get weather report of City \\\\n1.Select from database \\\\n2.Enter manually\\\\n\\\")\\n if option == '1':\\n lat, long = get_by_city()\\n elif option == '2':\\n lat, long = get_by_altitute()\\n print(\\\"~~~~~~~~~~~~~~~~~~~~~~~Getting the weather report for the city~~~~~~~~~~~~~~~~~~~~\\\")\\n response = requests.get(BASE_URL.format(lat, long, API_KEYS), verify=True)\\n print(json.dumps(json.loads(response.text), indent=4))\\n except ValueError:\\n print(\\\"Select correct option.\\\")\",\n \"def test_single_word_exeter(self):\\n result = location.lookup_location('Exeter GB')\\n\\n self.assertEqual(result['country'], 'GB')\",\n \"def get_city_from_user():\\n while True:\\n city = input('Select the city you want to explore. \\\\n1. Chicago\\\\n2. New york city\\\\n3. Washington\\\\n Press 1,'\\n '2 or 3 to select the city: ')\\n\\n if city in VALID_CITIES.keys():\\n confirm = input(\\\"You have selected {}. Press 'y' to confirm: \\\".format(VALID_CITIES[city]))\\n\\n if confirm == 'y':\\n break\\n else:\\n print(\\\"Try again.\\\\n\\\")\\n else:\\n print(\\\"Invalid input: {}. Try again.\\\\n\\\".format(city))\\n return city\",\n \"def return_city(n):\\n if n == 1:\\n return \\\"San Francisco\\\"\\n elif n == 2:\\n return \\\"Los Angeles\\\"\\n elif n == 3:\\n return \\\"Las Vegas\\\"\\n elif n == 4:\\n return \\\"Portland\\\"\\n elif n == 5:\\n return \\\"San Diego\\\"\\n else:\\n return \\\"Seattle\\\"\",\n \"def take_input():\\r\\n from_country = input(\\\"From Country: \\\")\\r\\n to_country = input(\\\"TO Country: \\\")\\r\\n amount = float(input(\\\"Amount: \\\"))\\r\\n return from_country, to_country, amount\",\n \"def get_filters():\\n print('Hello! Let\\\\'s explore some US bikeshare data!')\\n # get user input for city (chicago, new york city, washington). \\n # ask user to determine city \\n \\n while True:\\n city = input(\\\"choose city you want to explore from ('chicago', 'new york city', 'washington')\\\")\\n if city.lower()in ['chicago', 'new york city', 'washington']:\\n break\\n else:\\n print(\\\"{} invalid input\\\".format(city))\\n \\n \\n \\n # get user input for month (all, january, february, ... , june)\\n while True:\\n month = input(\\\"choose the month you want to explore from ('jan','feb','mar','apr','may','jun','all')\\\")\\n if month.lower()in['jan','feb','mar','apr','may','jun','all']:\\n break \\n else:\\n print(\\\"{}invalid input\\\".format(month))\\n \\n \\n # get user input for day of week (all, monday, tuesday, ... sunday)\\n while True:\\n day = input(\\\"choose the day you want to explore from ('saturday','sunday','monday','tuesday','wednesday','thursday','friday','all')\\\")\\n if day.lower() in ['saturday','sunday','monday','tuesday','wednesday','thursday','friday','all']:\\n break\\n else:\\n print(\\\"{}invalid input\\\".format(day))\\n \\n \\n\\n\\n print('-'*40)\\n return city.lower(), month.lower(), day.lower()\",\n \"async def countryinfo_command(self, ctx, *, countryname: str):\\n async with aiohttp.ClientSession() as session:\\n async with session.get(\\n f\\\"https://restcountries.eu/rest/v2/name/{countryname}\\\"\\n ) as resp:\\n info = await resp.json()\\n countryName = info[0][\\\"name\\\"]\\n topLevelDomainn = info[0][\\\"topLevelDomain\\\"]\\n topLevelDomain = \\\",\\\".join(topLevelDomainn)\\n alpha2Code = info[0][\\\"alpha2Code\\\"]\\n callingCodesList = info[0][\\\"callingCodes\\\"]\\n callingCodes = \\\",\\\".join(callingCodesList)\\n capital = info[0][\\\"capital\\\"]\\n region = info[0][\\\"region\\\"]\\n population = info[0][\\\"population\\\"]\\n nativeName = info[0][\\\"nativeName\\\"]\\n timeZonesList = info[0][\\\"timezones\\\"]\\n timeZones = \\\",\\\".join(timeZonesList)\\n currencies = info[0][\\\"currencies\\\"]\\n currency_code = currencies[0][\\\"code\\\"]\\n currency_symbol = currencies[0][\\\"symbol\\\"]\\n alternativeSpellingsList = info[0][\\\"altSpellings\\\"]\\n alternativeSpellings = \\\",\\\".join(alternativeSpellingsList)\\n\\n embed = Embed(\\n color=Color.blurple(),\\n timestamp=datetime.utcnow(),\\n description=f\\\"**Name** - {countryName}\\\\n**Top Level Domain** - {topLevelDomain}\\\\n**Alpha2 Code** - {alpha2Code}\\\\n**Calling Codes** - {callingCodes}\\\\n**Capital** - {capital}\\\\n **Region** - {region}\\\\n**Population** - {population}\\\\n**Native Name** - {nativeName}\\\\n**Time Zones** - {timeZones}\\\\n**Currency Code** - {currency_code}\\\\n**Currency Symbol** - {currency_symbol}\\\\n**Alternative Spellings** - {alternativeSpellings}\\\",\\n )\\n embed.set_author(name=f\\\"Info of {countryName}\\\")\\n embed.set_thumbnail(\\n url=f\\\"https://flagcdn.com/w80/{str(alpha2Code).lower()}.png\\\"\\n )\\n embed.set_footer(text=f\\\"Requested by {ctx.author}\\\")\\n await ctx.send(embed=embed)\",\n \"def get_by_city():\\n while True:\\n try:\\n for key in CITY_DICT:\\n print(key)\\n city = input(\\\"Enter city name: \\\")\\n lat, long = CITY_DICT.get(city.capitalize())\\n return lat, long\\n except TypeError:\\n print(\\\"~\\\" * 50)\\n print(\\\"Please enter the city name correctly\\\")\",\n \"def GetCity():\\n IPinfoRequest = requests.get('https://ipinfo.io/')\\n IPinfo = IPinfoRequest.json()\\n City = IPinfo['city']\\n return(City)\",\n \"def get_filters():\\n\\n cities = CITY_DATA.keys()\\n months = ('all', 'january', 'february','march', 'april', 'may', 'june')\\n days = ('all', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday')\\n print('Hello! Let\\\\'s explore some US bikeshare data!')\\n\\n # TO DO: get user input for city (chicago, new york city, washington). HINT: Use a while loop to handle invalid inputs\\n city_name= \\\"chicago, new york city or washington\\\"\\n while True:\\n city = input('Which city would you like to view:{}?\\\\n'.format(city_name)).lower()\\n if city not in cities:\\n print('Invalid response, please try again.')\\n continue\\n else:\\n break\\n\\n # TO DO: get user input for month (all, january, february, ... , june)\\n month_list=\\\"all, january, february, march, april, may or june\\\"\\n while True:\\n month = input('Which month would you like to view: {}?\\\\n'.format(month_list)).lower()\\n if month not in months:\\n print('Invalid response, please try again.')\\n continue\\n else:\\n break\\n\\n # TO DO: get user input for day of week (all, monday, tuesday, ... sunday)\\n week_days= \\\"all, monday, tuesday, wednesday, thursday, friday, saturday or sunday\\\"\\n while True:\\n day = input('Which day of the week would you like to view:{}?\\\\n'.format(week_days)).lower()\\n if day not in days:\\n print('Invalid response, please try again.')\\n continue\\n else:\\n break\\n\\n print('-'*40)\\n return city, month, day\",\n \"def hometown_greeting(hometown, first_name, last_name):\\n\\n\\tif is_hometown(hometown):\\n\\t\\tprint \\\"Hi \\\" + full_name(first_name, last_name) + \\\", we're from the same place!\\\"\\n\\telse:\\n\\t\\tprint \\\"Hi \\\" + full_name(first_name, last_name) + \\\", where are you from?\\\"\",\n \"def test_single_word_swanage(self):\\n result = location.lookup_location('Swanage GB')\\n\\n self.assertEqual(result['country'], 'GB')\",\n \"def filter_city(input_city: str) -> str:\\n # input_city = string.capwords(input_city.lower())\\n result = filterString(input_city).cities\\n return result\",\n \"def show_sample_city (city_record):\\n sample = copy.deepcopy(city_record)\\n data = xpath(sample, 'data' )\\n data[1:] = [ '... other similar dicts ...']\\n pprint.pprint (sample)\",\n \"def get_filters():\\n print('Hello! Let\\\\'s explore some US bikeshare data!')\\n\\n city = get_city_from_user()\\n print('-' * 10)\\n\\n # get user input for month (all, january, february, ... , june)\\n month = get_month_from_user()\\n print('-' * 10)\\n\\n # get user input for day of week (all, monday, tuesday, ... sunday)\\n day = get_day_of_week_from_user()\\n print('-' * 40)\\n return city, month, day\",\n \"def print_cities(g):\\n cities = []\\n for key in g.city_dict:\\n cities.append(g.city_dict[key].get_name())\\n return cities\",\n \"def searchCountry(host):\\n process = subprocess.Popen(\\\"geoiplookup \\\"+host,stdout=subprocess.PIPE, shell=True)\\n (output, err) = process.communicate()\\n secondPart = output.split(\\\"GeoIP Country Edition: \\\", 1)[1]\\n country = secondPart.split(\\\"\\\\nGeoIP City Edition\\\", 1)[0]\\n return country\",\n \"def check_born_place(input_string: str) -> tuple:\\n c = input_string[0]\\n if c == 'A':\\n return 'Taipei City', 10\\n elif c == 'B':\\n return 'Taichung City', 11\\n elif c == 'C':\\n return 'Keelung City', 12\\n elif c == 'D':\\n return 'Tainan City', 13\\n elif c == 'E':\\n return 'Kaohsiung City', 14\\n elif c == 'F':\\n return 'New Taipei City', 15\\n elif c == 'G':\\n return 'Yilan County', 16\\n elif c == 'H':\\n return 'Taoyuan City', 17\\n elif c == 'I':\\n return 'Chiayi City', 34\\n elif c == 'J':\\n return 'Hsinchu County', 18\\n elif c == 'K':\\n return 'Miaoli County', 19\\n elif c == 'L':\\n return 'Taichung County', 20\\n elif c == 'M':\\n return 'Nantou County', 21\\n elif c == 'N':\\n return 'Changhua County', 22\\n elif c == 'O':\\n return 'Hsinchu City', 35\\n elif c == 'P':\\n return 'Yunlin County', 23\\n elif c == 'Q':\\n return 'Chiayi County', 24\\n elif c == 'R':\\n return 'Tainan County', 25\\n elif c == 'S':\\n return 'Kaohsiung County', 26\\n elif c == 'T':\\n return 'Pingtung County', 27\\n elif c == 'U':\\n return 'Hualien County', 28\\n elif c == 'V':\\n return 'Taitung County', 29\\n elif c == 'W':\\n return 'Kinmen County', 32\\n elif c == 'X':\\n return 'Penghu County', 30\\n elif c == 'Y':\\n return 'Yangmingshan Management Bureau', 31\\n elif c == 'Z':\\n return 'Lienchiang County', 33\\n else:\\n # Should not happen\\n return None, None # The return value is a tuple containing two values\",\n \"def get_filters():\\n print('Hello! Let\\\\'s explore some US bikeshare data!')\\n\\n while True:\\n city = input('Are you from Washington, New York City or Chicago: ').lower()\\n if city in cities:\\n break\\n print('You selected: ', city)\\n#fixed the missing loop and case sensitivity in 'month' and 'day' input\\n while True:\\n month = input('Which month would you like to filter, choose \\\"all\\\" if you do not want to filter: ').lower()\\n if month in months:\\n break\\n print('You selected')\\n\\n while True:\\n day = input('Which day would you like to filter, choose \\\"all\\\" if you do not want to filter: ').lower()\\n if day in days:\\n break\\n\\n print('-'*40)\\n return city, month, day\",\n \"def test_addr_city_good_values(self):\\n for input_val, output_val in self.known_values:\\n self.line._parse_addr_city(input_val)\\n self.assertEqual(output_val, self.line.addr_city)\",\n \"def ad_rep_city_state(obj):\\n return '%s, %s' % (obj.ad_rep.geolocation_object.us_city.name,\\n obj.ad_rep.geolocation_object.us_state.abbreviation)\",\n \"def get(world, country, json):\\n if world:\\n dt = data.get_global_data()\\n pretty_print(dt, json)\\n if country:\\n dt = data.get_country_data(country)\\n pretty_print(dt, json)\",\n \"def get_filters():\\n print('Hello! Let\\\\'s explore some US bikeshare data!')\\n # TO DO: get user input for city (chicago, new york city, washington). HINT: Use a while loop to handle invalid inputs\\n while True:\\n city = input(\\\"Enter the city name: \\\").lower()\\n if city not in ('chicago', 'new york city', 'washington'):\\n print('Not found the city name. Try again!')\\n continue\\n else:\\n break\\n \\n # TO DO: get user input for month (all, january, february, ... , june)\\n while True:\\n month = input(\\\"Enter the month: \\\").lower()\\n if month not in ('january', 'february', 'march', 'april', 'may', 'june', 'all'):\\n print('Not found the month')\\n continue\\n else:\\n break\\n \\n # TO DO: get user input for day of week (all, monday, tuesday, ... sunday)\\n while True:\\n day = input('Enter the day: ').lower()\\n if day not in ('monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday'):\\n print('Not found the day')\\n continue\\n else:\\n break\\n \\n print('-'*40)\\n return city, month, day\",\n \"def get_filters():\\n print('Hello! Let\\\\'s explore some US bikeshare data!')\\n # TO DO: get user input for city (chicago, new york city, washington). HINT: Use a while loop to handle invalid inputs\\n cities= ['chicago','new york city','washington']\\n \\n while True:\\n city =input(\\\"Please Enter City: \\\").lower()\\n if city in cities:\\n break\\n else:\\n print(\\\"Please enter right input!\\\")\\n \\n # TO DO: get user input for month (all, january, february, ... , june)\\n months=['all','january','february','march','april','june']\\n \\n while True:\\n month=input(\\\"Please Enter month: \\\").lower()\\n if month in months:\\n break\\n else:\\n \\n print(\\\"Please enter right input!\\\")\\n\\n\\n # TO DO: get user input for day of week (all, monday, tuesday, ... sunday)\\n days=['all','monday','tuesday','wednesday','thursday','friday','saturday','sunday']\\n \\n while True:\\n \\n day=input(\\\"Please Enter Day: \\\").lower()\\n if day in days:\\n break\\n else:\\n print(\\\"Please enter right input!\\\")\\n\\n print('-'*40)\\n return city, month, day\",\n \"def get_filters():\\n print('Hello! Let\\\\'s explore some US bikeshare data!')\\n # get user input for city (chicago, new york city, washington). HINT: Use a while loop to handle invalid inputs\\n cities = ('chicago', 'new york', 'washington')\\n while True:\\n city = input(\\\"Which city would you like to look at? Chicago, New York, or Washington? \\\\n\\\").lower()\\n\\n if city in cities:\\n break\\n\\n # get user input for month (all, january, february, ... , june)\\n months = ('all', 'january', 'february', 'march', 'april', 'may', 'june')\\n while True:\\n month = (input(\\\"Which month would you like to look at? You can choose january through june. Or type 'all' for all of them\\\\n\\\")).lower()\\n\\n if month in months:\\n break\\n\\n # get user input for day of week (all, monday, tuesday, ... sunday)\\n days = ('all', 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday')\\n while True:\\n day = (input(\\\"Which day would you like to select? Type in the name of the day or all to select all days. \\\\n\\\")).lower()\\n\\n if day in days:\\n break\\n\\n print('-'*40)\\n return city, month, day\",\n \"def printNameAndAge(name: str, age: int) -> None:\\n print(f\\\"Name: {name} and age: {age}\\\")\",\n \"def AllCountries():\\n print(\\\"TOUS LES PAYS\\\\n\\\")\\n for x in countries:\\n nom = countries[x]['name']\\n capital = countries[x]['capital']\\n continent = countries[x]['location']\\n independance = countries[x]['independance']\\n president = countries[x]['president']\\n langue = countries[x]['langue']\\n superficie = countries[x]['superficie']\\n haditant = countries[x]['population']\\n pib = countries[x]['pib']\\n\\n print(f\\\"Nom ==> {nom}\\\")\\n print(f\\\"Capital ==> {capital}\\\")\\n print(f\\\"Continent ==> {continent}\\\")\\n print(f\\\"Date Independance ==> {independance}\\\")\\n print(f\\\"Nom President Actuel ==> {president}\\\")\\n print(f\\\"Langue Offielle ==> {langue}\\\")\\n print(f\\\"Superficie ==> {superficie}\\\")\\n print(f\\\"Nombre d'habitants ==> {haditant}\\\")\\n print(f\\\"PIB ==> {pib}\\\")\",\n \"def main():\\n word = input(\\\"Give me a word! \\\\n\\\\n\\\")\\n vowels = ['a', 'e', 'i', 'o', 'u']\\n if word[0].lower() in vowels:\\n print(f\\\"\\\\n\\\\nPig latin: {word}way\\\")\\n else:\\n print(f\\\"\\\\n\\\\nPig latin: {word[1:]}{word[0]}ay\\\")\",\n \"def test_addr_country_good_values(self):\\n for input_val, output_val in self.known_values:\\n self.line._parse_addr_country(input_val)\\n self.assertEqual(output_val, self.line.addr_country)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.856302","0.81208575","0.8088181","0.8051179","0.79706645","0.79012996","0.78986406","0.7809852","0.77355325","0.7704453","0.7686551","0.7686551","0.7685671","0.7684176","0.7679467","0.7600646","0.74408424","0.7436566","0.7406232","0.737946","0.73696256","0.7288805","0.71703255","0.70477754","0.7034143","0.69359523","0.69283473","0.6834192","0.6818097","0.6811115","0.67967874","0.6758067","0.67397124","0.671677","0.6663981","0.6365707","0.6346235","0.6346235","0.6346235","0.6278685","0.6265275","0.6259778","0.62575984","0.6220732","0.6139988","0.61112624","0.6075163","0.5971618","0.5968167","0.5962457","0.5960647","0.5840464","0.58066475","0.57821584","0.5770427","0.5761472","0.57478803","0.5747215","0.5701392","0.56947047","0.5692718","0.5626944","0.5625926","0.5613565","0.5610967","0.560093","0.556555","0.5564628","0.5544109","0.55397356","0.55387133","0.55341834","0.5510549","0.5507904","0.54947525","0.5490822","0.54777986","0.54566836","0.54468435","0.5429514","0.54190105","0.5398489","0.53946024","0.53898734","0.53886175","0.53835505","0.53798455","0.5374048","0.5367737","0.5351223","0.53482634","0.5338161","0.5333216","0.53260225","0.53219086","0.5313146","0.5311876","0.53038335","0.5293816","0.5288413"],"string":"[\n \"0.856302\",\n \"0.81208575\",\n \"0.8088181\",\n \"0.8051179\",\n \"0.79706645\",\n \"0.79012996\",\n \"0.78986406\",\n \"0.7809852\",\n \"0.77355325\",\n \"0.7704453\",\n \"0.7686551\",\n \"0.7686551\",\n \"0.7685671\",\n \"0.7684176\",\n \"0.7679467\",\n \"0.7600646\",\n \"0.74408424\",\n \"0.7436566\",\n \"0.7406232\",\n \"0.737946\",\n \"0.73696256\",\n \"0.7288805\",\n \"0.71703255\",\n \"0.70477754\",\n \"0.7034143\",\n \"0.69359523\",\n \"0.69283473\",\n \"0.6834192\",\n \"0.6818097\",\n \"0.6811115\",\n \"0.67967874\",\n \"0.6758067\",\n \"0.67397124\",\n \"0.671677\",\n \"0.6663981\",\n \"0.6365707\",\n \"0.6346235\",\n \"0.6346235\",\n \"0.6346235\",\n \"0.6278685\",\n \"0.6265275\",\n \"0.6259778\",\n \"0.62575984\",\n \"0.6220732\",\n \"0.6139988\",\n \"0.61112624\",\n \"0.6075163\",\n \"0.5971618\",\n \"0.5968167\",\n \"0.5962457\",\n \"0.5960647\",\n \"0.5840464\",\n \"0.58066475\",\n \"0.57821584\",\n \"0.5770427\",\n \"0.5761472\",\n \"0.57478803\",\n \"0.5747215\",\n \"0.5701392\",\n \"0.56947047\",\n \"0.5692718\",\n \"0.5626944\",\n \"0.5625926\",\n \"0.5613565\",\n \"0.5610967\",\n \"0.560093\",\n \"0.556555\",\n \"0.5564628\",\n \"0.5544109\",\n \"0.55397356\",\n \"0.55387133\",\n \"0.55341834\",\n \"0.5510549\",\n \"0.5507904\",\n \"0.54947525\",\n \"0.5490822\",\n \"0.54777986\",\n \"0.54566836\",\n \"0.54468435\",\n \"0.5429514\",\n \"0.54190105\",\n \"0.5398489\",\n \"0.53946024\",\n \"0.53898734\",\n \"0.53886175\",\n \"0.53835505\",\n \"0.53798455\",\n \"0.5374048\",\n \"0.5367737\",\n \"0.5351223\",\n \"0.53482634\",\n \"0.5338161\",\n \"0.5333216\",\n \"0.53260225\",\n \"0.53219086\",\n \"0.5313146\",\n \"0.5311876\",\n \"0.53038335\",\n \"0.5293816\",\n \"0.5288413\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81209445"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":83173,"cells":{"query":{"kind":"string","value":"Scaled Exponential Linear Unit. (Klambauer et al., 2017) Arguments"},"document":{"kind":"string","value":"def selu(x):\n alpha = 1.6732632423543772848170429916717\n scale = 1.0507009873554804934193349852946\n return scale * elu(x, alpha)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def setExponent(self, *args):\n return _libsbml.Unit_setExponent(self, *args)","def scale(inp, ab):\n\n return inp * ab[0] + ab[1]\n # pass","def scale(inp, ab):\n\n return inp * ab[0] + ab[1]","def scale(self):","def calculate_exponent():\n pass","def xscale(value):\n impl.xscale(**locals())","def get_scale():\r\n\r\n \r\n return 0.5","def invmelscale(b):\n return 700.0 * (np.exp(b / 1125.0) - 1)","def exponential(input_dim,variance=1., lengthscale=None, ARD=False):\r\n part = parts.exponential.Exponential(input_dim,variance, lengthscale, ARD)\r\n return kern(input_dim, [part])","def __init__(self, expr, a, name='scale'):\n super(ScaleExpression, self).__init__(e=expr, domain=expr.domain,\n verbosity=expr.verbosity,\n name=name)\n ## Factor to scale the expression by.\n self.a = a","def unit_scale(x, eps=1e-8):\n\tx = x.copy()\n\tx -= x.min()\n\tx *= 1.0 / (x.max() + eps)\n\treturn x","def melscale(f):\n return 1125.0 * np.log(1 + f / 700.0)","def transform(self, original_input):\n return super(ExponentialDimension, self).transform(np.exp(original_input))","def Scale(*args, **kwargs):\n return _gdi_.Font_Scale(*args, **kwargs)","def exp(x):\n raise NotImplementedError","def Scale(*args, **kwargs):\n return _gdi_.GraphicsMatrix_Scale(*args, **kwargs)","def schechter(l,alpha):\n return exp(-l)*(l**alpha)","def get_scaled_input_expressions(self, input_vars):\n pass","def scale_it(val):\n return scale(val, 0, 1, bpm_range[0], bpm_range[1])","def GetScale(self):\n ...","def exp_func(x, initial, lifetime):\n return initial * np.exp(-x/lifetime)","def adjust_E(self, power):\n if self.pwr_in_tot:\n fac = power/self.pwr_in_tot\n else:\n fac = 1.0\n fac = min(1.01, fac)\n self.Ey = sqrt(fac)*self.Ey","def calc_scales(self, params_in):\n if self.use_scales:\n scale = params_in[0]\n B = params_in[1]\n sin_sq_theta = self.miller_array.two_theta(wavelength=self.wavelength) \\\n .sin_theta_over_lambda_sq().data()\n\n scales = scale * self.miller_array.data()\n exp_arg = flex.double(-2 * B * sin_sq_theta)\n return flex.double(flex.double(scales) * flex.exp(exp_arg))\n else:\n # Horrible way to get vector of ones...\n return flex.double(self.miller_array.data()/self.miller_array.data())","def multiplier(self) -> global___Expression:","def exp(self, X, U):\n raise NotImplementedError","def _scale(x):\n scaleFactor = 1\n _ret = int(x/scaleFactor)\n return _ret","def grad_scale(x, multiplier):\n return GradScale(multiplier)(x)","def set_scales(l_min, l_max, N_scales):\r\n t1=1\r\n t2=2\r\n s_min = t1 / l_max\r\n s_max = t2 / l_min\r\n # Scales should be decreasing ... higher j should give larger s\r\n s = np.exp(np.linspace(np.log(s_max), np.log(s_min), N_scales));\r\n\r\n return s","def get_scale(units, compartmentId, volume, extracellularVolume):\r\n if compartmentId == 'c':\r\n V = volume\r\n else:\r\n V = extracellularVolume\r\n\r\n if units == 'uM':\r\n return 1. / N_AVOGADRO / V * 1e6\r\n elif units == 'mM':\r\n return 1. / N_AVOGADRO / V * 1e3\r\n elif units == 'molecules':\r\n return 1.\r\n else:\r\n raise Exception('Invalid units \"%s\"' % units)","def _eta_sfr_scaling(self,x,q):\n i = self.enum[q]\n A = self.scaling_params['A'][i]\n b = self.scaling_params['b'][i]\n return A*x**b","def getExponent(self):\n return _libsbml.Unit_getExponent(self)","def Scale(*args, **kwargs):\n return _gdi_.GraphicsContext_Scale(*args, **kwargs)","def scale(self, k_x, k_y = None):\r\n if (k_y is None):\r\n return vec2(k_x*self.x, k_x*self.y)\r\n else:\r\n return vec2(k_x*self.x, k_y*self.y)","def yscale(value):\n impl.yscale(**locals())","def scientific(c, e):\n return Scientific(long(c), long(e))","def setScale(self, *args):\n return _libsbml.Unit_setScale(self, *args)","def scale(curve):\n return curve/rmsd(curve)","def useUnits():","def lam(E):\n return (12398.4/E)*1e-10","def Scaled(*args, **kwargs):\n return _gdi_.Font_Scaled(*args, **kwargs)","def _scale_param(self, resid_us):\n return((resid_us**2).sum().sum() / self.dof)","def _linear_to_mel_scale(linear_scale_in, n_mel_bins, mel_lower_hertz_edge,\n mel_upper_hertz_edge):\n\n linear_to_mel_weight_matrix = tf.signal.linear_to_mel_weight_matrix(\n n_mel_bins, linear_scale_in.shape[-1], _SAMPLE_RATE, mel_lower_hertz_edge,\n mel_upper_hertz_edge\n )\n\n mel_scale_out = tf.tensordot(linear_scale_in, linear_to_mel_weight_matrix, 1)\n return mel_scale_out","def scale_quantity_gen(stock_size_gen, scale_factor):\n\n if scale_factor is not None:\n return stock_size_gen\\\n .map(f_vect=operations.scale(factor=scale_factor)) \\\n .map(f=operations.bound_value(lb=1))\n\n return stock_size_gen","def pl_exp_cut(x, mask=None, **params):\n energy_scale = np.ones(x.shape)\n if mask is not None:\n # E -> E * (1 + s)\n energy_scale[mask] += params['Energy_Scale']\n else:\n # apply to all energies\n energy_scale += params['Energy_Scale']\n\n if isinstance(x, u.Quantity):\n energy_scale *= u.dimensionless_unscaled\n\n x_scaled = x * energy_scale\n result = params[\"Prefactor\"] * np.power(x_scaled / params[\"Scale\"], params[\"Index\"])\n result *= np.exp(-x_scaled / params[\"Cutoff\"])\n return result","def scale(c, scalar):\n return [c[0]*scalar, c[1]*scalar]","def _etaE_cool(self,x):\n return self._eta_sfr_scaling(x,'E_cool')","def scale(requestContext, seriesList, factor):\n for series in seriesList:\n series.name = \"scale(%s,%g)\" % (series.name,float(factor))\n series.pathExpression = series.name\n for i,value in enumerate(series):\n series[i] = safeMul(value,factor)\n return seriesList","def selu(x):\n # from Keras 2.0.6 - does not exist in 2.0.4\n alpha = 1.6732632423543772848170429916717\n scale = 1.0507009873554804934193349852946\n return scale * K.elu(x, alpha)","def mults(self, s):\n prod = Vector.fromSequence(self.mV)\n prod.scale(s)\n return prod","def scale(self,n,d=1):\r\n\t\t\r\n\t\t# scale all terms\r\n\t\ts = [i.scale(n,d) for i in self]\r\n\t\t\r\n\t\treturn Li(s)","def _call_scale(vecObj, sc):\n res = vecObj.scale(sc)\n return res","def scale(self):\n return self.scale_factor / CONSTANTS.AU","def get_scaled_value(self, value):\r\n if self.logarithmic_factor != 1.0:\r\n exp_mult = exp(self.logarithmic_factor * value * 4.0) - 1\r\n exp_div = exp(self.logarithmic_factor * 4.0) - 1\r\n return exp_mult / exp_div * (self.maxvalue - self.minvalue) + self.minvalue\r\n else:\r\n return value * (self.maxvalue - self.minvalue) + self.minvalue","def adapt_length_scale(self):\n Ne = max(1,self.Ne)\n Nc = max(1,self.Nc)\n ratio = Ne/(Ne+Nc)\n self.mu *= 2*ratio","def scale(self):\n return self._a","def scientific(x):\n return '{:.2e}'.format(x)","def scale_factor(self, z = 0.):\n return 1./(1.+z)","def selu(x): # https://gist.github.com/naure/78bc7a881a9db17e366093c81425184f\n alpha = 1.6732632423543772848170429916717\n scale = 1.0507009873554804934193349852946\n return scale * elu(x, alpha)","def as_exp(s: str) -> str:\n return s if \"e\" in s else \"{:1.0e}\".format(float(s))","def scale(f, a, j=0):\n return f.per(dmp_scale_in(f.rep, f.dom.convert(a), j, f.lev, f.dom))","def scaling(mat, factor):\n\treturn mat / (mat + factor)","def exp_term(x, i):\n return x**i/math.factorial(i)","def scale(self):\n return self._scale","def selu(x):\n alpha = 1.6732632423543772848170429916717\n scale = 1.0507009873554804934193349852946\n return scale * K.elu(x, alpha)","def power_e(amount, start, stop, truncated, sequence):\n ratio = .5\n for x in range(start, amount):\n y = abs(round(ratio * math.exp(x)))\n if truncated and y >= stop:\n sequence.append(stop)\n elif y < start:\n sequence.append(start)\n else:\n sequence.append(y)\n return sequence","def setMultiplier(self, *args):\n return _libsbml.Unit_setMultiplier(self, *args)","def _fit_func(en, a, b, c, d, e, f, g, h):\n return a*(1./en**b)*(1./(c+d/(en**e))) + f*exp(-g*(en-h)**2)","def scale(self,s):\n return Vector(self.x * s, self.y * s, self.z * s)","def setExtentUnits(self, *args):\n return _libsbml.Model_setExtentUnits(self, *args)","def scale_mag_1(x):\n return np.array([np.true_divide(ui, mag(x)) for ui in x])","def e():\n print(math.e)","def inverse_scaled_quantization(x, scale):\n return x / tf.cast(scale, x.dtype)","def fit_line(model,scaling):\n\treturn scaling*model","def spaxel_scale(scale=4, wave=1.0):\n\n scale_rad = scale / MILIARCSECS_IN_A_RAD\n rho = scale_rad * ELT_DIAM / (wave * 1e-6)\n print(rho)","def lsePower(self, elim=None, power=1.0, out=None):\n if (elim is None):\n elim = self.v\n #return (self*power).lse(elim).__imul__(1.0/power) # fails if elim = self.v?\n tmp = (self*power).lse(elim)\n tmp *= (1.0/power)\n return tmp\n #return (self*power).lse(elim)*(1.0/power) # TODO: make more efficient?","def scale(self, x, y, z) -> None:\n ...","def exponential_window_lssm(self):\n self.A = np.array([self.decay])\n self.s = np.ones(1)\n self.C = np.ones(1)","def energy(e: float) -> float:\n\n return (1/np.sqrt(2))*(gamma(-e/2+1/2)/(gamma(-e/2+3/4)))","def get_scale_parameter(self):\n\n shape_in_gamma_func = float(1 + (1 / self._shape_parameter))\n gamma_func = special.gamma(shape_in_gamma_func)\n self._scale_parameter = self._mean_fire_recurrence / gamma_func","def with_scale_op(self, scale):\n\t\tself.variables['scale'] = scale\n\t\treturn self","def power_em1(amount, start, stop, truncated, sequence):\n ratio = .25\n for x in range(start, amount):\n y = abs(round(ratio * math.expm1(x)))\n if truncated and y >= stop:\n sequence.append(stop)\n elif y < start:\n sequence.append(start)\n else:\n sequence.append(y)\n return sequence","def get_unscaled_output_expressions(self, scaled_output_vars):\n pass","def exponential(value):\n return math.exp(value)","def test_econ_scale_eqn():\n eqn = 0.5\n # from pvwattsv7 defaults\n data = {'aep': 35188456.00,\n 'capital_cost': 53455000.00,\n 'foc': 360000.00,\n 'voc': 0,\n 'fcr': 0.096}\n true_raw_lcoe = 15.62 # cents/kWh\n true_raw_lcoe *= 10 # cents/kWh -> $/MWh\n\n # Back out the fcr * capital_cost term ($)\n x = (true_raw_lcoe / 1000 - data['voc']) * data['aep'] - data['foc']\n # pylint: disable=eval-used\n x *= eval(str(eqn))\n true_scaled_lcoe = (x + data['foc']) / data['aep'] + data['voc']\n true_scaled_lcoe *= 1000 # $/kWh -> $/MWh\n eos = EconomiesOfScale(eqn, data)\n assert np.allclose(true_scaled_lcoe, eos.scaled_lcoe, rtol=0.001)\n assert np.allclose(true_raw_lcoe, eos.raw_lcoe, rtol=0.001)\n\n eqn = '2 * capacity ** -0.3'\n aep = data.pop('aep')\n data['mean_cf'] = 0.201\n data['capacity'] = 20\n x = (true_raw_lcoe / 1000 - data['voc']) * aep - data['foc']\n # pylint: disable=eval-used\n x *= eval(str(eqn), globals(), data) # x is fcr*capital_cost in $\n true_scaled_lcoe = (x + data['foc']) / aep + data['voc']\n true_scaled_lcoe *= 1000 # $/kWh -> $/MWh\n eos = EconomiesOfScale(eqn, data)\n assert np.allclose(aep, eos.aep, rtol=0.001)\n assert np.allclose(true_scaled_lcoe, eos.scaled_lcoe, rtol=0.002)\n assert np.allclose(true_raw_lcoe, eos.raw_lcoe, rtol=0.002)\n\n data['capacity'] = np.arange(20, 400, 20)\n eos = EconomiesOfScale(eqn, data)\n assert all(np.diff(eos.scaled_lcoe) < 0)","def scale(self, s):\n for n in range(len(self.mV)):\n self.mV[n] *= s\n return self","def xycurves_write_x_scale(self, argument) -> float:\n argument = Base.check_float_param(argument)\n return float(self.dss_obj.XYCurvesF(ctypes.c_int32(9), ctypes.c_double(argument)))","def __call__(self, q):\n # SASCalculator ignores the scale, so we add it in here\n yout = BasePDFGenerator.__call__(self, q)\n yout *= self.scale.value\n return yout","def unit(self,unit_str,unit_scale):\n self.units[unit_str] = unit_scale\n return self","def Q_e(params):\n return (params['Q_e_real'].value +\n 1j * params['Q_e_imag'].value)","def scale(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"scale\")","def exp(t,tau):\n return np.exp(-t/tau)","def exp_fun(self, xs, *args, **kwargs):\n raise NotImplementedError","def scale(X, *, axis=..., with_mean=..., with_std=..., copy=...):\n ...","def exp(self):\n return Factor().__build( VarSet(self.v) , np.exp(self.t) )","def scale(self, value):\r\n return (float(value)-float(self.minimum))/float(self.maximum-self.minimum)*2.0 - 1.0","def scale(input):\n return (input - np.min(input)) / ((np.max(input) - np.min(input)))","def __init__(self, multiplier=1e-1):\r\n self.multiplier = multiplier","def e_mul_const(pub, a, n):\n return myExp(a, n, pub.n_sq)","def get_scale_parameter(self):\r\n \r\n if self.scale_parameter == 0.0: \r\n shape_in_gamma_func = float(1+(1/self.shape_parameter))\r\n gamma_func = special.gamma(shape_in_gamma_func)\r\n self.scale_parameter = (self.mean_fire_recurrence/gamma_func)\r\n return self.scale_parameter\r\n else:\r\n return self.scale_parameter","def exponential_series(x, prec, type=0):\n if x < 0:\n x = -x\n sign = 1\n else:\n sign = 0\n r = int(0.5*prec**0.5)\n xmag = bitcount(x) - prec\n r = max(0, xmag + r)\n extra = 10 + 2*max(r,-xmag)\n wp = prec + extra\n x <<= (extra - r)\n one = MPZ_ONE << wp\n alt = (type == 2)\n if prec < EXP_SERIES_U_CUTOFF:\n x2 = a = (x*x) >> wp\n x4 = (x2*x2) >> wp\n s0 = s1 = MPZ_ZERO\n k = 2\n while a:\n a //= (k-1)*k; s0 += a; k += 2\n a //= (k-1)*k; s1 += a; k += 2\n a = (a*x4) >> wp\n s1 = (x2*s1) >> wp\n if alt:\n c = s1 - s0 + one\n else:\n c = s1 + s0 + one\n else:\n u = int(0.3*prec**0.35)\n x2 = a = (x*x) >> wp\n xpowers = [one, x2]\n for i in xrange(1, u):\n xpowers.append((xpowers[-1]*x2)>>wp)\n sums = [MPZ_ZERO] * u\n k = 2\n while a:\n for i in xrange(u):\n a //= (k-1)*k\n if alt and k & 2: sums[i] -= a\n else: sums[i] += a\n k += 2\n a = (a*xpowers[-1]) >> wp\n for i in xrange(1, u):\n sums[i] = (sums[i]*xpowers[i]) >> wp\n c = sum(sums) + one\n if type == 0:\n s = isqrt_fast(c*c - (one<<wp))\n if sign:\n v = c - s\n else:\n v = c + s\n for i in xrange(r):\n v = (v*v) >> wp\n return v >> extra\n else:\n # Repeatedly apply the double-angle formula\n # cosh(2*x) = 2*cosh(x)^2 - 1\n # cos(2*x) = 2*cos(x)^2 - 1\n pshift = wp-1\n for i in xrange(r):\n c = ((c*c) >> pshift) - one\n # With the abs, this is the same for sinh and sin\n s = isqrt_fast(abs((one<<wp) - c*c))\n if sign:\n s = -s\n return (c>>extra), (s>>extra)"],"string":"[\n \"def setExponent(self, *args):\\n return _libsbml.Unit_setExponent(self, *args)\",\n \"def scale(inp, ab):\\n\\n return inp * ab[0] + ab[1]\\n # pass\",\n \"def scale(inp, ab):\\n\\n return inp * ab[0] + ab[1]\",\n \"def scale(self):\",\n \"def calculate_exponent():\\n pass\",\n \"def xscale(value):\\n impl.xscale(**locals())\",\n \"def get_scale():\\r\\n\\r\\n \\r\\n return 0.5\",\n \"def invmelscale(b):\\n return 700.0 * (np.exp(b / 1125.0) - 1)\",\n \"def exponential(input_dim,variance=1., lengthscale=None, ARD=False):\\r\\n part = parts.exponential.Exponential(input_dim,variance, lengthscale, ARD)\\r\\n return kern(input_dim, [part])\",\n \"def __init__(self, expr, a, name='scale'):\\n super(ScaleExpression, self).__init__(e=expr, domain=expr.domain,\\n verbosity=expr.verbosity,\\n name=name)\\n ## Factor to scale the expression by.\\n self.a = a\",\n \"def unit_scale(x, eps=1e-8):\\n\\tx = x.copy()\\n\\tx -= x.min()\\n\\tx *= 1.0 / (x.max() + eps)\\n\\treturn x\",\n \"def melscale(f):\\n return 1125.0 * np.log(1 + f / 700.0)\",\n \"def transform(self, original_input):\\n return super(ExponentialDimension, self).transform(np.exp(original_input))\",\n \"def Scale(*args, **kwargs):\\n return _gdi_.Font_Scale(*args, **kwargs)\",\n \"def exp(x):\\n raise NotImplementedError\",\n \"def Scale(*args, **kwargs):\\n return _gdi_.GraphicsMatrix_Scale(*args, **kwargs)\",\n \"def schechter(l,alpha):\\n return exp(-l)*(l**alpha)\",\n \"def get_scaled_input_expressions(self, input_vars):\\n pass\",\n \"def scale_it(val):\\n return scale(val, 0, 1, bpm_range[0], bpm_range[1])\",\n \"def GetScale(self):\\n ...\",\n \"def exp_func(x, initial, lifetime):\\n return initial * np.exp(-x/lifetime)\",\n \"def adjust_E(self, power):\\n if self.pwr_in_tot:\\n fac = power/self.pwr_in_tot\\n else:\\n fac = 1.0\\n fac = min(1.01, fac)\\n self.Ey = sqrt(fac)*self.Ey\",\n \"def calc_scales(self, params_in):\\n if self.use_scales:\\n scale = params_in[0]\\n B = params_in[1]\\n sin_sq_theta = self.miller_array.two_theta(wavelength=self.wavelength) \\\\\\n .sin_theta_over_lambda_sq().data()\\n\\n scales = scale * self.miller_array.data()\\n exp_arg = flex.double(-2 * B * sin_sq_theta)\\n return flex.double(flex.double(scales) * flex.exp(exp_arg))\\n else:\\n # Horrible way to get vector of ones...\\n return flex.double(self.miller_array.data()/self.miller_array.data())\",\n \"def multiplier(self) -> global___Expression:\",\n \"def exp(self, X, U):\\n raise NotImplementedError\",\n \"def _scale(x):\\n scaleFactor = 1\\n _ret = int(x/scaleFactor)\\n return _ret\",\n \"def grad_scale(x, multiplier):\\n return GradScale(multiplier)(x)\",\n \"def set_scales(l_min, l_max, N_scales):\\r\\n t1=1\\r\\n t2=2\\r\\n s_min = t1 / l_max\\r\\n s_max = t2 / l_min\\r\\n # Scales should be decreasing ... higher j should give larger s\\r\\n s = np.exp(np.linspace(np.log(s_max), np.log(s_min), N_scales));\\r\\n\\r\\n return s\",\n \"def get_scale(units, compartmentId, volume, extracellularVolume):\\r\\n if compartmentId == 'c':\\r\\n V = volume\\r\\n else:\\r\\n V = extracellularVolume\\r\\n\\r\\n if units == 'uM':\\r\\n return 1. / N_AVOGADRO / V * 1e6\\r\\n elif units == 'mM':\\r\\n return 1. / N_AVOGADRO / V * 1e3\\r\\n elif units == 'molecules':\\r\\n return 1.\\r\\n else:\\r\\n raise Exception('Invalid units \\\"%s\\\"' % units)\",\n \"def _eta_sfr_scaling(self,x,q):\\n i = self.enum[q]\\n A = self.scaling_params['A'][i]\\n b = self.scaling_params['b'][i]\\n return A*x**b\",\n \"def getExponent(self):\\n return _libsbml.Unit_getExponent(self)\",\n \"def Scale(*args, **kwargs):\\n return _gdi_.GraphicsContext_Scale(*args, **kwargs)\",\n \"def scale(self, k_x, k_y = None):\\r\\n if (k_y is None):\\r\\n return vec2(k_x*self.x, k_x*self.y)\\r\\n else:\\r\\n return vec2(k_x*self.x, k_y*self.y)\",\n \"def yscale(value):\\n impl.yscale(**locals())\",\n \"def scientific(c, e):\\n return Scientific(long(c), long(e))\",\n \"def setScale(self, *args):\\n return _libsbml.Unit_setScale(self, *args)\",\n \"def scale(curve):\\n return curve/rmsd(curve)\",\n \"def useUnits():\",\n \"def lam(E):\\n return (12398.4/E)*1e-10\",\n \"def Scaled(*args, **kwargs):\\n return _gdi_.Font_Scaled(*args, **kwargs)\",\n \"def _scale_param(self, resid_us):\\n return((resid_us**2).sum().sum() / self.dof)\",\n \"def _linear_to_mel_scale(linear_scale_in, n_mel_bins, mel_lower_hertz_edge,\\n mel_upper_hertz_edge):\\n\\n linear_to_mel_weight_matrix = tf.signal.linear_to_mel_weight_matrix(\\n n_mel_bins, linear_scale_in.shape[-1], _SAMPLE_RATE, mel_lower_hertz_edge,\\n mel_upper_hertz_edge\\n )\\n\\n mel_scale_out = tf.tensordot(linear_scale_in, linear_to_mel_weight_matrix, 1)\\n return mel_scale_out\",\n \"def scale_quantity_gen(stock_size_gen, scale_factor):\\n\\n if scale_factor is not None:\\n return stock_size_gen\\\\\\n .map(f_vect=operations.scale(factor=scale_factor)) \\\\\\n .map(f=operations.bound_value(lb=1))\\n\\n return stock_size_gen\",\n \"def pl_exp_cut(x, mask=None, **params):\\n energy_scale = np.ones(x.shape)\\n if mask is not None:\\n # E -> E * (1 + s)\\n energy_scale[mask] += params['Energy_Scale']\\n else:\\n # apply to all energies\\n energy_scale += params['Energy_Scale']\\n\\n if isinstance(x, u.Quantity):\\n energy_scale *= u.dimensionless_unscaled\\n\\n x_scaled = x * energy_scale\\n result = params[\\\"Prefactor\\\"] * np.power(x_scaled / params[\\\"Scale\\\"], params[\\\"Index\\\"])\\n result *= np.exp(-x_scaled / params[\\\"Cutoff\\\"])\\n return result\",\n \"def scale(c, scalar):\\n return [c[0]*scalar, c[1]*scalar]\",\n \"def _etaE_cool(self,x):\\n return self._eta_sfr_scaling(x,'E_cool')\",\n \"def scale(requestContext, seriesList, factor):\\n for series in seriesList:\\n series.name = \\\"scale(%s,%g)\\\" % (series.name,float(factor))\\n series.pathExpression = series.name\\n for i,value in enumerate(series):\\n series[i] = safeMul(value,factor)\\n return seriesList\",\n \"def selu(x):\\n # from Keras 2.0.6 - does not exist in 2.0.4\\n alpha = 1.6732632423543772848170429916717\\n scale = 1.0507009873554804934193349852946\\n return scale * K.elu(x, alpha)\",\n \"def mults(self, s):\\n prod = Vector.fromSequence(self.mV)\\n prod.scale(s)\\n return prod\",\n \"def scale(self,n,d=1):\\r\\n\\t\\t\\r\\n\\t\\t# scale all terms\\r\\n\\t\\ts = [i.scale(n,d) for i in self]\\r\\n\\t\\t\\r\\n\\t\\treturn Li(s)\",\n \"def _call_scale(vecObj, sc):\\n res = vecObj.scale(sc)\\n return res\",\n \"def scale(self):\\n return self.scale_factor / CONSTANTS.AU\",\n \"def get_scaled_value(self, value):\\r\\n if self.logarithmic_factor != 1.0:\\r\\n exp_mult = exp(self.logarithmic_factor * value * 4.0) - 1\\r\\n exp_div = exp(self.logarithmic_factor * 4.0) - 1\\r\\n return exp_mult / exp_div * (self.maxvalue - self.minvalue) + self.minvalue\\r\\n else:\\r\\n return value * (self.maxvalue - self.minvalue) + self.minvalue\",\n \"def adapt_length_scale(self):\\n Ne = max(1,self.Ne)\\n Nc = max(1,self.Nc)\\n ratio = Ne/(Ne+Nc)\\n self.mu *= 2*ratio\",\n \"def scale(self):\\n return self._a\",\n \"def scientific(x):\\n return '{:.2e}'.format(x)\",\n \"def scale_factor(self, z = 0.):\\n return 1./(1.+z)\",\n \"def selu(x): # https://gist.github.com/naure/78bc7a881a9db17e366093c81425184f\\n alpha = 1.6732632423543772848170429916717\\n scale = 1.0507009873554804934193349852946\\n return scale * elu(x, alpha)\",\n \"def as_exp(s: str) -> str:\\n return s if \\\"e\\\" in s else \\\"{:1.0e}\\\".format(float(s))\",\n \"def scale(f, a, j=0):\\n return f.per(dmp_scale_in(f.rep, f.dom.convert(a), j, f.lev, f.dom))\",\n \"def scaling(mat, factor):\\n\\treturn mat / (mat + factor)\",\n \"def exp_term(x, i):\\n return x**i/math.factorial(i)\",\n \"def scale(self):\\n return self._scale\",\n \"def selu(x):\\n alpha = 1.6732632423543772848170429916717\\n scale = 1.0507009873554804934193349852946\\n return scale * K.elu(x, alpha)\",\n \"def power_e(amount, start, stop, truncated, sequence):\\n ratio = .5\\n for x in range(start, amount):\\n y = abs(round(ratio * math.exp(x)))\\n if truncated and y >= stop:\\n sequence.append(stop)\\n elif y < start:\\n sequence.append(start)\\n else:\\n sequence.append(y)\\n return sequence\",\n \"def setMultiplier(self, *args):\\n return _libsbml.Unit_setMultiplier(self, *args)\",\n \"def _fit_func(en, a, b, c, d, e, f, g, h):\\n return a*(1./en**b)*(1./(c+d/(en**e))) + f*exp(-g*(en-h)**2)\",\n \"def scale(self,s):\\n return Vector(self.x * s, self.y * s, self.z * s)\",\n \"def setExtentUnits(self, *args):\\n return _libsbml.Model_setExtentUnits(self, *args)\",\n \"def scale_mag_1(x):\\n return np.array([np.true_divide(ui, mag(x)) for ui in x])\",\n \"def e():\\n print(math.e)\",\n \"def inverse_scaled_quantization(x, scale):\\n return x / tf.cast(scale, x.dtype)\",\n \"def fit_line(model,scaling):\\n\\treturn scaling*model\",\n \"def spaxel_scale(scale=4, wave=1.0):\\n\\n scale_rad = scale / MILIARCSECS_IN_A_RAD\\n rho = scale_rad * ELT_DIAM / (wave * 1e-6)\\n print(rho)\",\n \"def lsePower(self, elim=None, power=1.0, out=None):\\n if (elim is None):\\n elim = self.v\\n #return (self*power).lse(elim).__imul__(1.0/power) # fails if elim = self.v?\\n tmp = (self*power).lse(elim)\\n tmp *= (1.0/power)\\n return tmp\\n #return (self*power).lse(elim)*(1.0/power) # TODO: make more efficient?\",\n \"def scale(self, x, y, z) -> None:\\n ...\",\n \"def exponential_window_lssm(self):\\n self.A = np.array([self.decay])\\n self.s = np.ones(1)\\n self.C = np.ones(1)\",\n \"def energy(e: float) -> float:\\n\\n return (1/np.sqrt(2))*(gamma(-e/2+1/2)/(gamma(-e/2+3/4)))\",\n \"def get_scale_parameter(self):\\n\\n shape_in_gamma_func = float(1 + (1 / self._shape_parameter))\\n gamma_func = special.gamma(shape_in_gamma_func)\\n self._scale_parameter = self._mean_fire_recurrence / gamma_func\",\n \"def with_scale_op(self, scale):\\n\\t\\tself.variables['scale'] = scale\\n\\t\\treturn self\",\n \"def power_em1(amount, start, stop, truncated, sequence):\\n ratio = .25\\n for x in range(start, amount):\\n y = abs(round(ratio * math.expm1(x)))\\n if truncated and y >= stop:\\n sequence.append(stop)\\n elif y < start:\\n sequence.append(start)\\n else:\\n sequence.append(y)\\n return sequence\",\n \"def get_unscaled_output_expressions(self, scaled_output_vars):\\n pass\",\n \"def exponential(value):\\n return math.exp(value)\",\n \"def test_econ_scale_eqn():\\n eqn = 0.5\\n # from pvwattsv7 defaults\\n data = {'aep': 35188456.00,\\n 'capital_cost': 53455000.00,\\n 'foc': 360000.00,\\n 'voc': 0,\\n 'fcr': 0.096}\\n true_raw_lcoe = 15.62 # cents/kWh\\n true_raw_lcoe *= 10 # cents/kWh -> $/MWh\\n\\n # Back out the fcr * capital_cost term ($)\\n x = (true_raw_lcoe / 1000 - data['voc']) * data['aep'] - data['foc']\\n # pylint: disable=eval-used\\n x *= eval(str(eqn))\\n true_scaled_lcoe = (x + data['foc']) / data['aep'] + data['voc']\\n true_scaled_lcoe *= 1000 # $/kWh -> $/MWh\\n eos = EconomiesOfScale(eqn, data)\\n assert np.allclose(true_scaled_lcoe, eos.scaled_lcoe, rtol=0.001)\\n assert np.allclose(true_raw_lcoe, eos.raw_lcoe, rtol=0.001)\\n\\n eqn = '2 * capacity ** -0.3'\\n aep = data.pop('aep')\\n data['mean_cf'] = 0.201\\n data['capacity'] = 20\\n x = (true_raw_lcoe / 1000 - data['voc']) * aep - data['foc']\\n # pylint: disable=eval-used\\n x *= eval(str(eqn), globals(), data) # x is fcr*capital_cost in $\\n true_scaled_lcoe = (x + data['foc']) / aep + data['voc']\\n true_scaled_lcoe *= 1000 # $/kWh -> $/MWh\\n eos = EconomiesOfScale(eqn, data)\\n assert np.allclose(aep, eos.aep, rtol=0.001)\\n assert np.allclose(true_scaled_lcoe, eos.scaled_lcoe, rtol=0.002)\\n assert np.allclose(true_raw_lcoe, eos.raw_lcoe, rtol=0.002)\\n\\n data['capacity'] = np.arange(20, 400, 20)\\n eos = EconomiesOfScale(eqn, data)\\n assert all(np.diff(eos.scaled_lcoe) < 0)\",\n \"def scale(self, s):\\n for n in range(len(self.mV)):\\n self.mV[n] *= s\\n return self\",\n \"def xycurves_write_x_scale(self, argument) -> float:\\n argument = Base.check_float_param(argument)\\n return float(self.dss_obj.XYCurvesF(ctypes.c_int32(9), ctypes.c_double(argument)))\",\n \"def __call__(self, q):\\n # SASCalculator ignores the scale, so we add it in here\\n yout = BasePDFGenerator.__call__(self, q)\\n yout *= self.scale.value\\n return yout\",\n \"def unit(self,unit_str,unit_scale):\\n self.units[unit_str] = unit_scale\\n return self\",\n \"def Q_e(params):\\n return (params['Q_e_real'].value +\\n 1j * params['Q_e_imag'].value)\",\n \"def scale(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"scale\\\")\",\n \"def exp(t,tau):\\n return np.exp(-t/tau)\",\n \"def exp_fun(self, xs, *args, **kwargs):\\n raise NotImplementedError\",\n \"def scale(X, *, axis=..., with_mean=..., with_std=..., copy=...):\\n ...\",\n \"def exp(self):\\n return Factor().__build( VarSet(self.v) , np.exp(self.t) )\",\n \"def scale(self, value):\\r\\n return (float(value)-float(self.minimum))/float(self.maximum-self.minimum)*2.0 - 1.0\",\n \"def scale(input):\\n return (input - np.min(input)) / ((np.max(input) - np.min(input)))\",\n \"def __init__(self, multiplier=1e-1):\\r\\n self.multiplier = multiplier\",\n \"def e_mul_const(pub, a, n):\\n return myExp(a, n, pub.n_sq)\",\n \"def get_scale_parameter(self):\\r\\n \\r\\n if self.scale_parameter == 0.0: \\r\\n shape_in_gamma_func = float(1+(1/self.shape_parameter))\\r\\n gamma_func = special.gamma(shape_in_gamma_func)\\r\\n self.scale_parameter = (self.mean_fire_recurrence/gamma_func)\\r\\n return self.scale_parameter\\r\\n else:\\r\\n return self.scale_parameter\",\n \"def exponential_series(x, prec, type=0):\\n if x < 0:\\n x = -x\\n sign = 1\\n else:\\n sign = 0\\n r = int(0.5*prec**0.5)\\n xmag = bitcount(x) - prec\\n r = max(0, xmag + r)\\n extra = 10 + 2*max(r,-xmag)\\n wp = prec + extra\\n x <<= (extra - r)\\n one = MPZ_ONE << wp\\n alt = (type == 2)\\n if prec < EXP_SERIES_U_CUTOFF:\\n x2 = a = (x*x) >> wp\\n x4 = (x2*x2) >> wp\\n s0 = s1 = MPZ_ZERO\\n k = 2\\n while a:\\n a //= (k-1)*k; s0 += a; k += 2\\n a //= (k-1)*k; s1 += a; k += 2\\n a = (a*x4) >> wp\\n s1 = (x2*s1) >> wp\\n if alt:\\n c = s1 - s0 + one\\n else:\\n c = s1 + s0 + one\\n else:\\n u = int(0.3*prec**0.35)\\n x2 = a = (x*x) >> wp\\n xpowers = [one, x2]\\n for i in xrange(1, u):\\n xpowers.append((xpowers[-1]*x2)>>wp)\\n sums = [MPZ_ZERO] * u\\n k = 2\\n while a:\\n for i in xrange(u):\\n a //= (k-1)*k\\n if alt and k & 2: sums[i] -= a\\n else: sums[i] += a\\n k += 2\\n a = (a*xpowers[-1]) >> wp\\n for i in xrange(1, u):\\n sums[i] = (sums[i]*xpowers[i]) >> wp\\n c = sum(sums) + one\\n if type == 0:\\n s = isqrt_fast(c*c - (one<<wp))\\n if sign:\\n v = c - s\\n else:\\n v = c + s\\n for i in xrange(r):\\n v = (v*v) >> wp\\n return v >> extra\\n else:\\n # Repeatedly apply the double-angle formula\\n # cosh(2*x) = 2*cosh(x)^2 - 1\\n # cos(2*x) = 2*cos(x)^2 - 1\\n pshift = wp-1\\n for i in xrange(r):\\n c = ((c*c) >> pshift) - one\\n # With the abs, this is the same for sinh and sin\\n s = isqrt_fast(abs((one<<wp) - c*c))\\n if sign:\\n s = -s\\n return (c>>extra), (s>>extra)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62797046","0.61946106","0.61704326","0.61148554","0.59997374","0.5996937","0.5957179","0.5904153","0.5895206","0.58881485","0.5836805","0.57540625","0.57374054","0.5706502","0.5674149","0.5617635","0.5616218","0.5604117","0.5592343","0.55895114","0.5565679","0.5563665","0.55560464","0.5550629","0.5532337","0.55231035","0.5509866","0.54958236","0.5485178","0.54730344","0.5459943","0.5456037","0.5453781","0.5446886","0.5443341","0.5417944","0.5415551","0.5414837","0.54057944","0.54016507","0.5380234","0.5355103","0.5347231","0.5345096","0.53401256","0.53400046","0.5339626","0.5331512","0.53197503","0.53158104","0.531286","0.5310006","0.53088593","0.5303552","0.5281591","0.5274591","0.52612716","0.52600074","0.5250786","0.5247088","0.5246706","0.5243975","0.5240825","0.5236079","0.5235397","0.5235288","0.52347165","0.5230952","0.5218628","0.52133226","0.5211213","0.5202506","0.52024835","0.5201958","0.5190973","0.51879495","0.51824266","0.516627","0.51645243","0.51560986","0.5154896","0.5144536","0.5130133","0.5130004","0.5127566","0.5126579","0.5125461","0.51244307","0.5122463","0.51224166","0.5114713","0.5111496","0.5106029","0.5105428","0.50984323","0.5098088","0.5094643","0.509399","0.50934803","0.509343"],"string":"[\n \"0.62797046\",\n \"0.61946106\",\n \"0.61704326\",\n \"0.61148554\",\n \"0.59997374\",\n \"0.5996937\",\n \"0.5957179\",\n \"0.5904153\",\n \"0.5895206\",\n \"0.58881485\",\n \"0.5836805\",\n \"0.57540625\",\n \"0.57374054\",\n \"0.5706502\",\n \"0.5674149\",\n \"0.5617635\",\n \"0.5616218\",\n \"0.5604117\",\n \"0.5592343\",\n \"0.55895114\",\n \"0.5565679\",\n \"0.5563665\",\n \"0.55560464\",\n \"0.5550629\",\n \"0.5532337\",\n \"0.55231035\",\n \"0.5509866\",\n \"0.54958236\",\n \"0.5485178\",\n \"0.54730344\",\n \"0.5459943\",\n \"0.5456037\",\n \"0.5453781\",\n \"0.5446886\",\n \"0.5443341\",\n \"0.5417944\",\n \"0.5415551\",\n \"0.5414837\",\n \"0.54057944\",\n \"0.54016507\",\n \"0.5380234\",\n \"0.5355103\",\n \"0.5347231\",\n \"0.5345096\",\n \"0.53401256\",\n \"0.53400046\",\n \"0.5339626\",\n \"0.5331512\",\n \"0.53197503\",\n \"0.53158104\",\n \"0.531286\",\n \"0.5310006\",\n \"0.53088593\",\n \"0.5303552\",\n \"0.5281591\",\n \"0.5274591\",\n \"0.52612716\",\n \"0.52600074\",\n \"0.5250786\",\n \"0.5247088\",\n \"0.5246706\",\n \"0.5243975\",\n \"0.5240825\",\n \"0.5236079\",\n \"0.5235397\",\n \"0.5235288\",\n \"0.52347165\",\n \"0.5230952\",\n \"0.5218628\",\n \"0.52133226\",\n \"0.5211213\",\n \"0.5202506\",\n \"0.52024835\",\n \"0.5201958\",\n \"0.5190973\",\n \"0.51879495\",\n \"0.51824266\",\n \"0.516627\",\n \"0.51645243\",\n \"0.51560986\",\n \"0.5154896\",\n \"0.5144536\",\n \"0.5130133\",\n \"0.5130004\",\n \"0.5127566\",\n \"0.5126579\",\n \"0.5125461\",\n \"0.51244307\",\n \"0.5122463\",\n \"0.51224166\",\n \"0.5114713\",\n \"0.5111496\",\n \"0.5106029\",\n \"0.5105428\",\n \"0.50984323\",\n \"0.5098088\",\n \"0.5094643\",\n \"0.509399\",\n \"0.50934803\",\n \"0.509343\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5287071"},"document_rank":{"kind":"string","value":"54"}}},{"rowIdx":83174,"cells":{"query":{"kind":"string","value":"Constructor for the NasBackupParams class"},"document":{"kind":"string","value":"def __init__(self,\n backup_all_existing_snapshot=None,\n blacklisted_ip_addrs=None,\n continue_on_error=None,\n encryption_enabled=None,\n filtering_policy=None,\n fld_config=None,\n full_backup_snapshot_label=None,\n incremental_backup_snapshot_label=None,\n is_source_initiated_backup=None,\n mixed_mode_preference=None,\n modify_source_permissions=None,\n nfs_version_preference=None,\n s3_viewbackupproperties=None,\n shared_view_name=None,\n snapshot_change_enabled=None,\n throttling_params=None,\n whitelisted_ip_addrs=None,\n ):\n\n # Initialize members of the class\n self.backup_all_existing_snapshot = backup_all_existing_snapshot\n self.blacklisted_ip_addrs = blacklisted_ip_addrs\n self.continue_on_error = continue_on_error\n self.encryption_enabled = encryption_enabled\n self.filtering_policy = filtering_policy\n self.fld_config = fld_config\n self.full_backup_snapshot_label = full_backup_snapshot_label\n self.incremental_backup_snapshot_label = incremental_backup_snapshot_label\n self.is_source_initiated_backup = is_source_initiated_backup\n self.mixed_mode_preference = mixed_mode_preference\n self.modify_source_permissions = modify_source_permissions\n self.nfs_version_preference = nfs_version_preference\n self.s3_viewbackupproperties = s3_viewbackupproperties\n self.shared_view_name = shared_view_name\n self.snapshot_change_enabled = snapshot_change_enabled\n self.throttling_params = throttling_params\n self.whitelisted_ip_addrs = whitelisted_ip_addrs"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __init__(__self__, *,\n include_cluster_scope_resources: pulumi.Input[bool],\n object_type: pulumi.Input[str],\n snapshot_volumes: pulumi.Input[bool],\n excluded_namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n excluded_resource_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n included_namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n included_resource_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n label_selectors: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):\n pulumi.set(__self__, \"include_cluster_scope_resources\", include_cluster_scope_resources)\n pulumi.set(__self__, \"object_type\", 'KubernetesClusterBackupDatasourceParameters')\n pulumi.set(__self__, \"snapshot_volumes\", snapshot_volumes)\n if excluded_namespaces is not None:\n pulumi.set(__self__, \"excluded_namespaces\", excluded_namespaces)\n if excluded_resource_types is not None:\n pulumi.set(__self__, \"excluded_resource_types\", excluded_resource_types)\n if included_namespaces is not None:\n pulumi.set(__self__, \"included_namespaces\", included_namespaces)\n if included_resource_types is not None:\n pulumi.set(__self__, \"included_resource_types\", included_resource_types)\n if label_selectors is not None:\n pulumi.set(__self__, \"label_selectors\", label_selectors)","def __init__(self,\n backup_file_path=None,\n excluded_file_paths=None,\n skip_nested_volumes=None,\n ):\n\n # Initialize members of the class\n self.backup_file_path = backup_file_path\n self.excluded_file_paths = excluded_file_paths\n self.skip_nested_volumes = skip_nested_volumes","def __init__(__self__, *,\n backup: Optional[pulumi.Input['VolumeBackupPropertiesArgs']] = None,\n replication: Optional[pulumi.Input['ReplicationObjectArgs']] = None,\n snapshot: Optional[pulumi.Input['VolumeSnapshotPropertiesArgs']] = None):\n if backup is not None:\n pulumi.set(__self__, \"backup\", backup)\n if replication is not None:\n pulumi.set(__self__, \"replication\", replication)\n if snapshot is not None:\n pulumi.set(__self__, \"snapshot\", snapshot)","def __init__(__self__, *,\n include_cluster_scope_resources: bool,\n object_type: str,\n snapshot_volumes: bool,\n excluded_namespaces: Optional[Sequence[str]] = None,\n excluded_resource_types: Optional[Sequence[str]] = None,\n included_namespaces: Optional[Sequence[str]] = None,\n included_resource_types: Optional[Sequence[str]] = None,\n label_selectors: Optional[Sequence[str]] = None):\n pulumi.set(__self__, \"include_cluster_scope_resources\", include_cluster_scope_resources)\n pulumi.set(__self__, \"object_type\", 'KubernetesClusterBackupDatasourceParameters')\n pulumi.set(__self__, \"snapshot_volumes\", snapshot_volumes)\n if excluded_namespaces is not None:\n pulumi.set(__self__, \"excluded_namespaces\", excluded_namespaces)\n if excluded_resource_types is not None:\n pulumi.set(__self__, \"excluded_resource_types\", excluded_resource_types)\n if included_namespaces is not None:\n pulumi.set(__self__, \"included_namespaces\", included_namespaces)\n if included_resource_types is not None:\n pulumi.set(__self__, \"included_resource_types\", included_resource_types)\n if label_selectors is not None:\n pulumi.set(__self__, \"label_selectors\", label_selectors)","def __init__(__self__, *,\n containers_list: pulumi.Input[Sequence[pulumi.Input[str]]],\n object_type: pulumi.Input[str]):\n pulumi.set(__self__, \"containers_list\", containers_list)\n pulumi.set(__self__, \"object_type\", 'BlobBackupDatasourceParameters')","def __init__(self, ip, mnode, backups):\n self.vip = ip\n self.main_node = mnode\n self.backups = backups","def __init__(__self__, *,\n backups_count: Optional[pulumi.Input[int]] = None,\n policy_enabled: Optional[pulumi.Input[bool]] = None,\n volume_name: Optional[pulumi.Input[str]] = None):\n if backups_count is not None:\n pulumi.set(__self__, \"backups_count\", backups_count)\n if policy_enabled is not None:\n pulumi.set(__self__, \"policy_enabled\", policy_enabled)\n if volume_name is not None:\n pulumi.set(__self__, \"volume_name\", volume_name)","def __init__(__self__, *,\n backups_count: Optional[pulumi.Input[int]] = None,\n policy_enabled: Optional[pulumi.Input[bool]] = None,\n volume_name: Optional[pulumi.Input[str]] = None):\n if backups_count is not None:\n pulumi.set(__self__, \"backups_count\", backups_count)\n if policy_enabled is not None:\n pulumi.set(__self__, \"policy_enabled\", policy_enabled)\n if volume_name is not None:\n pulumi.set(__self__, \"volume_name\", volume_name)","def __init__(__self__, *,\n datasource_types: pulumi.Input[Sequence[pulumi.Input[str]]],\n object_type: pulumi.Input[str],\n policy_rules: pulumi.Input[Sequence[pulumi.Input[Union['AzureBackupRuleArgs', 'AzureRetentionRuleArgs']]]]):\n pulumi.set(__self__, \"datasource_types\", datasource_types)\n pulumi.set(__self__, \"object_type\", 'BackupPolicy')\n pulumi.set(__self__, \"policy_rules\", policy_rules)","def __init__(__self__, *,\n backup_retention_settings: 'outputs.BackupRetentionSettingsResponse',\n binary_log_enabled: bool,\n enabled: bool,\n kind: str,\n location: str,\n point_in_time_recovery_enabled: bool,\n replication_log_archiving_enabled: bool,\n start_time: str,\n transaction_log_retention_days: int):\n pulumi.set(__self__, \"backup_retention_settings\", backup_retention_settings)\n pulumi.set(__self__, \"binary_log_enabled\", binary_log_enabled)\n pulumi.set(__self__, \"enabled\", enabled)\n pulumi.set(__self__, \"kind\", kind)\n pulumi.set(__self__, \"location\", location)\n pulumi.set(__self__, \"point_in_time_recovery_enabled\", point_in_time_recovery_enabled)\n pulumi.set(__self__, \"replication_log_archiving_enabled\", replication_log_archiving_enabled)\n pulumi.set(__self__, \"start_time\", start_time)\n pulumi.set(__self__, \"transaction_log_retention_days\", transaction_log_retention_days)","def __init__( self, parameters={} ):\n self.params = {}","def __init__(__self__, *,\n containers_list: Sequence[str],\n object_type: str):\n pulumi.set(__self__, \"containers_list\", containers_list)\n pulumi.set(__self__, \"object_type\", 'BlobBackupDatasourceParameters')","def __init__(self, prefix: str = None, checkpoint: str = None, **kwargs):\n self.checkpoint_dir, self.parameter = self.__version(kwargs, checkpoint, prefix)\n LOGGER.info('checkpoint: %s' % self.checkpoint_dir)\n for k, v in self.parameter.items():\n LOGGER.info(' - [arg] %s: %s' % (k, str(v)))\n self.__dict__.update(self.parameter)","def __init__(__self__, *,\n backup_delete_lock_days: Optional[pulumi.Input[int]] = None,\n backup_retain_days: Optional[pulumi.Input[int]] = None,\n locked: Optional[pulumi.Input[bool]] = None):\n if backup_delete_lock_days is not None:\n pulumi.set(__self__, \"backup_delete_lock_days\", backup_delete_lock_days)\n if backup_retain_days is not None:\n pulumi.set(__self__, \"backup_retain_days\", backup_retain_days)\n if locked is not None:\n pulumi.set(__self__, \"locked\", locked)","def __init__(self,\n backup_type=None,\n copy_partially_successful_run=None,\n extended_retention_policy_vec=None,\n granularity_bucket=None,\n id=None,\n num_days_to_keep=None,\n retention_policy=None,\n snapshot_target=None,\n ):\n\n # Initialize members of the class\n self.backup_type = backup_type\n self.copy_partially_successful_run = copy_partially_successful_run\n self.extended_retention_policy_vec = extended_retention_policy_vec\n self.granularity_bucket = granularity_bucket\n self.id = id\n self.num_days_to_keep = num_days_to_keep\n self.retention_policy = retention_policy\n self.snapshot_target = snapshot_target","def __init__(self, **parameters):\n self.parameters = parameters","def __init__(self, mongos, backup_basedir, backup_bucket=None):\n logging.info(\"Initializing BackupCluster\")\n self.backup_id = self.generate_backup_id()\n self.backup_path = os.path.join(backup_basedir, self.backup_id)\n self.backup_bucket = backup_bucket\n run(\"mkdir -p %s\" % self.backup_path)\n logging.info(\"Backup ID is %s\" % self.backup_id)\n self.mongos = BackupMongos(mongos, 'mongos', False, self.backup_id, self.backup_path, self.backup_bucket)\n shards = self.mongos.get_shards()\n if len(shards) > 0:\n self.shards = [BackupMongo(shards[shard][0], shard, shards[shard][1], self.backup_id, self.backup_path, self.backup_bucket) for shard in shards]\n else:\n self.shards = [self.mongos]\n config_servers = self.mongos.get_config_servers()\n if len(config_servers) > 0:\n self.config_server = BackupMongo(\n config_servers[-1],\n 'config',\n len(config_servers) > 1,\n self.backup_id,\n self.backup_path,\n self.backup_bucket\n )\n else:\n self.config_server = None\n self.rollback_steps = []","def __init__(__self__, *,\n backups_count: Optional[int] = None,\n policy_enabled: Optional[bool] = None,\n volume_name: Optional[str] = None):\n if backups_count is not None:\n pulumi.set(__self__, \"backups_count\", backups_count)\n if policy_enabled is not None:\n pulumi.set(__self__, \"policy_enabled\", policy_enabled)\n if volume_name is not None:\n pulumi.set(__self__, \"volume_name\", volume_name)","def __init__(self, name, config):\n self.name = name\n self.config = config\n self.logger = logging.getLogger(name)\n if 'type' not in config:\n self.config['type'] = DEFAULT_BACKUP_TYPE\n elif config['type'] not in SUPPORTED_BACKUP_TYPES:\n self.logger.error('Unknown dump type: %s', config['type'])\n sys.exit(-1)\n if 'retention' not in config:\n self.config['retention'] = DEFAULT_RETENTION_DAYS\n else:\n self.config['retention'] = int(config['retention'])","def __init__(self,\n auto_log_backup=None,\n dynamic_config=None,\n entity_support=None,\n full_backup=None,\n incr_backup=None,\n log_backup=None,\n multi_object_restore=None,\n ):\n\n # Initialize members of the class\n self.auto_log_backup = auto_log_backup\n self.dynamic_config = dynamic_config\n self.entity_support = entity_support\n self.full_backup = full_backup\n self.incr_backup = incr_backup\n self.log_backup = log_backup\n self.multi_object_restore = multi_object_restore","def __init__(self,\n application_parameters=None,\n enable_system_backup=None,\n file_paths=None,\n metadata_file_path=None,\n skip_nested_volumes_vec=None,\n uses_skip_nested_volumes_vec=None,\n volume_guid=None,\n windows_parameters=None,\n ):\n\n # Initialize members of the class\n self.application_parameters = application_parameters\n self.enable_system_backup = enable_system_backup\n self.file_paths = file_paths\n self.metadata_file_path = metadata_file_path\n self.skip_nested_volumes_vec = skip_nested_volumes_vec\n self.uses_skip_nested_volumes_vec = uses_skip_nested_volumes_vec\n self.volume_guid = volume_guid\n self.windows_parameters = windows_parameters","def __init__(__self__, *,\n backup_pool: Optional[pulumi.Input[str]] = None,\n description: Optional[pulumi.Input[str]] = None,\n failover_ratio: Optional[pulumi.Input[float]] = None,\n health_checks: Optional[pulumi.Input[str]] = None,\n instances: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n name: Optional[pulumi.Input[str]] = None,\n project: Optional[pulumi.Input[str]] = None,\n region: Optional[pulumi.Input[str]] = None,\n session_affinity: Optional[pulumi.Input[str]] = None):\n if backup_pool is not None:\n pulumi.set(__self__, \"backup_pool\", backup_pool)\n if description is not None:\n pulumi.set(__self__, \"description\", description)\n if failover_ratio is not None:\n pulumi.set(__self__, \"failover_ratio\", failover_ratio)\n if health_checks is not None:\n pulumi.set(__self__, \"health_checks\", health_checks)\n if instances is not None:\n pulumi.set(__self__, \"instances\", instances)\n if name is not None:\n pulumi.set(__self__, \"name\", name)\n if project is not None:\n pulumi.set(__self__, \"project\", project)\n if region is not None:\n pulumi.set(__self__, \"region\", region)\n if session_affinity is not None:\n pulumi.set(__self__, \"session_affinity\", session_affinity)","def __init__(self,\n db_backup_base_prefix: str,\n bucket_name: str = Config.s3_bucket,\n **ignored_kwargs):\n self.bucket_name = bucket_name\n self.ch = Config.connection_helper\n self.s3u = S3Utils(ch=self.ch, bucket=self.bucket_name)\n self.db_backup_base_prefix = self.s3u.format_as_prefix(db_backup_base_prefix)\n self.ch.init_dbs()","def __init__(self, backups=None, ddos_protection=None): # noqa: E501\n self.openapi_types = {\n 'backups': bool,\n 'ddos_protection': bool\n }\n\n self.attribute_map = {\n 'backups': 'backups',\n 'ddos_protection': 'ddos_protection'\n }\n\n self._backups = backups\n self._ddos_protection = ddos_protection","def __init__(self, params: NamedParameters):\n super().__init__()\n self.sacc_filename = params.get_string(\"sacc_filename\")","def __init__(__self__, *,\n object_type: pulumi.Input[str],\n absolute_criteria: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'AbsoluteMarker']]]]] = None,\n days_of_month: Optional[pulumi.Input[Sequence[pulumi.Input['DayArgs']]]] = None,\n days_of_the_week: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'DayOfWeek']]]]] = None,\n months_of_year: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'Month']]]]] = None,\n schedule_times: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n weeks_of_the_month: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'WeekNumber']]]]] = None):\n pulumi.set(__self__, \"object_type\", 'ScheduleBasedBackupCriteria')\n if absolute_criteria is not None:\n pulumi.set(__self__, \"absolute_criteria\", absolute_criteria)\n if days_of_month is not None:\n pulumi.set(__self__, \"days_of_month\", days_of_month)\n if days_of_the_week is not None:\n pulumi.set(__self__, \"days_of_the_week\", days_of_the_week)\n if months_of_year is not None:\n pulumi.set(__self__, \"months_of_year\", months_of_year)\n if schedule_times is not None:\n pulumi.set(__self__, \"schedule_times\", schedule_times)\n if weeks_of_the_month is not None:\n pulumi.set(__self__, \"weeks_of_the_month\", weeks_of_the_month)","def __init__(__self__, *,\n backup_pool: Optional[pulumi.Input[str]] = None,\n description: Optional[pulumi.Input[str]] = None,\n failover_ratio: Optional[pulumi.Input[float]] = None,\n health_checks: Optional[pulumi.Input[str]] = None,\n instances: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n name: Optional[pulumi.Input[str]] = None,\n project: Optional[pulumi.Input[str]] = None,\n region: Optional[pulumi.Input[str]] = None,\n self_link: Optional[pulumi.Input[str]] = None,\n session_affinity: Optional[pulumi.Input[str]] = None):\n if backup_pool is not None:\n pulumi.set(__self__, \"backup_pool\", backup_pool)\n if description is not None:\n pulumi.set(__self__, \"description\", description)\n if failover_ratio is not None:\n pulumi.set(__self__, \"failover_ratio\", failover_ratio)\n if health_checks is not None:\n pulumi.set(__self__, \"health_checks\", health_checks)\n if instances is not None:\n pulumi.set(__self__, \"instances\", instances)\n if name is not None:\n pulumi.set(__self__, \"name\", name)\n if project is not None:\n pulumi.set(__self__, \"project\", project)\n if region is not None:\n pulumi.set(__self__, \"region\", region)\n if self_link is not None:\n pulumi.set(__self__, \"self_link\", self_link)\n if session_affinity is not None:\n pulumi.set(__self__, \"session_affinity\", session_affinity)","def __init__(__self__, *,\n datasource_types: Sequence[str],\n object_type: str,\n policy_rules: Sequence[Any]):\n pulumi.set(__self__, \"datasource_types\", datasource_types)\n pulumi.set(__self__, \"object_type\", 'BackupPolicy')\n pulumi.set(__self__, \"policy_rules\", policy_rules)","def __init__(self, params):\r\n self.Params = params","def __init__(self, params):\r\n self.Params = params","def __init__(self, params):\r\n self.Params = params","def __init__(self, params):\r\n self.Params = params","def __init__(self, params):\r\n self.Params = params","def __init__(self, params):\r\n self.Params = params","def __init__(self,\n has_archival_copy=None,\n has_local_copy=None,\n has_remote_copy=None,\n modified_time_usecs=None,\n replica_info_list=None,\n size_bytes=None,\n snapshot=None,\n ):\n\n # Initialize members of the class\n self.has_archival_copy = has_archival_copy\n self.has_local_copy = has_local_copy\n self.has_remote_copy = has_remote_copy\n self.modified_time_usecs = modified_time_usecs\n self.replica_info_list = replica_info_list\n self.size_bytes = size_bytes\n self.snapshot = snapshot","def __init__(self, a=\"a\", b=\"b\"):\n self.a = a\n self.b = b","def __init__(self, dst_version):\n\n self.dst_version = dst_version","def __init__(self, dst_version):\n\n self.dst_version = dst_version","def __init__(self, dst_version):\n\n self.dst_version = dst_version","def __init__(self, **kwargs):\n members = ('ip', 'mac', 'port', 'timeout', 'flags',\n 'index', 'tag', 'hostname')\n\n # copy the given value or default to None\n for member in members:\n self.__dict__[member] = kwargs.setdefault (member, None)","def __init__(__self__, *,\n retained_backups: int,\n retention_unit: str):\n pulumi.set(__self__, \"retained_backups\", retained_backups)\n pulumi.set(__self__, \"retention_unit\", retention_unit)","def __init__(self, **kw_args):\n self._isoFmt = \"%Y%m%dT%H%M%S%z\"\n\n self._init_client_id(kw_args)\n self._init_shared_secret(kw_args)\n self._init_counter_from_time(kw_args)\n self._init_last_count(kw_args)\n self._init_last_count_update_time(kw_args)\n self._init_period(kw_args)\n self._init_password_length(kw_args)\n self._init_tags(kw_args)\n self._init_note(kw_args)","def __init__(self):\n self.__parameters: ConfigParams = ConfigParams()","def __init__(self):\n self._config = copy.copy(self._parameters)","def __init__(self, backup=None, common=None, delete=None, sync=None, remove_resources=None, replication=None, resource=None, restore=None, vault_delete=None):\n \n \n\n self._backup = None\n self._common = None\n self._delete = None\n self._sync = None\n self._remove_resources = None\n self._replication = None\n self._resource = None\n self._restore = None\n self._vault_delete = None\n self.discriminator = None\n\n if backup is not None:\n self.backup = backup\n self.common = common\n if delete is not None:\n self.delete = delete\n if sync is not None:\n self.sync = sync\n if remove_resources is not None:\n self.remove_resources = remove_resources\n if replication is not None:\n self.replication = replication\n self.resource = resource\n if restore is not None:\n self.restore = restore\n if vault_delete is not None:\n self.vault_delete = vault_delete","def __init__(self, pubkey=None):","def __init__(self, settings):\n \n # storing otmbs settings\n self.settings = settings","def __init__(self, pasajeros = 1):\n self.pasajeros = pasajeros","def __init__(self, parant):\n pass","def __init__(self, initial_params, save_name=\"model_param.joblib\"):\n super().__init__()\n self.initial_params = initial_params\n self.save_name = save_name","def __init__(self, defaults={}, data=None):\n\n super().__init__(\n defaults={**OptimizationParameters.parameters, **defaults}, data=data\n )","def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.expected_cont_uuid = None\n self.daos_cmd = None","def __init__(self, controlparams, schizparams):\n self.controlparams = controlparams\n self.schizparams = schizparams\n super(BeemanNML2Model, self).__init__(\n controlparams=controlparams, schizparams=schizparams\n )","def __init__(self, basekey=\"\"):\n self.basekey = basekey","def __init__(self, account_number: str, bank_name: str,\n starting_balance: float):\n super().__init__(account_number)\n self.bank_name = bank_name\n self.starting_balance = starting_balance\n self.current_balance = starting_balance","def __init__(self, params=None):\n if isinstance(params, SSDParams):\n self.params = params\n else:\n self.params = SSDNet.default_params","def __init__(self, s, a, b, c, d, t = None):\n self.s = s\n self.a = a\n self.b = b\n self.c = c\n self.d = d\n self.t = t","def __init__(self, globalKey, publicKey, resourceName, **rest):\n super(SshKey, self).__init__({\n \"globalKey\": globalKey,\n \"publicKey\": publicKey,\n \"resourceName\": resourceName,\n }, **rest)","def __init__(self, config):\n try:\n config['volume_id']\n config['access_key']\n config['secret_access_key']\n config['region']\n except KeyError, e:\n logging.error(repr(e))\n raise ImproperlyConfigured()\n\n if not config.has_key('keep'):\n config['keep'] = 5\n\n self.config = config","def __init__(self):\n self._params = None","def __init__(self, **kwargs):\n for name, default in self.schema.items():\n # Try to copy the default value with jsonalize's copy(), else use\n # copy.deepcopy()\n try:\n default_copy = copy(default)\n except (JSONAlizeError, TypeError):\n default_copy = deepcopy(default)\n setattr(self, name, \n unserialize(kwargs.pop(name, default_copy)))\n if kwargs:\n raise NameError(\"unknown parameters passed to constructor: %s\" %\n \", \".join(kwargs.keys()))","def __init__(self,region=None, bucket=None, keyPrefix='logs', fqdn=None):\n object.__init__(self)\n \n if (not region):\n raise MissingArgumentException(\"The AWS region name must be provided.\")\n #endIf\n self.region = region\n \n if (not bucket):\n raise MissingArgumentException(\"The S3 bucket name for the exported logs must be provided.\")\n #endIf\n self.bucket = bucket\n \n self.keyPrefix = keyPrefix\n \n if (not fqdn):\n raise MissingArgumentException(\"The FQDN of the node exporting the logs must be provided.\")\n #endIf\n self.fqdn = fqdn\n \n self.s3Helper = S3Helper(region=region)\n \n if (not self.s3Helper.bucketExists(bucket)):\n self.s3Helper.createBucket(bucket,region=region)\n #endIf","def __init__(self, *args: Any, **kwargs: Any) -> None:\n kwargs[\"aux_params\"] = None\n super().__init__(*args, **kwargs)","def __init__(__self__,\n resource_name: str,\n args: Optional[TransferConfigArgs] = None,\n opts: Optional[pulumi.ResourceOptions] = None):\n ...","def __init__(self, a=None, b=None, **kwargs):\n super().__init__(a, b, **kwargs)","def __init__(self, *, arn: str, type: \"BucketNotificationDestinationType\", dependencies: typing.Optional[typing.List[aws_cdk.core.IDependable]]=None):\n self._values = {\n 'arn': arn,\n 'type': type,\n }\n if dependencies is not None: self._values[\"dependencies\"] = dependencies","def __init__(self,\n *,\n availability_zone: str = None,\n pools: List[str] = None) -> None:\n self.availability_zone = availability_zone\n self.pools = pools","def init(self, parameters):\n pass","def __init__(\n self, datetime,\n provider, asset_license,\n ext_properties\n ):\n self.ext_properties = ext_properties\n self.license = asset_license\n self.provider = provider\n self.datetime = datetime","def __init__(self, wks, bks, wqs, bqs):\r\n self.wks = wks\r\n self.bks = bks\r\n self.wqs = wqs\r\n self.bqs = bqs","def __init__(self, bnn_omega, components):\n BaseBNNPrior.__init__(self, bnn_omega, components)\n self.params_to_exclude = []\n self.set_params_list(self.params_to_exclude)\n self.set_comps_qphi_to_e1e2()","def __init__(self, **kwargs):\n self.max_samples = get_value(kwargs, 'max_samples', types=[int], range_min=0, default_value=0)\n self.obs_filename = get_value(kwargs, 'lba_obs_file', types=[str, None], default_value=None)\n self.sample_rate = get_value(kwargs, 'sample_rate', types=[int, None], default_value=None)\n if self.sample_rate is None:\n LOG.warning(\"No sample rate provided, defaulting to {0}\".format(self._default_sample_rate))\n self.sample_rate = self._default_sample_rate\n self.antenna_name = get_value(kwargs, 'lba_antenna_name', types=[str, None], default_value=None)\n if self.obs_filename is not None and self.antenna_name is None:\n raise RuntimeError(\"LBA file is missing --lba_antenna_name parameter which is needed when using \"\n \"--lba_obs_file\")\n self.chunk_size = get_value(kwargs, 'chunk_size', types=[int], range_min=0, default_value=4096)","def __init__(self, *args, **kwargs) -> None:\n pass","def __init__(self, *args, **kwargs) -> None:\n pass","def __init__(self, num_params):\r\n self.num_params = num_params","def __init__(self, num_params):\r\n self.num_params = num_params","def __init__(self, params):\n defaults = {}\n super(Regralizer, self).__init__(params, defaults)","def __init__(self, storage_directory, backup_filepath=None):\r\n self.record = defaultdict(str)\r\n if storage_directory.endswith('\\\\') or storage_directory.endswith('/'):\r\n self.storage_directory = storage_directory\r\n else:\r\n self.storage_directory = storage_directory + '\\\\'\r\n if backup_filepath is None:\r\n self.backup = self.storage_directory + 'mover_backup.json'\r\n else:\r\n self.backup = backup_filepath\r\n if os.path.isfile(self.backup):\r\n self.load_backup()\r\n logging.info('Initialized Backup')","def __init__(self, n_jobs=1, verbose=True):\n self.n_jobs = n_jobs\n self.verbose = verbose","def __init__(self, mesh, **kwargs):\n Parameters = namedtuple(\"Parameters\", [\"C\", \"a\", \"b\", \"gl\", \"El\", \"Delta_t\", \"Vt\", \"tau_w\"])\n default_params = {\"C\" : 281, # Membrane capacitance (pF)\n \"gl\" : 30, # Leak conductance (ns) \n \"El\" : -70.6, # Leak reversal potential (mV)\n \"Vt\" : -50.4, # Spike threshold (mV)\n \"Delta_t\" : 2, # Slop factor (mV)\n \"tau_w\" : 144, # Adaptation time constant (ms)\n \"a\" : 4, # Subthreshold adaptation (nS)\n \"b\" : 0.085 # Spike-triggered adaptation (nA) \n }\n\n # Make sure input parameters only has keys in default params \n assert set(kwargs.keys()) <= set(default_params)\n\n for key in defaultparams:\n defaultparams[key] = Constant(params[key])\n\n self.mesh = mesh\n self.params = Parameters(**default_params) # parameters subscriptable by name","def __init__(self, sk=None, n=None, h=None):\r\n if sk:\r\n self.n = sk.n\r\n self.h = sk.h\r\n elif n and h:\r\n self.n = n\r\n self.h = h\r\n else:\r\n raise Exception(\"Public Key construction failed: insufficient/wrong arguments\")\r\n\r\n self.signature_bound = Params[self.n][\"sig_bound\"]\r\n self.sig_bytelen = Params[self.n][\"sig_bytelen\"]","def __init__(__self__, *,\n object_type: str,\n absolute_criteria: Optional[Sequence[str]] = None,\n days_of_month: Optional[Sequence['outputs.DayResponse']] = None,\n days_of_the_week: Optional[Sequence[str]] = None,\n months_of_year: Optional[Sequence[str]] = None,\n schedule_times: Optional[Sequence[str]] = None,\n weeks_of_the_month: Optional[Sequence[str]] = None):\n pulumi.set(__self__, \"object_type\", 'ScheduleBasedBackupCriteria')\n if absolute_criteria is not None:\n pulumi.set(__self__, \"absolute_criteria\", absolute_criteria)\n if days_of_month is not None:\n pulumi.set(__self__, \"days_of_month\", days_of_month)\n if days_of_the_week is not None:\n pulumi.set(__self__, \"days_of_the_week\", days_of_the_week)\n if months_of_year is not None:\n pulumi.set(__self__, \"months_of_year\", months_of_year)\n if schedule_times is not None:\n pulumi.set(__self__, \"schedule_times\", schedule_times)\n if weeks_of_the_month is not None:\n pulumi.set(__self__, \"weeks_of_the_month\", weeks_of_the_month)","def __init__(self, **kwargs):\n\t\tself.__c_version = c_singlezone(**kwargs)","def __init__(self, metadata, environment, component, image, version, s3_bucket, exec_env):\n self.environment = environment\n self.component = component\n self.s3_bucket = s3_bucket\n self.exec_env = exec_env\n self.image = image\n self.version = version\n self.metadata = metadata\n\n # generate Terragrunt config as part of object initialisation\n self.config()","def __init__(self, tamanho_bateria: int = 75):\n self.tamanho_bateria = tamanho_bateria","def __init__(self, **kwargs):\n pass","def __init__(self, **kwargs):\n pass","def __init__(self, **kwargs):\n pass","def __init__(self):\n self.params = arcpy.GetParameterInfo()","def __init__(self, address, **kwargs):\n super(ZVA, self).__init__(address, **kwargs)\n self.resource.timeout = kwargs.get(\"timeout\", 2000)\n self.scpi = rs_zva_scpi.SCPI(self.resource)\n self.use_ascii() # less likely to cause problems than use_binary","def __init__(self):\n # load files\n self.init_bin_start_time = load_last_bin_time()\n self.prev_value_cache = load_prev_val_cache()\n self.init_job_vals_dict = load_job_init_vals()\n\n config = load_config()\n self.database_domain = config[ConfigFields.DATABASE_DOMAIN]\n self.metrics = config[ConfigFields.METRICS]\n self.bin_duration = config[ConfigFields.BIN_DURATION]\n\n \"to be overwritten when server time is found in a job\"\n self.current_time = int(time.time())\n self.bin_start_times = None # updated below\n self.final_bin_end_time = None # updated below\n self.update_bin_times() # updates","def _create_bsm_params(self):\n return dict(\n data_usage_key=self.usage_key,\n data_version='DV',\n data_edit_timestamp=now(),\n transformers_schema_version='TV',\n block_structure_schema_version=str(1),\n )","def __init__(self, parameters, learning_rate):\n self.parameters = parameters\n self.learning_rate = learning_rate","def __init__(self, a, b):\n self.a = a\n self.b = b","def __init__(__self__, *,\n acl_name: Optional[pulumi.Input[str]] = None,\n arn: Optional[pulumi.Input[str]] = None,\n auto_minor_version_upgrade: Optional[pulumi.Input[bool]] = None,\n cluster_endpoints: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterClusterEndpointArgs']]]] = None,\n data_tiering: Optional[pulumi.Input[bool]] = None,\n description: Optional[pulumi.Input[str]] = None,\n engine_patch_version: Optional[pulumi.Input[str]] = None,\n engine_version: Optional[pulumi.Input[str]] = None,\n final_snapshot_name: Optional[pulumi.Input[str]] = None,\n kms_key_arn: Optional[pulumi.Input[str]] = None,\n maintenance_window: Optional[pulumi.Input[str]] = None,\n name: Optional[pulumi.Input[str]] = None,\n name_prefix: Optional[pulumi.Input[str]] = None,\n node_type: Optional[pulumi.Input[str]] = None,\n num_replicas_per_shard: Optional[pulumi.Input[int]] = None,\n num_shards: Optional[pulumi.Input[int]] = None,\n parameter_group_name: Optional[pulumi.Input[str]] = None,\n port: Optional[pulumi.Input[int]] = None,\n security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n shards: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterShardArgs']]]] = None,\n snapshot_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n snapshot_name: Optional[pulumi.Input[str]] = None,\n snapshot_retention_limit: Optional[pulumi.Input[int]] = None,\n snapshot_window: Optional[pulumi.Input[str]] = None,\n sns_topic_arn: Optional[pulumi.Input[str]] = None,\n subnet_group_name: Optional[pulumi.Input[str]] = None,\n tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,\n tags_all: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,\n tls_enabled: Optional[pulumi.Input[bool]] = None):\n if acl_name is not None:\n pulumi.set(__self__, \"acl_name\", acl_name)\n if arn is not None:\n pulumi.set(__self__, \"arn\", arn)\n if auto_minor_version_upgrade is not None:\n pulumi.set(__self__, \"auto_minor_version_upgrade\", auto_minor_version_upgrade)\n if cluster_endpoints is not None:\n pulumi.set(__self__, \"cluster_endpoints\", cluster_endpoints)\n if data_tiering is not None:\n pulumi.set(__self__, \"data_tiering\", data_tiering)\n if description is not None:\n pulumi.set(__self__, \"description\", description)\n if engine_patch_version is not None:\n pulumi.set(__self__, \"engine_patch_version\", engine_patch_version)\n if engine_version is not None:\n pulumi.set(__self__, \"engine_version\", engine_version)\n if final_snapshot_name is not None:\n pulumi.set(__self__, \"final_snapshot_name\", final_snapshot_name)\n if kms_key_arn is not None:\n pulumi.set(__self__, \"kms_key_arn\", kms_key_arn)\n if maintenance_window is not None:\n pulumi.set(__self__, \"maintenance_window\", maintenance_window)\n if name is not None:\n pulumi.set(__self__, \"name\", name)\n if name_prefix is not None:\n pulumi.set(__self__, \"name_prefix\", name_prefix)\n if node_type is not None:\n pulumi.set(__self__, \"node_type\", node_type)\n if num_replicas_per_shard is not None:\n pulumi.set(__self__, \"num_replicas_per_shard\", num_replicas_per_shard)\n if num_shards is not None:\n pulumi.set(__self__, \"num_shards\", num_shards)\n if parameter_group_name is not None:\n pulumi.set(__self__, \"parameter_group_name\", parameter_group_name)\n if port is not None:\n pulumi.set(__self__, \"port\", port)\n if security_group_ids is not None:\n pulumi.set(__self__, \"security_group_ids\", security_group_ids)\n if shards is not None:\n pulumi.set(__self__, \"shards\", shards)\n if snapshot_arns is not None:\n pulumi.set(__self__, \"snapshot_arns\", snapshot_arns)\n if snapshot_name is not None:\n pulumi.set(__self__, \"snapshot_name\", snapshot_name)\n if snapshot_retention_limit is not None:\n pulumi.set(__self__, \"snapshot_retention_limit\", snapshot_retention_limit)\n if snapshot_window is not None:\n pulumi.set(__self__, \"snapshot_window\", snapshot_window)\n if sns_topic_arn is not None:\n pulumi.set(__self__, \"sns_topic_arn\", sns_topic_arn)\n if subnet_group_name is not None:\n pulumi.set(__self__, \"subnet_group_name\", subnet_group_name)\n if tags is not None:\n pulumi.set(__self__, \"tags\", tags)\n if tags_all is not None:\n pulumi.set(__self__, \"tags_all\", tags_all)\n if tls_enabled is not None:\n pulumi.set(__self__, \"tls_enabled\", tls_enabled)","def __init__(self, *args, **kwargs):\n if kwargs:\n for key, value in kwargs.items():\n if key in ('created_at', 'updated_at'):\n date = datetime.strptime(value, '%Y-%m-%dT%H:%M:%S.%f')\n setattr(self, key, date)\n elif key != '__class__':\n setattr(self, key, value)\n else:\n self.id = str(uuid.uuid4())\n self.created_at = datetime.now()\n self.updated_at = datetime.now()\n models.storage.new(self)","def __init__(self, *args, **kwargs):\n if kwargs or len(kwargs) != 0:\n for key, value in kwargs.items():\n if key == \"id\":\n self.id = value\n elif key == \"created_at\" or key == \"updated_at\":\n self.__dict__[key] = datetime.strptime(\n value, \"%Y-%m-%dT%H:%M:%S.%f\")\n else:\n self.__dict__[key] = value\n else:\n self.id = str(uuid.uuid4())\n self.created_at = datetime.now()\n self.updated_at = datetime.now()\n models.storage.new(self)","def __init__(self,\n bgp_asn: int,\n created_at: datetime,\n crn: str,\n global_: bool,\n id: str,\n location_display_name: str,\n location_name: str,\n metered: bool,\n name: str,\n operational_status: str,\n speed_mbps: int,\n type: str,\n *,\n bgp_base_cidr: str = None,\n bgp_cer_cidr: str = None,\n bgp_ibm_asn: int = None,\n bgp_ibm_cidr: str = None,\n bgp_status: str = None,\n change_request: 'GatewayChangeRequest' = None,\n completion_notice_reject_reason: str = None,\n cross_connect_router: str = None,\n dedicated_hosting_id: str = None,\n link_status: str = None,\n port: 'GatewayPort' = None,\n provider_api_managed: bool = None,\n resource_group: 'ResourceGroupReference' = None,\n vlan: int = None) -> None:\n self.bgp_asn = bgp_asn\n self.bgp_base_cidr = bgp_base_cidr\n self.bgp_cer_cidr = bgp_cer_cidr\n self.bgp_ibm_asn = bgp_ibm_asn\n self.bgp_ibm_cidr = bgp_ibm_cidr\n self.bgp_status = bgp_status\n self.change_request = change_request\n self.completion_notice_reject_reason = completion_notice_reject_reason\n self.created_at = created_at\n self.crn = crn\n self.cross_connect_router = cross_connect_router\n self.dedicated_hosting_id = dedicated_hosting_id\n self.global_ = global_\n self.id = id\n self.link_status = link_status\n self.location_display_name = location_display_name\n self.location_name = location_name\n self.metered = metered\n self.name = name\n self.operational_status = operational_status\n self.port = port\n self.provider_api_managed = provider_api_managed\n self.resource_group = resource_group\n self.speed_mbps = speed_mbps\n self.type = type\n self.vlan = vlan","def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.server_count = None\n self.ec_container = None\n self.cont_uuid = []","def __init__(self,\n application_restore_objects=None,\n hosting_protection_source=None,\n ):\n\n # Initialize members of the class\n self.application_restore_objects = application_restore_objects\n self.hosting_protection_source = hosting_protection_source"],"string":"[\n \"def __init__(__self__, *,\\n include_cluster_scope_resources: pulumi.Input[bool],\\n object_type: pulumi.Input[str],\\n snapshot_volumes: pulumi.Input[bool],\\n excluded_namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n excluded_resource_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n included_namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n included_resource_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n label_selectors: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):\\n pulumi.set(__self__, \\\"include_cluster_scope_resources\\\", include_cluster_scope_resources)\\n pulumi.set(__self__, \\\"object_type\\\", 'KubernetesClusterBackupDatasourceParameters')\\n pulumi.set(__self__, \\\"snapshot_volumes\\\", snapshot_volumes)\\n if excluded_namespaces is not None:\\n pulumi.set(__self__, \\\"excluded_namespaces\\\", excluded_namespaces)\\n if excluded_resource_types is not None:\\n pulumi.set(__self__, \\\"excluded_resource_types\\\", excluded_resource_types)\\n if included_namespaces is not None:\\n pulumi.set(__self__, \\\"included_namespaces\\\", included_namespaces)\\n if included_resource_types is not None:\\n pulumi.set(__self__, \\\"included_resource_types\\\", included_resource_types)\\n if label_selectors is not None:\\n pulumi.set(__self__, \\\"label_selectors\\\", label_selectors)\",\n \"def __init__(self,\\n backup_file_path=None,\\n excluded_file_paths=None,\\n skip_nested_volumes=None,\\n ):\\n\\n # Initialize members of the class\\n self.backup_file_path = backup_file_path\\n self.excluded_file_paths = excluded_file_paths\\n self.skip_nested_volumes = skip_nested_volumes\",\n \"def __init__(__self__, *,\\n backup: Optional[pulumi.Input['VolumeBackupPropertiesArgs']] = None,\\n replication: Optional[pulumi.Input['ReplicationObjectArgs']] = None,\\n snapshot: Optional[pulumi.Input['VolumeSnapshotPropertiesArgs']] = None):\\n if backup is not None:\\n pulumi.set(__self__, \\\"backup\\\", backup)\\n if replication is not None:\\n pulumi.set(__self__, \\\"replication\\\", replication)\\n if snapshot is not None:\\n pulumi.set(__self__, \\\"snapshot\\\", snapshot)\",\n \"def __init__(__self__, *,\\n include_cluster_scope_resources: bool,\\n object_type: str,\\n snapshot_volumes: bool,\\n excluded_namespaces: Optional[Sequence[str]] = None,\\n excluded_resource_types: Optional[Sequence[str]] = None,\\n included_namespaces: Optional[Sequence[str]] = None,\\n included_resource_types: Optional[Sequence[str]] = None,\\n label_selectors: Optional[Sequence[str]] = None):\\n pulumi.set(__self__, \\\"include_cluster_scope_resources\\\", include_cluster_scope_resources)\\n pulumi.set(__self__, \\\"object_type\\\", 'KubernetesClusterBackupDatasourceParameters')\\n pulumi.set(__self__, \\\"snapshot_volumes\\\", snapshot_volumes)\\n if excluded_namespaces is not None:\\n pulumi.set(__self__, \\\"excluded_namespaces\\\", excluded_namespaces)\\n if excluded_resource_types is not None:\\n pulumi.set(__self__, \\\"excluded_resource_types\\\", excluded_resource_types)\\n if included_namespaces is not None:\\n pulumi.set(__self__, \\\"included_namespaces\\\", included_namespaces)\\n if included_resource_types is not None:\\n pulumi.set(__self__, \\\"included_resource_types\\\", included_resource_types)\\n if label_selectors is not None:\\n pulumi.set(__self__, \\\"label_selectors\\\", label_selectors)\",\n \"def __init__(__self__, *,\\n containers_list: pulumi.Input[Sequence[pulumi.Input[str]]],\\n object_type: pulumi.Input[str]):\\n pulumi.set(__self__, \\\"containers_list\\\", containers_list)\\n pulumi.set(__self__, \\\"object_type\\\", 'BlobBackupDatasourceParameters')\",\n \"def __init__(self, ip, mnode, backups):\\n self.vip = ip\\n self.main_node = mnode\\n self.backups = backups\",\n \"def __init__(__self__, *,\\n backups_count: Optional[pulumi.Input[int]] = None,\\n policy_enabled: Optional[pulumi.Input[bool]] = None,\\n volume_name: Optional[pulumi.Input[str]] = None):\\n if backups_count is not None:\\n pulumi.set(__self__, \\\"backups_count\\\", backups_count)\\n if policy_enabled is not None:\\n pulumi.set(__self__, \\\"policy_enabled\\\", policy_enabled)\\n if volume_name is not None:\\n pulumi.set(__self__, \\\"volume_name\\\", volume_name)\",\n \"def __init__(__self__, *,\\n backups_count: Optional[pulumi.Input[int]] = None,\\n policy_enabled: Optional[pulumi.Input[bool]] = None,\\n volume_name: Optional[pulumi.Input[str]] = None):\\n if backups_count is not None:\\n pulumi.set(__self__, \\\"backups_count\\\", backups_count)\\n if policy_enabled is not None:\\n pulumi.set(__self__, \\\"policy_enabled\\\", policy_enabled)\\n if volume_name is not None:\\n pulumi.set(__self__, \\\"volume_name\\\", volume_name)\",\n \"def __init__(__self__, *,\\n datasource_types: pulumi.Input[Sequence[pulumi.Input[str]]],\\n object_type: pulumi.Input[str],\\n policy_rules: pulumi.Input[Sequence[pulumi.Input[Union['AzureBackupRuleArgs', 'AzureRetentionRuleArgs']]]]):\\n pulumi.set(__self__, \\\"datasource_types\\\", datasource_types)\\n pulumi.set(__self__, \\\"object_type\\\", 'BackupPolicy')\\n pulumi.set(__self__, \\\"policy_rules\\\", policy_rules)\",\n \"def __init__(__self__, *,\\n backup_retention_settings: 'outputs.BackupRetentionSettingsResponse',\\n binary_log_enabled: bool,\\n enabled: bool,\\n kind: str,\\n location: str,\\n point_in_time_recovery_enabled: bool,\\n replication_log_archiving_enabled: bool,\\n start_time: str,\\n transaction_log_retention_days: int):\\n pulumi.set(__self__, \\\"backup_retention_settings\\\", backup_retention_settings)\\n pulumi.set(__self__, \\\"binary_log_enabled\\\", binary_log_enabled)\\n pulumi.set(__self__, \\\"enabled\\\", enabled)\\n pulumi.set(__self__, \\\"kind\\\", kind)\\n pulumi.set(__self__, \\\"location\\\", location)\\n pulumi.set(__self__, \\\"point_in_time_recovery_enabled\\\", point_in_time_recovery_enabled)\\n pulumi.set(__self__, \\\"replication_log_archiving_enabled\\\", replication_log_archiving_enabled)\\n pulumi.set(__self__, \\\"start_time\\\", start_time)\\n pulumi.set(__self__, \\\"transaction_log_retention_days\\\", transaction_log_retention_days)\",\n \"def __init__( self, parameters={} ):\\n self.params = {}\",\n \"def __init__(__self__, *,\\n containers_list: Sequence[str],\\n object_type: str):\\n pulumi.set(__self__, \\\"containers_list\\\", containers_list)\\n pulumi.set(__self__, \\\"object_type\\\", 'BlobBackupDatasourceParameters')\",\n \"def __init__(self, prefix: str = None, checkpoint: str = None, **kwargs):\\n self.checkpoint_dir, self.parameter = self.__version(kwargs, checkpoint, prefix)\\n LOGGER.info('checkpoint: %s' % self.checkpoint_dir)\\n for k, v in self.parameter.items():\\n LOGGER.info(' - [arg] %s: %s' % (k, str(v)))\\n self.__dict__.update(self.parameter)\",\n \"def __init__(__self__, *,\\n backup_delete_lock_days: Optional[pulumi.Input[int]] = None,\\n backup_retain_days: Optional[pulumi.Input[int]] = None,\\n locked: Optional[pulumi.Input[bool]] = None):\\n if backup_delete_lock_days is not None:\\n pulumi.set(__self__, \\\"backup_delete_lock_days\\\", backup_delete_lock_days)\\n if backup_retain_days is not None:\\n pulumi.set(__self__, \\\"backup_retain_days\\\", backup_retain_days)\\n if locked is not None:\\n pulumi.set(__self__, \\\"locked\\\", locked)\",\n \"def __init__(self,\\n backup_type=None,\\n copy_partially_successful_run=None,\\n extended_retention_policy_vec=None,\\n granularity_bucket=None,\\n id=None,\\n num_days_to_keep=None,\\n retention_policy=None,\\n snapshot_target=None,\\n ):\\n\\n # Initialize members of the class\\n self.backup_type = backup_type\\n self.copy_partially_successful_run = copy_partially_successful_run\\n self.extended_retention_policy_vec = extended_retention_policy_vec\\n self.granularity_bucket = granularity_bucket\\n self.id = id\\n self.num_days_to_keep = num_days_to_keep\\n self.retention_policy = retention_policy\\n self.snapshot_target = snapshot_target\",\n \"def __init__(self, **parameters):\\n self.parameters = parameters\",\n \"def __init__(self, mongos, backup_basedir, backup_bucket=None):\\n logging.info(\\\"Initializing BackupCluster\\\")\\n self.backup_id = self.generate_backup_id()\\n self.backup_path = os.path.join(backup_basedir, self.backup_id)\\n self.backup_bucket = backup_bucket\\n run(\\\"mkdir -p %s\\\" % self.backup_path)\\n logging.info(\\\"Backup ID is %s\\\" % self.backup_id)\\n self.mongos = BackupMongos(mongos, 'mongos', False, self.backup_id, self.backup_path, self.backup_bucket)\\n shards = self.mongos.get_shards()\\n if len(shards) > 0:\\n self.shards = [BackupMongo(shards[shard][0], shard, shards[shard][1], self.backup_id, self.backup_path, self.backup_bucket) for shard in shards]\\n else:\\n self.shards = [self.mongos]\\n config_servers = self.mongos.get_config_servers()\\n if len(config_servers) > 0:\\n self.config_server = BackupMongo(\\n config_servers[-1],\\n 'config',\\n len(config_servers) > 1,\\n self.backup_id,\\n self.backup_path,\\n self.backup_bucket\\n )\\n else:\\n self.config_server = None\\n self.rollback_steps = []\",\n \"def __init__(__self__, *,\\n backups_count: Optional[int] = None,\\n policy_enabled: Optional[bool] = None,\\n volume_name: Optional[str] = None):\\n if backups_count is not None:\\n pulumi.set(__self__, \\\"backups_count\\\", backups_count)\\n if policy_enabled is not None:\\n pulumi.set(__self__, \\\"policy_enabled\\\", policy_enabled)\\n if volume_name is not None:\\n pulumi.set(__self__, \\\"volume_name\\\", volume_name)\",\n \"def __init__(self, name, config):\\n self.name = name\\n self.config = config\\n self.logger = logging.getLogger(name)\\n if 'type' not in config:\\n self.config['type'] = DEFAULT_BACKUP_TYPE\\n elif config['type'] not in SUPPORTED_BACKUP_TYPES:\\n self.logger.error('Unknown dump type: %s', config['type'])\\n sys.exit(-1)\\n if 'retention' not in config:\\n self.config['retention'] = DEFAULT_RETENTION_DAYS\\n else:\\n self.config['retention'] = int(config['retention'])\",\n \"def __init__(self,\\n auto_log_backup=None,\\n dynamic_config=None,\\n entity_support=None,\\n full_backup=None,\\n incr_backup=None,\\n log_backup=None,\\n multi_object_restore=None,\\n ):\\n\\n # Initialize members of the class\\n self.auto_log_backup = auto_log_backup\\n self.dynamic_config = dynamic_config\\n self.entity_support = entity_support\\n self.full_backup = full_backup\\n self.incr_backup = incr_backup\\n self.log_backup = log_backup\\n self.multi_object_restore = multi_object_restore\",\n \"def __init__(self,\\n application_parameters=None,\\n enable_system_backup=None,\\n file_paths=None,\\n metadata_file_path=None,\\n skip_nested_volumes_vec=None,\\n uses_skip_nested_volumes_vec=None,\\n volume_guid=None,\\n windows_parameters=None,\\n ):\\n\\n # Initialize members of the class\\n self.application_parameters = application_parameters\\n self.enable_system_backup = enable_system_backup\\n self.file_paths = file_paths\\n self.metadata_file_path = metadata_file_path\\n self.skip_nested_volumes_vec = skip_nested_volumes_vec\\n self.uses_skip_nested_volumes_vec = uses_skip_nested_volumes_vec\\n self.volume_guid = volume_guid\\n self.windows_parameters = windows_parameters\",\n \"def __init__(__self__, *,\\n backup_pool: Optional[pulumi.Input[str]] = None,\\n description: Optional[pulumi.Input[str]] = None,\\n failover_ratio: Optional[pulumi.Input[float]] = None,\\n health_checks: Optional[pulumi.Input[str]] = None,\\n instances: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n name: Optional[pulumi.Input[str]] = None,\\n project: Optional[pulumi.Input[str]] = None,\\n region: Optional[pulumi.Input[str]] = None,\\n session_affinity: Optional[pulumi.Input[str]] = None):\\n if backup_pool is not None:\\n pulumi.set(__self__, \\\"backup_pool\\\", backup_pool)\\n if description is not None:\\n pulumi.set(__self__, \\\"description\\\", description)\\n if failover_ratio is not None:\\n pulumi.set(__self__, \\\"failover_ratio\\\", failover_ratio)\\n if health_checks is not None:\\n pulumi.set(__self__, \\\"health_checks\\\", health_checks)\\n if instances is not None:\\n pulumi.set(__self__, \\\"instances\\\", instances)\\n if name is not None:\\n pulumi.set(__self__, \\\"name\\\", name)\\n if project is not None:\\n pulumi.set(__self__, \\\"project\\\", project)\\n if region is not None:\\n pulumi.set(__self__, \\\"region\\\", region)\\n if session_affinity is not None:\\n pulumi.set(__self__, \\\"session_affinity\\\", session_affinity)\",\n \"def __init__(self,\\n db_backup_base_prefix: str,\\n bucket_name: str = Config.s3_bucket,\\n **ignored_kwargs):\\n self.bucket_name = bucket_name\\n self.ch = Config.connection_helper\\n self.s3u = S3Utils(ch=self.ch, bucket=self.bucket_name)\\n self.db_backup_base_prefix = self.s3u.format_as_prefix(db_backup_base_prefix)\\n self.ch.init_dbs()\",\n \"def __init__(self, backups=None, ddos_protection=None): # noqa: E501\\n self.openapi_types = {\\n 'backups': bool,\\n 'ddos_protection': bool\\n }\\n\\n self.attribute_map = {\\n 'backups': 'backups',\\n 'ddos_protection': 'ddos_protection'\\n }\\n\\n self._backups = backups\\n self._ddos_protection = ddos_protection\",\n \"def __init__(self, params: NamedParameters):\\n super().__init__()\\n self.sacc_filename = params.get_string(\\\"sacc_filename\\\")\",\n \"def __init__(__self__, *,\\n object_type: pulumi.Input[str],\\n absolute_criteria: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'AbsoluteMarker']]]]] = None,\\n days_of_month: Optional[pulumi.Input[Sequence[pulumi.Input['DayArgs']]]] = None,\\n days_of_the_week: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'DayOfWeek']]]]] = None,\\n months_of_year: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'Month']]]]] = None,\\n schedule_times: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n weeks_of_the_month: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'WeekNumber']]]]] = None):\\n pulumi.set(__self__, \\\"object_type\\\", 'ScheduleBasedBackupCriteria')\\n if absolute_criteria is not None:\\n pulumi.set(__self__, \\\"absolute_criteria\\\", absolute_criteria)\\n if days_of_month is not None:\\n pulumi.set(__self__, \\\"days_of_month\\\", days_of_month)\\n if days_of_the_week is not None:\\n pulumi.set(__self__, \\\"days_of_the_week\\\", days_of_the_week)\\n if months_of_year is not None:\\n pulumi.set(__self__, \\\"months_of_year\\\", months_of_year)\\n if schedule_times is not None:\\n pulumi.set(__self__, \\\"schedule_times\\\", schedule_times)\\n if weeks_of_the_month is not None:\\n pulumi.set(__self__, \\\"weeks_of_the_month\\\", weeks_of_the_month)\",\n \"def __init__(__self__, *,\\n backup_pool: Optional[pulumi.Input[str]] = None,\\n description: Optional[pulumi.Input[str]] = None,\\n failover_ratio: Optional[pulumi.Input[float]] = None,\\n health_checks: Optional[pulumi.Input[str]] = None,\\n instances: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n name: Optional[pulumi.Input[str]] = None,\\n project: Optional[pulumi.Input[str]] = None,\\n region: Optional[pulumi.Input[str]] = None,\\n self_link: Optional[pulumi.Input[str]] = None,\\n session_affinity: Optional[pulumi.Input[str]] = None):\\n if backup_pool is not None:\\n pulumi.set(__self__, \\\"backup_pool\\\", backup_pool)\\n if description is not None:\\n pulumi.set(__self__, \\\"description\\\", description)\\n if failover_ratio is not None:\\n pulumi.set(__self__, \\\"failover_ratio\\\", failover_ratio)\\n if health_checks is not None:\\n pulumi.set(__self__, \\\"health_checks\\\", health_checks)\\n if instances is not None:\\n pulumi.set(__self__, \\\"instances\\\", instances)\\n if name is not None:\\n pulumi.set(__self__, \\\"name\\\", name)\\n if project is not None:\\n pulumi.set(__self__, \\\"project\\\", project)\\n if region is not None:\\n pulumi.set(__self__, \\\"region\\\", region)\\n if self_link is not None:\\n pulumi.set(__self__, \\\"self_link\\\", self_link)\\n if session_affinity is not None:\\n pulumi.set(__self__, \\\"session_affinity\\\", session_affinity)\",\n \"def __init__(__self__, *,\\n datasource_types: Sequence[str],\\n object_type: str,\\n policy_rules: Sequence[Any]):\\n pulumi.set(__self__, \\\"datasource_types\\\", datasource_types)\\n pulumi.set(__self__, \\\"object_type\\\", 'BackupPolicy')\\n pulumi.set(__self__, \\\"policy_rules\\\", policy_rules)\",\n \"def __init__(self, params):\\r\\n self.Params = params\",\n \"def __init__(self, params):\\r\\n self.Params = params\",\n \"def __init__(self, params):\\r\\n self.Params = params\",\n \"def __init__(self, params):\\r\\n self.Params = params\",\n \"def __init__(self, params):\\r\\n self.Params = params\",\n \"def __init__(self, params):\\r\\n self.Params = params\",\n \"def __init__(self,\\n has_archival_copy=None,\\n has_local_copy=None,\\n has_remote_copy=None,\\n modified_time_usecs=None,\\n replica_info_list=None,\\n size_bytes=None,\\n snapshot=None,\\n ):\\n\\n # Initialize members of the class\\n self.has_archival_copy = has_archival_copy\\n self.has_local_copy = has_local_copy\\n self.has_remote_copy = has_remote_copy\\n self.modified_time_usecs = modified_time_usecs\\n self.replica_info_list = replica_info_list\\n self.size_bytes = size_bytes\\n self.snapshot = snapshot\",\n \"def __init__(self, a=\\\"a\\\", b=\\\"b\\\"):\\n self.a = a\\n self.b = b\",\n \"def __init__(self, dst_version):\\n\\n self.dst_version = dst_version\",\n \"def __init__(self, dst_version):\\n\\n self.dst_version = dst_version\",\n \"def __init__(self, dst_version):\\n\\n self.dst_version = dst_version\",\n \"def __init__(self, **kwargs):\\n members = ('ip', 'mac', 'port', 'timeout', 'flags',\\n 'index', 'tag', 'hostname')\\n\\n # copy the given value or default to None\\n for member in members:\\n self.__dict__[member] = kwargs.setdefault (member, None)\",\n \"def __init__(__self__, *,\\n retained_backups: int,\\n retention_unit: str):\\n pulumi.set(__self__, \\\"retained_backups\\\", retained_backups)\\n pulumi.set(__self__, \\\"retention_unit\\\", retention_unit)\",\n \"def __init__(self, **kw_args):\\n self._isoFmt = \\\"%Y%m%dT%H%M%S%z\\\"\\n\\n self._init_client_id(kw_args)\\n self._init_shared_secret(kw_args)\\n self._init_counter_from_time(kw_args)\\n self._init_last_count(kw_args)\\n self._init_last_count_update_time(kw_args)\\n self._init_period(kw_args)\\n self._init_password_length(kw_args)\\n self._init_tags(kw_args)\\n self._init_note(kw_args)\",\n \"def __init__(self):\\n self.__parameters: ConfigParams = ConfigParams()\",\n \"def __init__(self):\\n self._config = copy.copy(self._parameters)\",\n \"def __init__(self, backup=None, common=None, delete=None, sync=None, remove_resources=None, replication=None, resource=None, restore=None, vault_delete=None):\\n \\n \\n\\n self._backup = None\\n self._common = None\\n self._delete = None\\n self._sync = None\\n self._remove_resources = None\\n self._replication = None\\n self._resource = None\\n self._restore = None\\n self._vault_delete = None\\n self.discriminator = None\\n\\n if backup is not None:\\n self.backup = backup\\n self.common = common\\n if delete is not None:\\n self.delete = delete\\n if sync is not None:\\n self.sync = sync\\n if remove_resources is not None:\\n self.remove_resources = remove_resources\\n if replication is not None:\\n self.replication = replication\\n self.resource = resource\\n if restore is not None:\\n self.restore = restore\\n if vault_delete is not None:\\n self.vault_delete = vault_delete\",\n \"def __init__(self, pubkey=None):\",\n \"def __init__(self, settings):\\n \\n # storing otmbs settings\\n self.settings = settings\",\n \"def __init__(self, pasajeros = 1):\\n self.pasajeros = pasajeros\",\n \"def __init__(self, parant):\\n pass\",\n \"def __init__(self, initial_params, save_name=\\\"model_param.joblib\\\"):\\n super().__init__()\\n self.initial_params = initial_params\\n self.save_name = save_name\",\n \"def __init__(self, defaults={}, data=None):\\n\\n super().__init__(\\n defaults={**OptimizationParameters.parameters, **defaults}, data=data\\n )\",\n \"def __init__(self, *args, **kwargs):\\n super().__init__(*args, **kwargs)\\n self.expected_cont_uuid = None\\n self.daos_cmd = None\",\n \"def __init__(self, controlparams, schizparams):\\n self.controlparams = controlparams\\n self.schizparams = schizparams\\n super(BeemanNML2Model, self).__init__(\\n controlparams=controlparams, schizparams=schizparams\\n )\",\n \"def __init__(self, basekey=\\\"\\\"):\\n self.basekey = basekey\",\n \"def __init__(self, account_number: str, bank_name: str,\\n starting_balance: float):\\n super().__init__(account_number)\\n self.bank_name = bank_name\\n self.starting_balance = starting_balance\\n self.current_balance = starting_balance\",\n \"def __init__(self, params=None):\\n if isinstance(params, SSDParams):\\n self.params = params\\n else:\\n self.params = SSDNet.default_params\",\n \"def __init__(self, s, a, b, c, d, t = None):\\n self.s = s\\n self.a = a\\n self.b = b\\n self.c = c\\n self.d = d\\n self.t = t\",\n \"def __init__(self, globalKey, publicKey, resourceName, **rest):\\n super(SshKey, self).__init__({\\n \\\"globalKey\\\": globalKey,\\n \\\"publicKey\\\": publicKey,\\n \\\"resourceName\\\": resourceName,\\n }, **rest)\",\n \"def __init__(self, config):\\n try:\\n config['volume_id']\\n config['access_key']\\n config['secret_access_key']\\n config['region']\\n except KeyError, e:\\n logging.error(repr(e))\\n raise ImproperlyConfigured()\\n\\n if not config.has_key('keep'):\\n config['keep'] = 5\\n\\n self.config = config\",\n \"def __init__(self):\\n self._params = None\",\n \"def __init__(self, **kwargs):\\n for name, default in self.schema.items():\\n # Try to copy the default value with jsonalize's copy(), else use\\n # copy.deepcopy()\\n try:\\n default_copy = copy(default)\\n except (JSONAlizeError, TypeError):\\n default_copy = deepcopy(default)\\n setattr(self, name, \\n unserialize(kwargs.pop(name, default_copy)))\\n if kwargs:\\n raise NameError(\\\"unknown parameters passed to constructor: %s\\\" %\\n \\\", \\\".join(kwargs.keys()))\",\n \"def __init__(self,region=None, bucket=None, keyPrefix='logs', fqdn=None):\\n object.__init__(self)\\n \\n if (not region):\\n raise MissingArgumentException(\\\"The AWS region name must be provided.\\\")\\n #endIf\\n self.region = region\\n \\n if (not bucket):\\n raise MissingArgumentException(\\\"The S3 bucket name for the exported logs must be provided.\\\")\\n #endIf\\n self.bucket = bucket\\n \\n self.keyPrefix = keyPrefix\\n \\n if (not fqdn):\\n raise MissingArgumentException(\\\"The FQDN of the node exporting the logs must be provided.\\\")\\n #endIf\\n self.fqdn = fqdn\\n \\n self.s3Helper = S3Helper(region=region)\\n \\n if (not self.s3Helper.bucketExists(bucket)):\\n self.s3Helper.createBucket(bucket,region=region)\\n #endIf\",\n \"def __init__(self, *args: Any, **kwargs: Any) -> None:\\n kwargs[\\\"aux_params\\\"] = None\\n super().__init__(*args, **kwargs)\",\n \"def __init__(__self__,\\n resource_name: str,\\n args: Optional[TransferConfigArgs] = None,\\n opts: Optional[pulumi.ResourceOptions] = None):\\n ...\",\n \"def __init__(self, a=None, b=None, **kwargs):\\n super().__init__(a, b, **kwargs)\",\n \"def __init__(self, *, arn: str, type: \\\"BucketNotificationDestinationType\\\", dependencies: typing.Optional[typing.List[aws_cdk.core.IDependable]]=None):\\n self._values = {\\n 'arn': arn,\\n 'type': type,\\n }\\n if dependencies is not None: self._values[\\\"dependencies\\\"] = dependencies\",\n \"def __init__(self,\\n *,\\n availability_zone: str = None,\\n pools: List[str] = None) -> None:\\n self.availability_zone = availability_zone\\n self.pools = pools\",\n \"def init(self, parameters):\\n pass\",\n \"def __init__(\\n self, datetime,\\n provider, asset_license,\\n ext_properties\\n ):\\n self.ext_properties = ext_properties\\n self.license = asset_license\\n self.provider = provider\\n self.datetime = datetime\",\n \"def __init__(self, wks, bks, wqs, bqs):\\r\\n self.wks = wks\\r\\n self.bks = bks\\r\\n self.wqs = wqs\\r\\n self.bqs = bqs\",\n \"def __init__(self, bnn_omega, components):\\n BaseBNNPrior.__init__(self, bnn_omega, components)\\n self.params_to_exclude = []\\n self.set_params_list(self.params_to_exclude)\\n self.set_comps_qphi_to_e1e2()\",\n \"def __init__(self, **kwargs):\\n self.max_samples = get_value(kwargs, 'max_samples', types=[int], range_min=0, default_value=0)\\n self.obs_filename = get_value(kwargs, 'lba_obs_file', types=[str, None], default_value=None)\\n self.sample_rate = get_value(kwargs, 'sample_rate', types=[int, None], default_value=None)\\n if self.sample_rate is None:\\n LOG.warning(\\\"No sample rate provided, defaulting to {0}\\\".format(self._default_sample_rate))\\n self.sample_rate = self._default_sample_rate\\n self.antenna_name = get_value(kwargs, 'lba_antenna_name', types=[str, None], default_value=None)\\n if self.obs_filename is not None and self.antenna_name is None:\\n raise RuntimeError(\\\"LBA file is missing --lba_antenna_name parameter which is needed when using \\\"\\n \\\"--lba_obs_file\\\")\\n self.chunk_size = get_value(kwargs, 'chunk_size', types=[int], range_min=0, default_value=4096)\",\n \"def __init__(self, *args, **kwargs) -> None:\\n pass\",\n \"def __init__(self, *args, **kwargs) -> None:\\n pass\",\n \"def __init__(self, num_params):\\r\\n self.num_params = num_params\",\n \"def __init__(self, num_params):\\r\\n self.num_params = num_params\",\n \"def __init__(self, params):\\n defaults = {}\\n super(Regralizer, self).__init__(params, defaults)\",\n \"def __init__(self, storage_directory, backup_filepath=None):\\r\\n self.record = defaultdict(str)\\r\\n if storage_directory.endswith('\\\\\\\\') or storage_directory.endswith('/'):\\r\\n self.storage_directory = storage_directory\\r\\n else:\\r\\n self.storage_directory = storage_directory + '\\\\\\\\'\\r\\n if backup_filepath is None:\\r\\n self.backup = self.storage_directory + 'mover_backup.json'\\r\\n else:\\r\\n self.backup = backup_filepath\\r\\n if os.path.isfile(self.backup):\\r\\n self.load_backup()\\r\\n logging.info('Initialized Backup')\",\n \"def __init__(self, n_jobs=1, verbose=True):\\n self.n_jobs = n_jobs\\n self.verbose = verbose\",\n \"def __init__(self, mesh, **kwargs):\\n Parameters = namedtuple(\\\"Parameters\\\", [\\\"C\\\", \\\"a\\\", \\\"b\\\", \\\"gl\\\", \\\"El\\\", \\\"Delta_t\\\", \\\"Vt\\\", \\\"tau_w\\\"])\\n default_params = {\\\"C\\\" : 281, # Membrane capacitance (pF)\\n \\\"gl\\\" : 30, # Leak conductance (ns) \\n \\\"El\\\" : -70.6, # Leak reversal potential (mV)\\n \\\"Vt\\\" : -50.4, # Spike threshold (mV)\\n \\\"Delta_t\\\" : 2, # Slop factor (mV)\\n \\\"tau_w\\\" : 144, # Adaptation time constant (ms)\\n \\\"a\\\" : 4, # Subthreshold adaptation (nS)\\n \\\"b\\\" : 0.085 # Spike-triggered adaptation (nA) \\n }\\n\\n # Make sure input parameters only has keys in default params \\n assert set(kwargs.keys()) <= set(default_params)\\n\\n for key in defaultparams:\\n defaultparams[key] = Constant(params[key])\\n\\n self.mesh = mesh\\n self.params = Parameters(**default_params) # parameters subscriptable by name\",\n \"def __init__(self, sk=None, n=None, h=None):\\r\\n if sk:\\r\\n self.n = sk.n\\r\\n self.h = sk.h\\r\\n elif n and h:\\r\\n self.n = n\\r\\n self.h = h\\r\\n else:\\r\\n raise Exception(\\\"Public Key construction failed: insufficient/wrong arguments\\\")\\r\\n\\r\\n self.signature_bound = Params[self.n][\\\"sig_bound\\\"]\\r\\n self.sig_bytelen = Params[self.n][\\\"sig_bytelen\\\"]\",\n \"def __init__(__self__, *,\\n object_type: str,\\n absolute_criteria: Optional[Sequence[str]] = None,\\n days_of_month: Optional[Sequence['outputs.DayResponse']] = None,\\n days_of_the_week: Optional[Sequence[str]] = None,\\n months_of_year: Optional[Sequence[str]] = None,\\n schedule_times: Optional[Sequence[str]] = None,\\n weeks_of_the_month: Optional[Sequence[str]] = None):\\n pulumi.set(__self__, \\\"object_type\\\", 'ScheduleBasedBackupCriteria')\\n if absolute_criteria is not None:\\n pulumi.set(__self__, \\\"absolute_criteria\\\", absolute_criteria)\\n if days_of_month is not None:\\n pulumi.set(__self__, \\\"days_of_month\\\", days_of_month)\\n if days_of_the_week is not None:\\n pulumi.set(__self__, \\\"days_of_the_week\\\", days_of_the_week)\\n if months_of_year is not None:\\n pulumi.set(__self__, \\\"months_of_year\\\", months_of_year)\\n if schedule_times is not None:\\n pulumi.set(__self__, \\\"schedule_times\\\", schedule_times)\\n if weeks_of_the_month is not None:\\n pulumi.set(__self__, \\\"weeks_of_the_month\\\", weeks_of_the_month)\",\n \"def __init__(self, **kwargs):\\n\\t\\tself.__c_version = c_singlezone(**kwargs)\",\n \"def __init__(self, metadata, environment, component, image, version, s3_bucket, exec_env):\\n self.environment = environment\\n self.component = component\\n self.s3_bucket = s3_bucket\\n self.exec_env = exec_env\\n self.image = image\\n self.version = version\\n self.metadata = metadata\\n\\n # generate Terragrunt config as part of object initialisation\\n self.config()\",\n \"def __init__(self, tamanho_bateria: int = 75):\\n self.tamanho_bateria = tamanho_bateria\",\n \"def __init__(self, **kwargs):\\n pass\",\n \"def __init__(self, **kwargs):\\n pass\",\n \"def __init__(self, **kwargs):\\n pass\",\n \"def __init__(self):\\n self.params = arcpy.GetParameterInfo()\",\n \"def __init__(self, address, **kwargs):\\n super(ZVA, self).__init__(address, **kwargs)\\n self.resource.timeout = kwargs.get(\\\"timeout\\\", 2000)\\n self.scpi = rs_zva_scpi.SCPI(self.resource)\\n self.use_ascii() # less likely to cause problems than use_binary\",\n \"def __init__(self):\\n # load files\\n self.init_bin_start_time = load_last_bin_time()\\n self.prev_value_cache = load_prev_val_cache()\\n self.init_job_vals_dict = load_job_init_vals()\\n\\n config = load_config()\\n self.database_domain = config[ConfigFields.DATABASE_DOMAIN]\\n self.metrics = config[ConfigFields.METRICS]\\n self.bin_duration = config[ConfigFields.BIN_DURATION]\\n\\n \\\"to be overwritten when server time is found in a job\\\"\\n self.current_time = int(time.time())\\n self.bin_start_times = None # updated below\\n self.final_bin_end_time = None # updated below\\n self.update_bin_times() # updates\",\n \"def _create_bsm_params(self):\\n return dict(\\n data_usage_key=self.usage_key,\\n data_version='DV',\\n data_edit_timestamp=now(),\\n transformers_schema_version='TV',\\n block_structure_schema_version=str(1),\\n )\",\n \"def __init__(self, parameters, learning_rate):\\n self.parameters = parameters\\n self.learning_rate = learning_rate\",\n \"def __init__(self, a, b):\\n self.a = a\\n self.b = b\",\n \"def __init__(__self__, *,\\n acl_name: Optional[pulumi.Input[str]] = None,\\n arn: Optional[pulumi.Input[str]] = None,\\n auto_minor_version_upgrade: Optional[pulumi.Input[bool]] = None,\\n cluster_endpoints: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterClusterEndpointArgs']]]] = None,\\n data_tiering: Optional[pulumi.Input[bool]] = None,\\n description: Optional[pulumi.Input[str]] = None,\\n engine_patch_version: Optional[pulumi.Input[str]] = None,\\n engine_version: Optional[pulumi.Input[str]] = None,\\n final_snapshot_name: Optional[pulumi.Input[str]] = None,\\n kms_key_arn: Optional[pulumi.Input[str]] = None,\\n maintenance_window: Optional[pulumi.Input[str]] = None,\\n name: Optional[pulumi.Input[str]] = None,\\n name_prefix: Optional[pulumi.Input[str]] = None,\\n node_type: Optional[pulumi.Input[str]] = None,\\n num_replicas_per_shard: Optional[pulumi.Input[int]] = None,\\n num_shards: Optional[pulumi.Input[int]] = None,\\n parameter_group_name: Optional[pulumi.Input[str]] = None,\\n port: Optional[pulumi.Input[int]] = None,\\n security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n shards: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterShardArgs']]]] = None,\\n snapshot_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n snapshot_name: Optional[pulumi.Input[str]] = None,\\n snapshot_retention_limit: Optional[pulumi.Input[int]] = None,\\n snapshot_window: Optional[pulumi.Input[str]] = None,\\n sns_topic_arn: Optional[pulumi.Input[str]] = None,\\n subnet_group_name: Optional[pulumi.Input[str]] = None,\\n tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,\\n tags_all: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,\\n tls_enabled: Optional[pulumi.Input[bool]] = None):\\n if acl_name is not None:\\n pulumi.set(__self__, \\\"acl_name\\\", acl_name)\\n if arn is not None:\\n pulumi.set(__self__, \\\"arn\\\", arn)\\n if auto_minor_version_upgrade is not None:\\n pulumi.set(__self__, \\\"auto_minor_version_upgrade\\\", auto_minor_version_upgrade)\\n if cluster_endpoints is not None:\\n pulumi.set(__self__, \\\"cluster_endpoints\\\", cluster_endpoints)\\n if data_tiering is not None:\\n pulumi.set(__self__, \\\"data_tiering\\\", data_tiering)\\n if description is not None:\\n pulumi.set(__self__, \\\"description\\\", description)\\n if engine_patch_version is not None:\\n pulumi.set(__self__, \\\"engine_patch_version\\\", engine_patch_version)\\n if engine_version is not None:\\n pulumi.set(__self__, \\\"engine_version\\\", engine_version)\\n if final_snapshot_name is not None:\\n pulumi.set(__self__, \\\"final_snapshot_name\\\", final_snapshot_name)\\n if kms_key_arn is not None:\\n pulumi.set(__self__, \\\"kms_key_arn\\\", kms_key_arn)\\n if maintenance_window is not None:\\n pulumi.set(__self__, \\\"maintenance_window\\\", maintenance_window)\\n if name is not None:\\n pulumi.set(__self__, \\\"name\\\", name)\\n if name_prefix is not None:\\n pulumi.set(__self__, \\\"name_prefix\\\", name_prefix)\\n if node_type is not None:\\n pulumi.set(__self__, \\\"node_type\\\", node_type)\\n if num_replicas_per_shard is not None:\\n pulumi.set(__self__, \\\"num_replicas_per_shard\\\", num_replicas_per_shard)\\n if num_shards is not None:\\n pulumi.set(__self__, \\\"num_shards\\\", num_shards)\\n if parameter_group_name is not None:\\n pulumi.set(__self__, \\\"parameter_group_name\\\", parameter_group_name)\\n if port is not None:\\n pulumi.set(__self__, \\\"port\\\", port)\\n if security_group_ids is not None:\\n pulumi.set(__self__, \\\"security_group_ids\\\", security_group_ids)\\n if shards is not None:\\n pulumi.set(__self__, \\\"shards\\\", shards)\\n if snapshot_arns is not None:\\n pulumi.set(__self__, \\\"snapshot_arns\\\", snapshot_arns)\\n if snapshot_name is not None:\\n pulumi.set(__self__, \\\"snapshot_name\\\", snapshot_name)\\n if snapshot_retention_limit is not None:\\n pulumi.set(__self__, \\\"snapshot_retention_limit\\\", snapshot_retention_limit)\\n if snapshot_window is not None:\\n pulumi.set(__self__, \\\"snapshot_window\\\", snapshot_window)\\n if sns_topic_arn is not None:\\n pulumi.set(__self__, \\\"sns_topic_arn\\\", sns_topic_arn)\\n if subnet_group_name is not None:\\n pulumi.set(__self__, \\\"subnet_group_name\\\", subnet_group_name)\\n if tags is not None:\\n pulumi.set(__self__, \\\"tags\\\", tags)\\n if tags_all is not None:\\n pulumi.set(__self__, \\\"tags_all\\\", tags_all)\\n if tls_enabled is not None:\\n pulumi.set(__self__, \\\"tls_enabled\\\", tls_enabled)\",\n \"def __init__(self, *args, **kwargs):\\n if kwargs:\\n for key, value in kwargs.items():\\n if key in ('created_at', 'updated_at'):\\n date = datetime.strptime(value, '%Y-%m-%dT%H:%M:%S.%f')\\n setattr(self, key, date)\\n elif key != '__class__':\\n setattr(self, key, value)\\n else:\\n self.id = str(uuid.uuid4())\\n self.created_at = datetime.now()\\n self.updated_at = datetime.now()\\n models.storage.new(self)\",\n \"def __init__(self, *args, **kwargs):\\n if kwargs or len(kwargs) != 0:\\n for key, value in kwargs.items():\\n if key == \\\"id\\\":\\n self.id = value\\n elif key == \\\"created_at\\\" or key == \\\"updated_at\\\":\\n self.__dict__[key] = datetime.strptime(\\n value, \\\"%Y-%m-%dT%H:%M:%S.%f\\\")\\n else:\\n self.__dict__[key] = value\\n else:\\n self.id = str(uuid.uuid4())\\n self.created_at = datetime.now()\\n self.updated_at = datetime.now()\\n models.storage.new(self)\",\n \"def __init__(self,\\n bgp_asn: int,\\n created_at: datetime,\\n crn: str,\\n global_: bool,\\n id: str,\\n location_display_name: str,\\n location_name: str,\\n metered: bool,\\n name: str,\\n operational_status: str,\\n speed_mbps: int,\\n type: str,\\n *,\\n bgp_base_cidr: str = None,\\n bgp_cer_cidr: str = None,\\n bgp_ibm_asn: int = None,\\n bgp_ibm_cidr: str = None,\\n bgp_status: str = None,\\n change_request: 'GatewayChangeRequest' = None,\\n completion_notice_reject_reason: str = None,\\n cross_connect_router: str = None,\\n dedicated_hosting_id: str = None,\\n link_status: str = None,\\n port: 'GatewayPort' = None,\\n provider_api_managed: bool = None,\\n resource_group: 'ResourceGroupReference' = None,\\n vlan: int = None) -> None:\\n self.bgp_asn = bgp_asn\\n self.bgp_base_cidr = bgp_base_cidr\\n self.bgp_cer_cidr = bgp_cer_cidr\\n self.bgp_ibm_asn = bgp_ibm_asn\\n self.bgp_ibm_cidr = bgp_ibm_cidr\\n self.bgp_status = bgp_status\\n self.change_request = change_request\\n self.completion_notice_reject_reason = completion_notice_reject_reason\\n self.created_at = created_at\\n self.crn = crn\\n self.cross_connect_router = cross_connect_router\\n self.dedicated_hosting_id = dedicated_hosting_id\\n self.global_ = global_\\n self.id = id\\n self.link_status = link_status\\n self.location_display_name = location_display_name\\n self.location_name = location_name\\n self.metered = metered\\n self.name = name\\n self.operational_status = operational_status\\n self.port = port\\n self.provider_api_managed = provider_api_managed\\n self.resource_group = resource_group\\n self.speed_mbps = speed_mbps\\n self.type = type\\n self.vlan = vlan\",\n \"def __init__(self, *args, **kwargs):\\n super().__init__(*args, **kwargs)\\n self.server_count = None\\n self.ec_container = None\\n self.cont_uuid = []\",\n \"def __init__(self,\\n application_restore_objects=None,\\n hosting_protection_source=None,\\n ):\\n\\n # Initialize members of the class\\n self.application_restore_objects = application_restore_objects\\n self.hosting_protection_source = hosting_protection_source\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64447784","0.6168862","0.61534363","0.6098209","0.6049831","0.5995434","0.5983703","0.5983703","0.5976207","0.597005","0.59328234","0.5924585","0.59173024","0.5862991","0.58594143","0.58371496","0.58366156","0.58322644","0.5827591","0.58213955","0.5814118","0.5782552","0.5769175","0.57258916","0.57194805","0.5690385","0.56713134","0.56577224","0.5656268","0.5656268","0.5656268","0.5656268","0.5656268","0.5656268","0.5634112","0.5614861","0.56079924","0.56079924","0.56079924","0.56032753","0.5573129","0.55681497","0.55656123","0.5546508","0.55454314","0.55096203","0.54913396","0.54818636","0.5458761","0.5452138","0.5446067","0.5424715","0.5404796","0.53971255","0.5394331","0.5392237","0.53894305","0.5385469","0.53842276","0.53832865","0.53811926","0.5380283","0.53791434","0.53767776","0.5373597","0.5371915","0.5364927","0.53511006","0.53496546","0.5338709","0.53341323","0.5331324","0.53191036","0.53191036","0.5317938","0.5317938","0.5310469","0.53096515","0.5308115","0.53050756","0.53034055","0.53024745","0.52982205","0.5296039","0.52841854","0.52696097","0.52696097","0.52696097","0.52655613","0.52566135","0.52563053","0.52562535","0.5254684","0.52525926","0.5247821","0.5242507","0.5242059","0.5235213","0.5234816","0.5232636"],"string":"[\n \"0.64447784\",\n \"0.6168862\",\n \"0.61534363\",\n \"0.6098209\",\n \"0.6049831\",\n \"0.5995434\",\n \"0.5983703\",\n \"0.5983703\",\n \"0.5976207\",\n \"0.597005\",\n \"0.59328234\",\n \"0.5924585\",\n \"0.59173024\",\n \"0.5862991\",\n \"0.58594143\",\n \"0.58371496\",\n \"0.58366156\",\n \"0.58322644\",\n \"0.5827591\",\n \"0.58213955\",\n \"0.5814118\",\n \"0.5782552\",\n \"0.5769175\",\n \"0.57258916\",\n \"0.57194805\",\n \"0.5690385\",\n \"0.56713134\",\n \"0.56577224\",\n \"0.5656268\",\n \"0.5656268\",\n \"0.5656268\",\n \"0.5656268\",\n \"0.5656268\",\n \"0.5656268\",\n \"0.5634112\",\n \"0.5614861\",\n \"0.56079924\",\n \"0.56079924\",\n \"0.56079924\",\n \"0.56032753\",\n \"0.5573129\",\n \"0.55681497\",\n \"0.55656123\",\n \"0.5546508\",\n \"0.55454314\",\n \"0.55096203\",\n \"0.54913396\",\n \"0.54818636\",\n \"0.5458761\",\n \"0.5452138\",\n \"0.5446067\",\n \"0.5424715\",\n \"0.5404796\",\n \"0.53971255\",\n \"0.5394331\",\n \"0.5392237\",\n \"0.53894305\",\n \"0.5385469\",\n \"0.53842276\",\n \"0.53832865\",\n \"0.53811926\",\n \"0.5380283\",\n \"0.53791434\",\n \"0.53767776\",\n \"0.5373597\",\n \"0.5371915\",\n \"0.5364927\",\n \"0.53511006\",\n \"0.53496546\",\n \"0.5338709\",\n \"0.53341323\",\n \"0.5331324\",\n \"0.53191036\",\n \"0.53191036\",\n \"0.5317938\",\n \"0.5317938\",\n \"0.5310469\",\n \"0.53096515\",\n \"0.5308115\",\n \"0.53050756\",\n \"0.53034055\",\n \"0.53024745\",\n \"0.52982205\",\n \"0.5296039\",\n \"0.52841854\",\n \"0.52696097\",\n \"0.52696097\",\n \"0.52696097\",\n \"0.52655613\",\n \"0.52566135\",\n \"0.52563053\",\n \"0.52562535\",\n \"0.5254684\",\n \"0.52525926\",\n \"0.5247821\",\n \"0.5242507\",\n \"0.5242059\",\n \"0.5235213\",\n \"0.5234816\",\n \"0.5232636\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6467344"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83175,"cells":{"query":{"kind":"string","value":"Creates an instance of this model from a dictionary"},"document":{"kind":"string","value":"def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n backup_all_existing_snapshot = dictionary.get('backupAllExistingSnapshot')\n blacklisted_ip_addrs = dictionary.get(\"blacklistedIpAddrs\")\n continue_on_error = dictionary.get('continueOnError')\n encryption_enabled = dictionary.get('encryptionEnabled')\n filtering_policy = cohesity_management_sdk.models.filtering_policy_proto.FilteringPolicyProto.from_dictionary(dictionary.get('filteringPolicy')) if dictionary.get('filteringPolicy') else None\n fld_config = cohesity_management_sdk.models.view_id_mapping_proto_file_level_data_lock_config.ViewIdMappingProto_FileLevelDataLockConfig.from_dictionary(dictionary.get('fldConfig')) if dictionary.get('fldConfig') else None\n full_backup_snapshot_label = dictionary.get('fullBackupSnapshotLabel')\n incremental_backup_snapshot_label = dictionary.get('incrementalBackupSnapshotLabel')\n is_source_initiated_backup = dictionary.get('isSourceInitiatedBackup')\n mixed_mode_preference = dictionary.get('mixedModePreference')\n modify_source_permissions = dictionary.get('modifySourcePermissions')\n nfs_version_preference = dictionary.get('nfsVersionPreference')\n s3_viewbackupproperties = cohesity_management_sdk.models.s3_view_backup_properties.S3ViewBackupProperties.from_dictionary(dictionary.get('s3Viewbackupproperties')) if dictionary.get('s3Viewbackupproperties') else None\n shared_view_name = dictionary.get('sharedViewName')\n snapshot_change_enabled = dictionary.get('snapshotChangeEnabled')\n throttling_params = cohesity_management_sdk.models.nas_throttling_params.NasThrottlingParams.from_dictionary(dictionary.get('throttlingParams')) if dictionary.get('throttlingParams') else None\n whitelisted_ip_addrs = dictionary.get(\"whitelistedIpAddrs\")\n\n # Return an object of this model\n return cls(\n backup_all_existing_snapshot,\n blacklisted_ip_addrs,\n continue_on_error,\n encryption_enabled,\n filtering_policy,\n fld_config,\n full_backup_snapshot_label,\n incremental_backup_snapshot_label,\n is_source_initiated_backup,\n mixed_mode_preference,\n modify_source_permissions,\n nfs_version_preference,\n s3_viewbackupproperties,\n shared_view_name,\n snapshot_change_enabled,\n throttling_params,\n whitelisted_ip_addrs\n)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n id = dictionary.get('id')\n name = dictionary.get('name')\n mtype = dictionary.get('type')\n usage_bytes = dictionary.get('usageBytes')\n\n # Return an object of this model\n return cls(\n id,\n name,\n mtype,\n usage_bytes\n)","def create(cls, dictionary):\n return cls(**dictionary)","def create(cls, dictionary):\n return cls(**dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n name = dictionary.get('name')\r\n scheduling = meraki.models.scheduling_model.SchedulingModel.from_dictionary(dictionary.get('scheduling')) if dictionary.get('scheduling') else None\r\n bandwidth = meraki.models.bandwidth_model.BandwidthModel.from_dictionary(dictionary.get('bandwidth')) if dictionary.get('bandwidth') else None\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(name,\r\n scheduling,\r\n bandwidth,\r\n dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n external_ids = dictionary.get('externalIds')\r\n harsh_accel_setting = dictionary.get('harsh_accel_setting')\r\n name = dictionary.get('name')\r\n\r\n # Return an object of this model\r\n return cls(external_ids,\r\n harsh_accel_setting,\r\n name)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n formatted_price = dictionary.get('FormattedPrice')\n amount = dictionary.get('Amount')\n currency_code = dictionary.get('CurrencyCode')\n\n # Return an object of this model\n return cls(formatted_price,\n amount,\n currency_code)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n id = dictionary.get('Id')\r\n name = dictionary.get('Name')\r\n last_edited = APIHelper.RFC3339DateTime.from_value(dictionary.get(\"LastEdited\")).datetime if dictionary.get(\"LastEdited\") else None\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(id,\r\n name,\r\n last_edited,\r\n dictionary)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n mtype = dictionary.get(\"type\")\n filename = dictionary.get(\"filename\")\n payload = dictionary.get(\"payload\")\n\n # Return an object of this model\n return cls(mtype,\n filename,\n payload)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n protected_count = dictionary.get('protectedCount')\n protected_size = dictionary.get('protectedSize')\n unprotected_count = dictionary.get('unprotectedCount')\n unprotected_size = dictionary.get('unprotectedSize')\n\n # Return an object of this model\n return cls(\n protected_count,\n protected_size,\n unprotected_count,\n unprotected_size\n)","def from_dict(cls, dictionary: Dict[str, Any]):\n return cls(**dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n primary_language = dictionary.get('PrimaryLanguage')\r\n secondary_language = dictionary.get('SecondaryLanguage')\r\n xml_signature = dictionary.get('XmlSignature')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(primary_language,\r\n secondary_language,\r\n xml_signature,\r\n dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n id = dictionary.get('id')\r\n number = dictionary.get('number')\r\n name = dictionary.get('name')\r\n balance = dictionary.get('balance')\r\n mtype = dictionary.get('type')\r\n status = dictionary.get('status')\r\n customer_id = dictionary.get('customerId')\r\n institution_id = dictionary.get('institutionId')\r\n balance_date = dictionary.get('balanceDate')\r\n created_date = dictionary.get('createdDate')\r\n currency = dictionary.get('currency')\r\n institution_login_id = dictionary.get('institutionLoginId')\r\n display_position = dictionary.get('displayPosition')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(id,\r\n number,\r\n name,\r\n balance,\r\n mtype,\r\n status,\r\n customer_id,\r\n institution_id,\r\n balance_date,\r\n created_date,\r\n currency,\r\n institution_login_id,\r\n display_position,\r\n dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n links = dictionary.get('links')\r\n email_config = dictionary.get('emailConfig')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(links,\r\n email_config,\r\n dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n alias = dictionary.get(\"alias\")\r\n cnam_lookups_enabled = dictionary.get(\"cnam_lookups_enabled\")\r\n number_type = dictionary.get(\"number_type\")\r\n rate_center = dictionary.get(\"rate_center\")\r\n state = dictionary.get(\"state\")\r\n value = dictionary.get(\"value\")\r\n\r\n # Return an object of this model\r\n return cls(alias,\r\n cnam_lookups_enabled,\r\n number_type,\r\n rate_center,\r\n state,\r\n value)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n username = dictionary.get('username')\r\n first_name = dictionary.get('firstName')\r\n last_name = dictionary.get('lastName')\r\n application_id = dictionary.get('applicationId')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(username,\r\n first_name,\r\n last_name,\r\n application_id,\r\n dictionary)","def from_dict(cls, data):\n return cls(**data)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n height = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Height')) if dictionary.get('Height') else None\n length = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Length')) if dictionary.get('Length') else None\n weight = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Weight')) if dictionary.get('Weight') else None\n width = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Width')) if dictionary.get('Width') else None\n\n # Return an object of this model\n return cls(height,\n length,\n weight,\n width)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n setup = idfy_rest_client.models.setup.Setup.from_dictionary(dictionary.get('setup')) if dictionary.get('setup') else None\r\n merge_fields = dictionary.get('mergeFields')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(setup,\r\n merge_fields,\r\n dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n to = dictionary.get('to')\r\n application_id = dictionary.get('applicationId')\r\n expiration_time_in_minutes = dictionary.get('expirationTimeInMinutes')\r\n code = dictionary.get('code')\r\n scope = dictionary.get('scope')\r\n\r\n # Return an object of this model\r\n return cls(to,\r\n application_id,\r\n expiration_time_in_minutes,\r\n code,\r\n scope)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n fqdn = dictionary.get('fqdn')\n guid = dictionary.get('guid')\n id = dictionary.get('id')\n name = dictionary.get('name')\n owner_id = dictionary.get('ownerId')\n status = dictionary.get('status')\n total_size_bytes = dictionary.get('totalSizeBytes')\n\n # Return an object of this model\n return cls(\n fqdn,\n guid,\n id,\n name,\n owner_id,\n status,\n total_size_bytes\n)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n force_delete = dictionary.get('forceDelete')\n id = dictionary.get('id')\n include_marked_for_removal = dictionary.get('includeMarkedForRemoval')\n retry = dictionary.get('retry')\n\n # Return an object of this model\n return cls(\n force_delete,\n id,\n include_marked_for_removal,\n retry\n)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n account_holder_name = dictionary.get('accountHolderName')\r\n routing_number = dictionary.get('routingNumber')\r\n\r\n # Return an object of this model\r\n return cls(account_holder_name,\r\n routing_number)","def from_dict(cls, d):\n return cls(**d)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n ephemeral_public_key = dictionary.get('ephemeral_public_key')\r\n public_key_hash = dictionary.get('public_key_hash')\r\n transaction_id = dictionary.get('transaction_id')\r\n\r\n # Return an object of this model\r\n return cls(ephemeral_public_key,\r\n public_key_hash,\r\n transaction_id)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n name = dictionary.get('name')\r\n given_name = dictionary.get('givenName')\r\n middle_name = dictionary.get('middleName')\r\n family_name = dictionary.get('familyName')\r\n address = None\r\n if dictionary.get('address') != None:\r\n address = list()\r\n for structure in dictionary.get('address'):\r\n address.append(finicityapi.models.payroll_address.PayrollAddress.from_dictionary(structure))\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(name,\r\n given_name,\r\n middle_name,\r\n family_name,\r\n address,\r\n dictionary)","def from_dict(cls, dct):\n return cls(**dct)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n mor_item = dictionary.get('morItem')\n mor_type = dictionary.get('morType')\n uuid = dictionary.get('uuid')\n\n # Return an object of this model\n return cls(\n mor_item,\n mor_type,\n uuid\n)","def from_dict(cls, data: Dict[str, any]):\n return cls(**data)","def from_dict(cls, session: \"FigoSession\", data_dict: dict) -> \"ModelBase\":\n return cls(session, **data_dict)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n wind_speed = dictionary.get('windSpeed')\n power = dictionary.get('power')\n\n # Return an object of this model\n return cls(wind_speed,\n power)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n consumer_id = dictionary.get('consumerId')\r\n consumer_ssn = dictionary.get('consumerSsn')\r\n event_name = dictionary.get('eventName')\r\n id = dictionary.get('id')\r\n status = dictionary.get('status')\r\n mtype = dictionary.get('type')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(consumer_id,\r\n consumer_ssn,\r\n event_name,\r\n id,\r\n status,\r\n mtype,\r\n dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n id = dictionary.get('id')\r\n title = dictionary.get('title')\r\n device_group = dictionary.get('deviceGroup')\r\n create_on = dictionary.get('createOn')\r\n update_on = dictionary.get('updateOn')\r\n created_by = dictionary.get('createdBy')\r\n create_on_persian_date = dictionary.get('createOnPersianDate')\r\n update_on_persian_date = dictionary.get('updateOnPersianDate')\r\n device_type_brand_model_title = dictionary.get('deviceTypeBrandModelTitle')\r\n device_brand_ids = dictionary.get('deviceBrandIds')\r\n device_type_id = dictionary.get('deviceTypeId')\r\n device_brand_id = dictionary.get('deviceBrandId')\r\n updated_by = dictionary.get('updatedBy')\r\n device_type_title = dictionary.get('deviceTypeTitle')\r\n device_brand_title = dictionary.get('deviceBrandTitle')\r\n device_brands_title = dictionary.get('deviceBrandsTitle')\r\n\r\n # Return an object of this model\r\n return cls(id,\r\n title,\r\n device_group,\r\n create_on,\r\n update_on,\r\n created_by,\r\n create_on_persian_date,\r\n update_on_persian_date,\r\n device_type_brand_model_title,\r\n device_brand_ids,\r\n device_type_id,\r\n device_brand_id,\r\n updated_by,\r\n device_type_title,\r\n device_brand_title,\r\n device_brands_title)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n account_id = dictionary.get('AccountId')\r\n name = dictionary.get('Name')\r\n org_no = dictionary.get('OrgNo')\r\n uni_customer_no = dictionary.get('UniCustomerNo')\r\n created = APIHelper.RFC3339DateTime.from_value(dictionary.get(\"Created\")).datetime if dictionary.get(\"Created\") else None\r\n last_modified = APIHelper.RFC3339DateTime.from_value(dictionary.get(\"LastModified\")).datetime if dictionary.get(\"LastModified\") else None\r\n dealer_id = dictionary.get('DealerId')\r\n dealer_name = dictionary.get('DealerName')\r\n dealer_reference = dictionary.get('DealerReference')\r\n enabled = dictionary.get('Enabled')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(account_id,\r\n name,\r\n org_no,\r\n uni_customer_no,\r\n created,\r\n last_modified,\r\n dealer_id,\r\n dealer_name,\r\n dealer_reference,\r\n enabled,\r\n dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n password = dictionary.get('password')\r\n name = dictionary.get('name')\r\n tag_ids = dictionary.get('tagIds')\r\n eld_adverse_weather_exemption_enabled = dictionary.get('eldAdverseWeatherExemptionEnabled')\r\n eld_big_day_exemption_enabled = dictionary.get('eldBigDayExemptionEnabled')\r\n eld_day_start_hour = dictionary.get('eldDayStartHour')\r\n eld_exempt = dictionary.get('eldExempt')\r\n eld_exempt_reason = dictionary.get('eldExemptReason')\r\n eld_pc_enabled = dictionary.get(\"eldPcEnabled\") if dictionary.get(\"eldPcEnabled\") else False\r\n eld_ym_enabled = dictionary.get(\"eldYmEnabled\") if dictionary.get(\"eldYmEnabled\") else False\r\n external_ids = dictionary.get('externalIds')\r\n group_id = dictionary.get('groupId')\r\n license_number = dictionary.get('licenseNumber')\r\n license_state = dictionary.get('licenseState')\r\n notes = dictionary.get('notes')\r\n phone = dictionary.get('phone')\r\n username = dictionary.get('username')\r\n vehicle_id = dictionary.get('vehicleId')\r\n\r\n # Return an object of this model\r\n return cls(password,\r\n name,\r\n tag_ids,\r\n eld_adverse_weather_exemption_enabled,\r\n eld_big_day_exemption_enabled,\r\n eld_day_start_hour,\r\n eld_exempt,\r\n eld_exempt_reason,\r\n eld_pc_enabled,\r\n eld_ym_enabled,\r\n external_ids,\r\n group_id,\r\n license_number,\r\n license_state,\r\n notes,\r\n phone,\r\n username,\r\n vehicle_id)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n env_type = dictionary.get('envType')\n protected_count = dictionary.get('protectedCount')\n protected_size_bytes = dictionary.get('protectedSizeBytes')\n unprotected_count = dictionary.get('unprotectedCount')\n unprotected_size_bytes = dictionary.get('unprotectedSizeBytes')\n\n # Return an object of this model\n return cls(\n env_type,\n protected_count,\n protected_size_bytes,\n unprotected_count,\n unprotected_size_bytes\n)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n is_mail_enabled = dictionary.get('isMailEnabled')\n is_security_enabled = dictionary.get('isSecurityEnabled')\n member_count = dictionary.get('memberCount')\n visibility = dictionary.get('visibility')\n\n # Return an object of this model\n return cls(\n is_mail_enabled,\n is_security_enabled,\n member_count,\n visibility\n)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n name = dictionary.get('name')\r\n time_zone = dictionary.get('timeZone')\r\n tags = dictionary.get('tags')\r\n disable_my_meraki_com = dictionary.get('disableMyMerakiCom')\r\n disable_remote_status_page = dictionary.get('disableRemoteStatusPage')\r\n enrollment_string = dictionary.get('enrollmentString')\r\n\r\n # Return an object of this model\r\n return cls(name,\r\n time_zone,\r\n tags,\r\n disable_my_meraki_com,\r\n disable_remote_status_page,\r\n enrollment_string)","def from_dict(cls, dictionary):\n normalised = cls.normalise_dict(dictionary)\n return cls.from_normalised_dict(normalised)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n name = dictionary.get('name')\r\n lan_ip = dictionary.get('lanIp')\r\n uplink = dictionary.get('uplink')\r\n public_port = dictionary.get('publicPort')\r\n local_port = dictionary.get('localPort')\r\n allowed_ips = dictionary.get('allowedIps')\r\n protocol = dictionary.get('protocol')\r\n\r\n # Return an object of this model\r\n return cls(name,\r\n lan_ip,\r\n uplink,\r\n public_port,\r\n local_port,\r\n allowed_ips,\r\n protocol)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n found = dictionary.get('found')\r\n displaying = dictionary.get('displaying')\r\n more_available = dictionary.get('moreAvailable')\r\n created_date = dictionary.get('createdDate')\r\n institutions = None\r\n if dictionary.get('institutions') != None:\r\n institutions = list()\r\n for structure in dictionary.get('institutions'):\r\n institutions.append(finicityapi.models.institution.Institution.from_dictionary(structure))\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(found,\r\n displaying,\r\n more_available,\r\n created_date,\r\n institutions,\r\n dictionary)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n backup_file_path = dictionary.get('backupFilePath')\n excluded_file_paths = dictionary.get(\"excludedFilePaths\")\n skip_nested_volumes = dictionary.get('skipNestedVolumes')\n\n # Return an object of this model\n return cls(\n backup_file_path,\n excluded_file_paths,\n skip_nested_volumes\n)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n lowest_new_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestNewPrice')) if dictionary.get('LowestNewPrice') else None\n lowest_used_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestUsedPrice')) if dictionary.get('LowestUsedPrice') else None\n lowest_collectible_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestCollectiblePrice')) if dictionary.get('LowestCollectiblePrice') else None\n lowest_refurbished_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestRefurbishedPrice')) if dictionary.get('LowestRefurbishedPrice') else None\n total_new = dictionary.get('TotalNew')\n total_used = dictionary.get('TotalUsed')\n total_collectible = dictionary.get('TotalCollectible')\n total_refurbished = dictionary.get('TotalRefurbished')\n\n # Return an object of this model\n return cls(lowest_new_price,\n lowest_used_price,\n lowest_collectible_price,\n lowest_refurbished_price,\n total_new,\n total_used,\n total_collectible,\n total_refurbished)","def from_dict(cls, data):\r\n instance = cls()\r\n for key, value in data.items():\r\n instance.__dict__[key] = value\r\n return instance","def from_dict(cls, dictionary):\n instance = cls()\n for key, value in dictionary.items():\n instance.__dict__[key] = value\n\n return instance","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n door_closed = dictionary.get('doorClosed')\r\n id = dictionary.get('id')\r\n name = dictionary.get('name')\r\n\r\n # Return an object of this model\r\n return cls(door_closed,\r\n id,\r\n name)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n id = dictionary.get('id')\n provider_id = dictionary.get('providerId')\n server_time = dictionary.get('serverTime')\n username = dictionary.get('username')\n driver_license_number = dictionary.get('driverLicenseNumber')\n country = dictionary.get('country')\n region = dictionary.get('region')\n driver_home_terminal = dictionary.get('driverHomeTerminal')\n\n # Return an object of this model\n return cls(id,\n provider_id,\n server_time,\n username,\n driver_license_number,\n country,\n region,\n driver_home_terminal)","def from_dict(cls, data):\n instance = cls()\n instance._set_data(data)\n return instance","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n is_group_site = dictionary.get('isGroupSite')\n is_private_channel_site = dictionary.get('isPrivateChannelSite')\n is_team_site = dictionary.get('isTeamSite')\n\n # Return an object of this model\n return cls(\n is_group_site,\n is_private_channel_site,\n is_team_site\n)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n id = dictionary.get('id')\n provider_id = dictionary.get('providerId')\n server_time = dictionary.get('serverTime')\n active_from = dictionary.get('activeFrom')\n active_to = dictionary.get('activeTo')\n rpm_over_value = dictionary.get('rpmOverValue')\n over_speed_value = dictionary.get('overSpeedValue')\n excess_speed_value = dictionary.get('excessSpeedValue')\n long_idle_value = dictionary.get('longIdleValue')\n hi_throttle_value = dictionary.get('hiThrottleValue')\n\n # Return an object of this model\n return cls(id,\n provider_id,\n server_time,\n active_from,\n active_to,\n rpm_over_value,\n over_speed_value,\n excess_speed_value,\n long_idle_value,\n hi_throttle_value)","def from_dict(cls, dikt) -> 'ModelClass':\n return util.deserialize_model(dikt, cls)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n action = dictionary.get('action')\n cluster_info = dictionary.get('clusterInfo')\n details = dictionary.get('details')\n domain = dictionary.get('domain')\n entity_id = dictionary.get('entityId')\n entity_name = dictionary.get('entityName')\n entity_type = dictionary.get('entityType')\n human_timestamp = dictionary.get('humanTimestamp')\n impersonation = dictionary.get('impersonation')\n ip = dictionary.get('ip')\n new_record = dictionary.get('newRecord')\n original_tenant = cohesity_management_sdk.models.tenant.Tenant.from_dictionary(dictionary.get('originalTenant')) if dictionary.get('originalTenant') else None\n previous_record = dictionary.get('previousRecord')\n tenant = cohesity_management_sdk.models.tenant.Tenant.from_dictionary(dictionary.get('tenant')) if dictionary.get('tenant') else None\n timestamp_usecs = dictionary.get('timestampUsecs')\n user_name = dictionary.get('userName')\n\n # Return an object of this model\n return cls(\n action,\n cluster_info,\n details,\n domain,\n entity_id,\n entity_name,\n entity_type,\n human_timestamp,\n impersonation,\n ip,\n new_record,\n original_tenant,\n previous_record,\n tenant,\n timestamp_usecs,\n user_name\n)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n api_group = dictionary.get('apiGroup')\n api_version = dictionary.get('apiVersion')\n kind = dictionary.get('kind')\n name = dictionary.get('name')\n namespace = dictionary.get('namespace')\n resource_version = dictionary.get('resourceVersion')\n uid = dictionary.get('uid')\n\n # Return an object of this model\n return cls(\n api_group,\n api_version,\n kind,\n name,\n namespace,\n resource_version,\n uid\n)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n id = dictionary.get('id')\r\n consumer_id = dictionary.get('consumerId')\r\n consumer_ssn = dictionary.get('consumerSsn')\r\n requester_name = dictionary.get('requesterName')\r\n request_id = dictionary.get('requestId')\r\n constraints = finicityapi.models.report_constraints.ReportConstraints.from_dictionary(dictionary.get('constraints')) if dictionary.get('constraints') else None\r\n mtype = dictionary.get('type')\r\n status = dictionary.get('status')\r\n created_date = dictionary.get('createdDate')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(id,\r\n consumer_id,\r\n consumer_ssn,\r\n requester_name,\r\n request_id,\r\n constraints,\r\n mtype,\r\n status,\r\n created_date,\r\n dictionary)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n address = dictionary.get('address')\n port = dictionary.get('port')\n protocol = dictionary.get('protocol')\n is_cluster_auditing_enabled = dictionary.get('isClusterAuditingEnabled')\n is_data_protection_enabled = dictionary.get('isDataProtectionEnabled')\n is_filer_auditing_enabled = dictionary.get('isFilerAuditingEnabled')\n is_ssh_log_enabled = dictionary.get('isSshLogEnabled')\n name = dictionary.get('name')\n\n # Return an object of this model\n return cls(address,\n port,\n protocol,\n is_cluster_auditing_enabled,\n is_data_protection_enabled,\n is_filer_auditing_enabled,\n is_ssh_log_enabled,\n name)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n enabled = dictionary.get('enabled')\r\n spare_serial = dictionary.get('spareSerial')\r\n uplink_mode = dictionary.get('uplinkMode')\r\n virtual_ip_1 = dictionary.get('virtualIp1')\r\n virtual_ip_2 = dictionary.get('virtualIp2')\r\n\r\n # Return an object of this model\r\n return cls(enabled,\r\n spare_serial,\r\n uplink_mode,\r\n virtual_ip_1,\r\n virtual_ip_2)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n access_token = dictionary.get('accessToken')\n token_type = dictionary.get('tokenType')\n error = cohesity_app_sdk.models.error.Error.from_dictionary(dictionary.get('error')) if dictionary.get('error') else None\n\n # Return an object of this model\n return cls(access_token,\n token_type,\n error)"],"string":"[\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n id = dictionary.get('id')\\n name = dictionary.get('name')\\n mtype = dictionary.get('type')\\n usage_bytes = dictionary.get('usageBytes')\\n\\n # Return an object of this model\\n return cls(\\n id,\\n name,\\n mtype,\\n usage_bytes\\n)\",\n \"def create(cls, dictionary):\\n return cls(**dictionary)\",\n \"def create(cls, dictionary):\\n return cls(**dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n name = dictionary.get('name')\\r\\n scheduling = meraki.models.scheduling_model.SchedulingModel.from_dictionary(dictionary.get('scheduling')) if dictionary.get('scheduling') else None\\r\\n bandwidth = meraki.models.bandwidth_model.BandwidthModel.from_dictionary(dictionary.get('bandwidth')) if dictionary.get('bandwidth') else None\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(name,\\r\\n scheduling,\\r\\n bandwidth,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n external_ids = dictionary.get('externalIds')\\r\\n harsh_accel_setting = dictionary.get('harsh_accel_setting')\\r\\n name = dictionary.get('name')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(external_ids,\\r\\n harsh_accel_setting,\\r\\n name)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n formatted_price = dictionary.get('FormattedPrice')\\n amount = dictionary.get('Amount')\\n currency_code = dictionary.get('CurrencyCode')\\n\\n # Return an object of this model\\n return cls(formatted_price,\\n amount,\\n currency_code)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n id = dictionary.get('Id')\\r\\n name = dictionary.get('Name')\\r\\n last_edited = APIHelper.RFC3339DateTime.from_value(dictionary.get(\\\"LastEdited\\\")).datetime if dictionary.get(\\\"LastEdited\\\") else None\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(id,\\r\\n name,\\r\\n last_edited,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n mtype = dictionary.get(\\\"type\\\")\\n filename = dictionary.get(\\\"filename\\\")\\n payload = dictionary.get(\\\"payload\\\")\\n\\n # Return an object of this model\\n return cls(mtype,\\n filename,\\n payload)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n protected_count = dictionary.get('protectedCount')\\n protected_size = dictionary.get('protectedSize')\\n unprotected_count = dictionary.get('unprotectedCount')\\n unprotected_size = dictionary.get('unprotectedSize')\\n\\n # Return an object of this model\\n return cls(\\n protected_count,\\n protected_size,\\n unprotected_count,\\n unprotected_size\\n)\",\n \"def from_dict(cls, dictionary: Dict[str, Any]):\\n return cls(**dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n primary_language = dictionary.get('PrimaryLanguage')\\r\\n secondary_language = dictionary.get('SecondaryLanguage')\\r\\n xml_signature = dictionary.get('XmlSignature')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(primary_language,\\r\\n secondary_language,\\r\\n xml_signature,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n id = dictionary.get('id')\\r\\n number = dictionary.get('number')\\r\\n name = dictionary.get('name')\\r\\n balance = dictionary.get('balance')\\r\\n mtype = dictionary.get('type')\\r\\n status = dictionary.get('status')\\r\\n customer_id = dictionary.get('customerId')\\r\\n institution_id = dictionary.get('institutionId')\\r\\n balance_date = dictionary.get('balanceDate')\\r\\n created_date = dictionary.get('createdDate')\\r\\n currency = dictionary.get('currency')\\r\\n institution_login_id = dictionary.get('institutionLoginId')\\r\\n display_position = dictionary.get('displayPosition')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(id,\\r\\n number,\\r\\n name,\\r\\n balance,\\r\\n mtype,\\r\\n status,\\r\\n customer_id,\\r\\n institution_id,\\r\\n balance_date,\\r\\n created_date,\\r\\n currency,\\r\\n institution_login_id,\\r\\n display_position,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n links = dictionary.get('links')\\r\\n email_config = dictionary.get('emailConfig')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(links,\\r\\n email_config,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n alias = dictionary.get(\\\"alias\\\")\\r\\n cnam_lookups_enabled = dictionary.get(\\\"cnam_lookups_enabled\\\")\\r\\n number_type = dictionary.get(\\\"number_type\\\")\\r\\n rate_center = dictionary.get(\\\"rate_center\\\")\\r\\n state = dictionary.get(\\\"state\\\")\\r\\n value = dictionary.get(\\\"value\\\")\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(alias,\\r\\n cnam_lookups_enabled,\\r\\n number_type,\\r\\n rate_center,\\r\\n state,\\r\\n value)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n username = dictionary.get('username')\\r\\n first_name = dictionary.get('firstName')\\r\\n last_name = dictionary.get('lastName')\\r\\n application_id = dictionary.get('applicationId')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(username,\\r\\n first_name,\\r\\n last_name,\\r\\n application_id,\\r\\n dictionary)\",\n \"def from_dict(cls, data):\\n return cls(**data)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n height = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Height')) if dictionary.get('Height') else None\\n length = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Length')) if dictionary.get('Length') else None\\n weight = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Weight')) if dictionary.get('Weight') else None\\n width = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Width')) if dictionary.get('Width') else None\\n\\n # Return an object of this model\\n return cls(height,\\n length,\\n weight,\\n width)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n setup = idfy_rest_client.models.setup.Setup.from_dictionary(dictionary.get('setup')) if dictionary.get('setup') else None\\r\\n merge_fields = dictionary.get('mergeFields')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(setup,\\r\\n merge_fields,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n to = dictionary.get('to')\\r\\n application_id = dictionary.get('applicationId')\\r\\n expiration_time_in_minutes = dictionary.get('expirationTimeInMinutes')\\r\\n code = dictionary.get('code')\\r\\n scope = dictionary.get('scope')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(to,\\r\\n application_id,\\r\\n expiration_time_in_minutes,\\r\\n code,\\r\\n scope)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n fqdn = dictionary.get('fqdn')\\n guid = dictionary.get('guid')\\n id = dictionary.get('id')\\n name = dictionary.get('name')\\n owner_id = dictionary.get('ownerId')\\n status = dictionary.get('status')\\n total_size_bytes = dictionary.get('totalSizeBytes')\\n\\n # Return an object of this model\\n return cls(\\n fqdn,\\n guid,\\n id,\\n name,\\n owner_id,\\n status,\\n total_size_bytes\\n)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n force_delete = dictionary.get('forceDelete')\\n id = dictionary.get('id')\\n include_marked_for_removal = dictionary.get('includeMarkedForRemoval')\\n retry = dictionary.get('retry')\\n\\n # Return an object of this model\\n return cls(\\n force_delete,\\n id,\\n include_marked_for_removal,\\n retry\\n)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n account_holder_name = dictionary.get('accountHolderName')\\r\\n routing_number = dictionary.get('routingNumber')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(account_holder_name,\\r\\n routing_number)\",\n \"def from_dict(cls, d):\\n return cls(**d)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n ephemeral_public_key = dictionary.get('ephemeral_public_key')\\r\\n public_key_hash = dictionary.get('public_key_hash')\\r\\n transaction_id = dictionary.get('transaction_id')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(ephemeral_public_key,\\r\\n public_key_hash,\\r\\n transaction_id)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n name = dictionary.get('name')\\r\\n given_name = dictionary.get('givenName')\\r\\n middle_name = dictionary.get('middleName')\\r\\n family_name = dictionary.get('familyName')\\r\\n address = None\\r\\n if dictionary.get('address') != None:\\r\\n address = list()\\r\\n for structure in dictionary.get('address'):\\r\\n address.append(finicityapi.models.payroll_address.PayrollAddress.from_dictionary(structure))\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(name,\\r\\n given_name,\\r\\n middle_name,\\r\\n family_name,\\r\\n address,\\r\\n dictionary)\",\n \"def from_dict(cls, dct):\\n return cls(**dct)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n mor_item = dictionary.get('morItem')\\n mor_type = dictionary.get('morType')\\n uuid = dictionary.get('uuid')\\n\\n # Return an object of this model\\n return cls(\\n mor_item,\\n mor_type,\\n uuid\\n)\",\n \"def from_dict(cls, data: Dict[str, any]):\\n return cls(**data)\",\n \"def from_dict(cls, session: \\\"FigoSession\\\", data_dict: dict) -> \\\"ModelBase\\\":\\n return cls(session, **data_dict)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n wind_speed = dictionary.get('windSpeed')\\n power = dictionary.get('power')\\n\\n # Return an object of this model\\n return cls(wind_speed,\\n power)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n consumer_id = dictionary.get('consumerId')\\r\\n consumer_ssn = dictionary.get('consumerSsn')\\r\\n event_name = dictionary.get('eventName')\\r\\n id = dictionary.get('id')\\r\\n status = dictionary.get('status')\\r\\n mtype = dictionary.get('type')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(consumer_id,\\r\\n consumer_ssn,\\r\\n event_name,\\r\\n id,\\r\\n status,\\r\\n mtype,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n id = dictionary.get('id')\\r\\n title = dictionary.get('title')\\r\\n device_group = dictionary.get('deviceGroup')\\r\\n create_on = dictionary.get('createOn')\\r\\n update_on = dictionary.get('updateOn')\\r\\n created_by = dictionary.get('createdBy')\\r\\n create_on_persian_date = dictionary.get('createOnPersianDate')\\r\\n update_on_persian_date = dictionary.get('updateOnPersianDate')\\r\\n device_type_brand_model_title = dictionary.get('deviceTypeBrandModelTitle')\\r\\n device_brand_ids = dictionary.get('deviceBrandIds')\\r\\n device_type_id = dictionary.get('deviceTypeId')\\r\\n device_brand_id = dictionary.get('deviceBrandId')\\r\\n updated_by = dictionary.get('updatedBy')\\r\\n device_type_title = dictionary.get('deviceTypeTitle')\\r\\n device_brand_title = dictionary.get('deviceBrandTitle')\\r\\n device_brands_title = dictionary.get('deviceBrandsTitle')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(id,\\r\\n title,\\r\\n device_group,\\r\\n create_on,\\r\\n update_on,\\r\\n created_by,\\r\\n create_on_persian_date,\\r\\n update_on_persian_date,\\r\\n device_type_brand_model_title,\\r\\n device_brand_ids,\\r\\n device_type_id,\\r\\n device_brand_id,\\r\\n updated_by,\\r\\n device_type_title,\\r\\n device_brand_title,\\r\\n device_brands_title)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n account_id = dictionary.get('AccountId')\\r\\n name = dictionary.get('Name')\\r\\n org_no = dictionary.get('OrgNo')\\r\\n uni_customer_no = dictionary.get('UniCustomerNo')\\r\\n created = APIHelper.RFC3339DateTime.from_value(dictionary.get(\\\"Created\\\")).datetime if dictionary.get(\\\"Created\\\") else None\\r\\n last_modified = APIHelper.RFC3339DateTime.from_value(dictionary.get(\\\"LastModified\\\")).datetime if dictionary.get(\\\"LastModified\\\") else None\\r\\n dealer_id = dictionary.get('DealerId')\\r\\n dealer_name = dictionary.get('DealerName')\\r\\n dealer_reference = dictionary.get('DealerReference')\\r\\n enabled = dictionary.get('Enabled')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(account_id,\\r\\n name,\\r\\n org_no,\\r\\n uni_customer_no,\\r\\n created,\\r\\n last_modified,\\r\\n dealer_id,\\r\\n dealer_name,\\r\\n dealer_reference,\\r\\n enabled,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n password = dictionary.get('password')\\r\\n name = dictionary.get('name')\\r\\n tag_ids = dictionary.get('tagIds')\\r\\n eld_adverse_weather_exemption_enabled = dictionary.get('eldAdverseWeatherExemptionEnabled')\\r\\n eld_big_day_exemption_enabled = dictionary.get('eldBigDayExemptionEnabled')\\r\\n eld_day_start_hour = dictionary.get('eldDayStartHour')\\r\\n eld_exempt = dictionary.get('eldExempt')\\r\\n eld_exempt_reason = dictionary.get('eldExemptReason')\\r\\n eld_pc_enabled = dictionary.get(\\\"eldPcEnabled\\\") if dictionary.get(\\\"eldPcEnabled\\\") else False\\r\\n eld_ym_enabled = dictionary.get(\\\"eldYmEnabled\\\") if dictionary.get(\\\"eldYmEnabled\\\") else False\\r\\n external_ids = dictionary.get('externalIds')\\r\\n group_id = dictionary.get('groupId')\\r\\n license_number = dictionary.get('licenseNumber')\\r\\n license_state = dictionary.get('licenseState')\\r\\n notes = dictionary.get('notes')\\r\\n phone = dictionary.get('phone')\\r\\n username = dictionary.get('username')\\r\\n vehicle_id = dictionary.get('vehicleId')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(password,\\r\\n name,\\r\\n tag_ids,\\r\\n eld_adverse_weather_exemption_enabled,\\r\\n eld_big_day_exemption_enabled,\\r\\n eld_day_start_hour,\\r\\n eld_exempt,\\r\\n eld_exempt_reason,\\r\\n eld_pc_enabled,\\r\\n eld_ym_enabled,\\r\\n external_ids,\\r\\n group_id,\\r\\n license_number,\\r\\n license_state,\\r\\n notes,\\r\\n phone,\\r\\n username,\\r\\n vehicle_id)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n env_type = dictionary.get('envType')\\n protected_count = dictionary.get('protectedCount')\\n protected_size_bytes = dictionary.get('protectedSizeBytes')\\n unprotected_count = dictionary.get('unprotectedCount')\\n unprotected_size_bytes = dictionary.get('unprotectedSizeBytes')\\n\\n # Return an object of this model\\n return cls(\\n env_type,\\n protected_count,\\n protected_size_bytes,\\n unprotected_count,\\n unprotected_size_bytes\\n)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n is_mail_enabled = dictionary.get('isMailEnabled')\\n is_security_enabled = dictionary.get('isSecurityEnabled')\\n member_count = dictionary.get('memberCount')\\n visibility = dictionary.get('visibility')\\n\\n # Return an object of this model\\n return cls(\\n is_mail_enabled,\\n is_security_enabled,\\n member_count,\\n visibility\\n)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n name = dictionary.get('name')\\r\\n time_zone = dictionary.get('timeZone')\\r\\n tags = dictionary.get('tags')\\r\\n disable_my_meraki_com = dictionary.get('disableMyMerakiCom')\\r\\n disable_remote_status_page = dictionary.get('disableRemoteStatusPage')\\r\\n enrollment_string = dictionary.get('enrollmentString')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(name,\\r\\n time_zone,\\r\\n tags,\\r\\n disable_my_meraki_com,\\r\\n disable_remote_status_page,\\r\\n enrollment_string)\",\n \"def from_dict(cls, dictionary):\\n normalised = cls.normalise_dict(dictionary)\\n return cls.from_normalised_dict(normalised)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n name = dictionary.get('name')\\r\\n lan_ip = dictionary.get('lanIp')\\r\\n uplink = dictionary.get('uplink')\\r\\n public_port = dictionary.get('publicPort')\\r\\n local_port = dictionary.get('localPort')\\r\\n allowed_ips = dictionary.get('allowedIps')\\r\\n protocol = dictionary.get('protocol')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(name,\\r\\n lan_ip,\\r\\n uplink,\\r\\n public_port,\\r\\n local_port,\\r\\n allowed_ips,\\r\\n protocol)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n found = dictionary.get('found')\\r\\n displaying = dictionary.get('displaying')\\r\\n more_available = dictionary.get('moreAvailable')\\r\\n created_date = dictionary.get('createdDate')\\r\\n institutions = None\\r\\n if dictionary.get('institutions') != None:\\r\\n institutions = list()\\r\\n for structure in dictionary.get('institutions'):\\r\\n institutions.append(finicityapi.models.institution.Institution.from_dictionary(structure))\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(found,\\r\\n displaying,\\r\\n more_available,\\r\\n created_date,\\r\\n institutions,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n backup_file_path = dictionary.get('backupFilePath')\\n excluded_file_paths = dictionary.get(\\\"excludedFilePaths\\\")\\n skip_nested_volumes = dictionary.get('skipNestedVolumes')\\n\\n # Return an object of this model\\n return cls(\\n backup_file_path,\\n excluded_file_paths,\\n skip_nested_volumes\\n)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n lowest_new_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestNewPrice')) if dictionary.get('LowestNewPrice') else None\\n lowest_used_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestUsedPrice')) if dictionary.get('LowestUsedPrice') else None\\n lowest_collectible_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestCollectiblePrice')) if dictionary.get('LowestCollectiblePrice') else None\\n lowest_refurbished_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestRefurbishedPrice')) if dictionary.get('LowestRefurbishedPrice') else None\\n total_new = dictionary.get('TotalNew')\\n total_used = dictionary.get('TotalUsed')\\n total_collectible = dictionary.get('TotalCollectible')\\n total_refurbished = dictionary.get('TotalRefurbished')\\n\\n # Return an object of this model\\n return cls(lowest_new_price,\\n lowest_used_price,\\n lowest_collectible_price,\\n lowest_refurbished_price,\\n total_new,\\n total_used,\\n total_collectible,\\n total_refurbished)\",\n \"def from_dict(cls, data):\\r\\n instance = cls()\\r\\n for key, value in data.items():\\r\\n instance.__dict__[key] = value\\r\\n return instance\",\n \"def from_dict(cls, dictionary):\\n instance = cls()\\n for key, value in dictionary.items():\\n instance.__dict__[key] = value\\n\\n return instance\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n door_closed = dictionary.get('doorClosed')\\r\\n id = dictionary.get('id')\\r\\n name = dictionary.get('name')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(door_closed,\\r\\n id,\\r\\n name)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n id = dictionary.get('id')\\n provider_id = dictionary.get('providerId')\\n server_time = dictionary.get('serverTime')\\n username = dictionary.get('username')\\n driver_license_number = dictionary.get('driverLicenseNumber')\\n country = dictionary.get('country')\\n region = dictionary.get('region')\\n driver_home_terminal = dictionary.get('driverHomeTerminal')\\n\\n # Return an object of this model\\n return cls(id,\\n provider_id,\\n server_time,\\n username,\\n driver_license_number,\\n country,\\n region,\\n driver_home_terminal)\",\n \"def from_dict(cls, data):\\n instance = cls()\\n instance._set_data(data)\\n return instance\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n is_group_site = dictionary.get('isGroupSite')\\n is_private_channel_site = dictionary.get('isPrivateChannelSite')\\n is_team_site = dictionary.get('isTeamSite')\\n\\n # Return an object of this model\\n return cls(\\n is_group_site,\\n is_private_channel_site,\\n is_team_site\\n)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n id = dictionary.get('id')\\n provider_id = dictionary.get('providerId')\\n server_time = dictionary.get('serverTime')\\n active_from = dictionary.get('activeFrom')\\n active_to = dictionary.get('activeTo')\\n rpm_over_value = dictionary.get('rpmOverValue')\\n over_speed_value = dictionary.get('overSpeedValue')\\n excess_speed_value = dictionary.get('excessSpeedValue')\\n long_idle_value = dictionary.get('longIdleValue')\\n hi_throttle_value = dictionary.get('hiThrottleValue')\\n\\n # Return an object of this model\\n return cls(id,\\n provider_id,\\n server_time,\\n active_from,\\n active_to,\\n rpm_over_value,\\n over_speed_value,\\n excess_speed_value,\\n long_idle_value,\\n hi_throttle_value)\",\n \"def from_dict(cls, dikt) -> 'ModelClass':\\n return util.deserialize_model(dikt, cls)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n action = dictionary.get('action')\\n cluster_info = dictionary.get('clusterInfo')\\n details = dictionary.get('details')\\n domain = dictionary.get('domain')\\n entity_id = dictionary.get('entityId')\\n entity_name = dictionary.get('entityName')\\n entity_type = dictionary.get('entityType')\\n human_timestamp = dictionary.get('humanTimestamp')\\n impersonation = dictionary.get('impersonation')\\n ip = dictionary.get('ip')\\n new_record = dictionary.get('newRecord')\\n original_tenant = cohesity_management_sdk.models.tenant.Tenant.from_dictionary(dictionary.get('originalTenant')) if dictionary.get('originalTenant') else None\\n previous_record = dictionary.get('previousRecord')\\n tenant = cohesity_management_sdk.models.tenant.Tenant.from_dictionary(dictionary.get('tenant')) if dictionary.get('tenant') else None\\n timestamp_usecs = dictionary.get('timestampUsecs')\\n user_name = dictionary.get('userName')\\n\\n # Return an object of this model\\n return cls(\\n action,\\n cluster_info,\\n details,\\n domain,\\n entity_id,\\n entity_name,\\n entity_type,\\n human_timestamp,\\n impersonation,\\n ip,\\n new_record,\\n original_tenant,\\n previous_record,\\n tenant,\\n timestamp_usecs,\\n user_name\\n)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n api_group = dictionary.get('apiGroup')\\n api_version = dictionary.get('apiVersion')\\n kind = dictionary.get('kind')\\n name = dictionary.get('name')\\n namespace = dictionary.get('namespace')\\n resource_version = dictionary.get('resourceVersion')\\n uid = dictionary.get('uid')\\n\\n # Return an object of this model\\n return cls(\\n api_group,\\n api_version,\\n kind,\\n name,\\n namespace,\\n resource_version,\\n uid\\n)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n id = dictionary.get('id')\\r\\n consumer_id = dictionary.get('consumerId')\\r\\n consumer_ssn = dictionary.get('consumerSsn')\\r\\n requester_name = dictionary.get('requesterName')\\r\\n request_id = dictionary.get('requestId')\\r\\n constraints = finicityapi.models.report_constraints.ReportConstraints.from_dictionary(dictionary.get('constraints')) if dictionary.get('constraints') else None\\r\\n mtype = dictionary.get('type')\\r\\n status = dictionary.get('status')\\r\\n created_date = dictionary.get('createdDate')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(id,\\r\\n consumer_id,\\r\\n consumer_ssn,\\r\\n requester_name,\\r\\n request_id,\\r\\n constraints,\\r\\n mtype,\\r\\n status,\\r\\n created_date,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n address = dictionary.get('address')\\n port = dictionary.get('port')\\n protocol = dictionary.get('protocol')\\n is_cluster_auditing_enabled = dictionary.get('isClusterAuditingEnabled')\\n is_data_protection_enabled = dictionary.get('isDataProtectionEnabled')\\n is_filer_auditing_enabled = dictionary.get('isFilerAuditingEnabled')\\n is_ssh_log_enabled = dictionary.get('isSshLogEnabled')\\n name = dictionary.get('name')\\n\\n # Return an object of this model\\n return cls(address,\\n port,\\n protocol,\\n is_cluster_auditing_enabled,\\n is_data_protection_enabled,\\n is_filer_auditing_enabled,\\n is_ssh_log_enabled,\\n name)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n enabled = dictionary.get('enabled')\\r\\n spare_serial = dictionary.get('spareSerial')\\r\\n uplink_mode = dictionary.get('uplinkMode')\\r\\n virtual_ip_1 = dictionary.get('virtualIp1')\\r\\n virtual_ip_2 = dictionary.get('virtualIp2')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(enabled,\\r\\n spare_serial,\\r\\n uplink_mode,\\r\\n virtual_ip_1,\\r\\n virtual_ip_2)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n access_token = dictionary.get('accessToken')\\n token_type = dictionary.get('tokenType')\\n error = cohesity_app_sdk.models.error.Error.from_dictionary(dictionary.get('error')) if dictionary.get('error') else None\\n\\n # Return an object of this model\\n return cls(access_token,\\n token_type,\\n error)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.83185387","0.81679726","0.81679726","0.81194353","0.80894536","0.79789025","0.7949881","0.7922983","0.7898846","0.7892914","0.7888425","0.7882915","0.7882119","0.78765213","0.7858605","0.78363335","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.78024834","0.7782055","0.7778154","0.7759028","0.7743117","0.77353734","0.7704602","0.7697104","0.768094","0.7669933","0.7665181","0.7660912","0.76575106","0.7651525","0.7630762","0.7603281","0.7594447","0.7593958","0.7590695","0.7589819","0.75800014","0.75671214","0.7566006","0.75631315","0.74959457","0.7492305","0.7491037","0.7486914","0.74839115","0.74673057","0.7465791","0.7461559","0.74569243","0.74556625","0.7447716","0.7409682","0.7400533","0.73913556","0.73877615","0.73852116","0.7370114"],"string":"[\n \"0.83185387\",\n \"0.81679726\",\n \"0.81679726\",\n \"0.81194353\",\n \"0.80894536\",\n \"0.79789025\",\n \"0.7949881\",\n \"0.7922983\",\n \"0.7898846\",\n \"0.7892914\",\n \"0.7888425\",\n \"0.7882915\",\n \"0.7882119\",\n \"0.78765213\",\n \"0.7858605\",\n \"0.78363335\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.78024834\",\n \"0.7782055\",\n \"0.7778154\",\n \"0.7759028\",\n \"0.7743117\",\n \"0.77353734\",\n \"0.7704602\",\n \"0.7697104\",\n \"0.768094\",\n \"0.7669933\",\n \"0.7665181\",\n \"0.7660912\",\n \"0.76575106\",\n \"0.7651525\",\n \"0.7630762\",\n \"0.7603281\",\n \"0.7594447\",\n \"0.7593958\",\n \"0.7590695\",\n \"0.7589819\",\n \"0.75800014\",\n \"0.75671214\",\n \"0.7566006\",\n \"0.75631315\",\n \"0.74959457\",\n \"0.7492305\",\n \"0.7491037\",\n \"0.7486914\",\n \"0.74839115\",\n \"0.74673057\",\n \"0.7465791\",\n \"0.7461559\",\n \"0.74569243\",\n \"0.74556625\",\n \"0.7447716\",\n \"0.7409682\",\n \"0.7400533\",\n \"0.73913556\",\n \"0.73877615\",\n \"0.73852116\",\n \"0.7370114\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83176,"cells":{"query":{"kind":"string","value":"Catch Ctrl+C signal to termiante workers"},"document":{"kind":"string","value":"def init_worker():\n signal.signal(signal.SIGINT, signal.SIG_IGN)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def allowCtrlC():\n signal.signal(signal.SIGINT, signal.SIG_DFL)","def signal_handler(*unused_argvs):\n sys.stderr.write(\"\\nCtrl^C caught, bailing...\\n\")\n sys.exit(0)","def worker_initializer():\n signal.signal(signal.SIGINT, signal.SIG_IGN)","def _init_worker():\n signal.signal(signal.SIGINT, signal.SIG_IGN)","def signal_handler(self, signal, frame):\n logger.info('CTRL+C pressed')\n self.trigger_stop()","def __sigint_handler(signal, frame):\n logging.debug(\"SIGINT or SIGTERM catched\")\n logging.debug(\"Raise t_stop_event\")\n t_stop_event.set() # Set stop flag to true for all launched threads\n logging.info(\"Stopping daemons...\")\n sleep(1)","def ctrl_c(signum, frame):\n global shutdown_event\n raise SystemExit('\\nCancelling...')","def ctrl_c_trapper(signum: int, stackframe) -> None:\n log.critical(\"Ignoring CTRL+C (signal {}); use the GUI to quit\", signum)","def ctrlc_catcher(*excargs, **exckwargs):\n\n # Depending on the number of input arguments, we're either in Jupyter/iPython\n # or \"regular\" Python - this matters for actually handling the raised exception\n if len(excargs) == 3:\n isipy = False\n etype, evalue, etb = excargs\n else:\n shell, = excargs\n etype, evalue, etb = sys.exc_info()\n try: # careful: if iPython is used to launch a script, ``get_ipython`` is not defined\n get_ipython()\n isipy = True\n sys.last_traceback = etb # smartify ``sys``\n except NameError:\n isipy = False\n\n # Prepare to log any uncaught exceptions\n log = logging.getLogger(\"ACME\")\n\n # The only exception we really care about is a `KeyboardInterrupt`: if CTRL + C\n # is pressed, ensure graceful shutdown of any parallel processing clients\n if issubclass(etype, KeyboardInterrupt):\n try:\n client = dd.get_client()\n except ValueError:\n client = None\n if client is not None:\n for st in client.futures.values():\n st.cancel()\n client.futures.clear()\n dh.cluster_cleanup(client)\n log.debug(\"CTRL + C acknowledged, client and workers successfully killed\")\n\n # Relay exception handling back to appropriate system tools\n if isipy:\n shell.ipyTBshower(shell, exc_tuple=(etype, evalue, etb), **exckwargs)\n else:\n sys.__excepthook__(etype, evalue, etb)\n\n # Write to all logging locations, manually print traceback to file (stdout\n # printing was handled above)\n log.error(\"Exception received.\")\n memHandler = [h for h in log.handlers if isinstance(h, handlers.MemoryHandler)][0]\n if memHandler.target is not None:\n memHandler.acquire()\n with open(memHandler.target.baseFilename, \"a\", encoding=\"utf-8\") as logfile:\n logfile.write(\"\".join(traceback.format_exception_only(etype, evalue)))\n logfile.write(\"\".join(traceback.format_tb(etb)))\n memHandler.release()\n\n return","def signal_handler(signal, frame):\n\n process_id = multiprocessing.current_process().name\n if process_id == 'child':\n return\n logger = logging.getlogger('signal_handler')\n logger.info('ctrl-c received.')\n logger.info('telling pipeline to shutdown')\n global pipeline\n pipeline.shutdown()","def signal_handler(self, signal, frame):\r\n print 'You pressed Ctrl+C!'\r\n sys.exit(0)","def signal_handler(sig, frame):\n print(\"\")\n print(\"You pressed Ctrl+C! Closing ros client and shell.\")\n rclpy.try_shutdown()\n sys.exit(0)","def test_ctrl_c(u_boot_console):\n\n u_boot_console.kill(signal.SIGINT)\n assert(u_boot_console.validate_exited())","def signal_handler(sig, frame):\r\n print('You pressed Control+C')\r\n led.off()\r\n sys.exit(0)","def trap_ctrl_c_ctrl_break() -> None: # noqa\n\n signal.signal(signal.SIGINT, ctrl_c_trapper)\n signal.signal(signal.SIGTERM, sigterm_trapper)\n if platform.system() == \"Windows\":\n # SIGBREAK isn't in the Linux signal module\n # noinspection PyUnresolvedReferences\n signal.signal(signal.SIGBREAK, ctrl_break_trapper)","def stop(self, signum, dummy):\n if signum == signal.SIGINT:\n self.writer.lock.acquire()\n self.stopped = True\n logging.info('Ctrl-C issued')\n self.writer.lock.release()","def sigint_handler(*dummy):\n print \"Received SIGINT. Stopping everything.\"\n executor.Stop()\n server.Stop()","def cli():\n signal.signal(signal.SIGINT, signal_handler)\n pass","def interrupt_handler(signum, frame): #pylint: disable=W0613\n cleanup()\n sys.exit(-2) # Terminate process here as catching the signal\n # removes the close process behaviour of Ctrl-C","def on_interrupt(self, *args) -> None: #pylint: disable=unused-argument\r\n if not self.stop_requested:\r\n self.stop_requested = True\r\n self.logger.critical('SIGINT detected - will stop at the end of the current evolution')\r\n else:\r\n stop_from = time.time() - 5000\r\n if self.last_stop_request > stop_from:\r\n raise KeyboardInterrupt\r\n else:\r\n self.last_stop_request = time.time()\r\n self.logger.critical('SIGINT suppressed - repeat within 5 seconds to sigterm')","def catch_keyboard_interrupt() -> Callable:\n return signal.signal(signal.SIGINT, keyboard_interrupt_handler)","def signal_handler(signum, frame):\n self.log.error(\"Received SIGTERM. Terminating subprocesses\")\n self.task_runner.terminate()\n self.handle_task_exit(128 + signum)","def signal_handler(self):\n\t\twith open(\"/dev/null\") as sys.stderr:\n\t\t\tself._thread_executor.shutdown(wait=False)\n\t\t\t[task.cancel() for task in Task.all_tasks() if task is not Task.current_task()]\n\t\t\tself._event_loop.stop()\n\t\t\tself._dump_test_parser_log()","def keyboard_interrupt_handler(sig: int, _: object) -> None:\n logger.warning(f'KeyboardInterrupt (id: {sig}) has been caught...')\n logger.info('Terminating the session gracefully...')\n ray.shutdown()\n minio_leftovers = glob('*.part.minio')\n for leftover in minio_leftovers:\n Path(leftover).unlink()\n sys.exit(1)","def sig_handler(sig, frame):\n if sig == signal.SIGINT:\n stop_ros()\n print(\"Shutting down...\")\n sys.exit(0)","def signal_handler(signum, frame):\n monitor.stop()\n sys.exit(0)","def finish(self):\n super(InterruptibleMixin, self).finish()\n signal(SIGINT, self.original_handler)","def sigterm_handler(signal, frame):\n GPIO.cleanup()\n print('WARN : %s Received Kill' % PROG_NAME)\n print('INFO : Performed GPIO.cleanup. Bye ...')\n sys.exit(0)","def handle_sigint(signum, frame):\n print(\"\\nInterrupted by SIGINT\\n\")\n sys.exit()","def sigint_handler(signal, frame):\n rclpy.shutdown()\n if prev_sigint_handler is not None:\n prev_sigint_handler(signal)","def SIGINT(self, signum, frame):\n for t in [t for t in threading.enumerate() if t.name != 'MainThread']:\n if hasattr(t, 'stop') and callable(t.stop):\n t.stop()\n\n for t in [t for t in threading.enumerate() if t.name != 'MainThread']:\n t.join()\n\n self.exit(1)","def test_control_c_is_possible(self):\n if platform.type != \"posix\":\n raise SkipTest(\"I don't have the energy to fight Windows semantics.\")\n program = \"\"\"\\\nimport os, threading, signal, time, sys\nimport crochet\ncrochet.setup()\nfrom twisted.internet.defer import Deferred\n\nif sys.platform.startswith('win'):\n signal.signal(signal.SIGBREAK, signal.default_int_handler)\n sig_int=signal.CTRL_BREAK_EVENT\n sig_kill=signal.SIGTERM\nelse:\n sig_int=signal.SIGINT\n sig_kill=signal.SIGKILL\n\n\ndef interrupt():\n time.sleep(0.1) # Make sure we've hit wait()\n os.kill(os.getpid(), sig_int)\n time.sleep(1)\n # Still running, test shall fail...\n os.kill(os.getpid(), sig_kill)\n\nt = threading.Thread(target=interrupt, daemon=True)\nt.start()\n\nd = Deferred()\ne = crochet.EventualResult(d, None)\n\ntry:\n e.wait(10000)\nexcept KeyboardInterrupt:\n sys.exit(23)\n\"\"\"\n kw = {'cwd': crochet_directory}\n # on Windows the only way to interrupt a subprocess reliably is to\n # create a new process group:\n # http://docs.python.org/2/library/subprocess.html#subprocess.CREATE_NEW_PROCESS_GROUP\n if platform.type.startswith('win'):\n kw['creationflags'] = subprocess.CREATE_NEW_PROCESS_GROUP\n process = subprocess.Popen([sys.executable, \"-c\", program], **kw)\n self.assertEqual(process.wait(), 23)","def SIGINT_handler(signal, frame):\n exit(2)","def interrupt_handler(signum, frame):\n if DOCKER_MONITOR:\n util.log.warning(\"Signal %d received - Tearing down monitoring\"\n % (signum))\n DOCKER_MONITOR.tear_down_all()\n sys.exit(0)","def setup_termination():\n setpgrp()\n\n def terminate(signum, frame):\n logger.debug(\"SIGKILL received!\")\n logger.debug(\"%d, %s\", signum, frame)\n killpg(0, SIGKILL)\n\n signal(SIGINT, terminate)","def sigint_handler(signal, frame):\n print(\"SIGINT received by run_end_to_end.py. Terminating process.\")\n exit_gracefully()\n sys.exit()","async def shutdown(signal, loop):\n print(f\"Received exit signal {signal.name}...\")\n print(\"Closing redis connections\")\n print(\"Nacking outstanding messages\")\n tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]\n\n [task.cancel() for task in tasks]\n\n print(f\"Cancelling {len(tasks)} outstanding tasks\")\n await asyncio.gather(*tasks, return_exceptions=True)\n print(f\"Flushing metrics\")\n loop.stop()","def sigint_handler(sig, frame):\n print(\"[i] Caught SIGINT, cleaning up...\")\n server.close()\n exit(0)","def sigterm(signum, frame):\n loop.stop()","def signal_handler(signal_number, stack_frame):\n if signal_number in [signal.SIGTERM, signal.SIGINT]:\n terminate_surveillance()","def signal_handler(signum, frame):\n sys.exit(0)","def register_signal_handler(self):\n signal.signal(signal.SIGINT, self.quit_gracefully)\n signal.signal(signal.SIGTERM, self.quit_gracefully)\n return","def graceful_exit():\n print(\"KeyboardInterrupt, exit(1)\")\n exit(1)","def __before_termination__(self, sig):\n print(\"Ahhhh! I'm going to be killed. My pid:{}, signal received:{}\".format(self.pid, sig ) )","def sigterm_handler(signum: int, stack_frame) -> None:\n\n del signum\n del stack_frame\n\n logger.info(\"Terminating promqtt. Bye!\")\n sys.exit(0)","def IgnoreSigint():\n signal.signal(signal.SIGINT, signal.SIG_IGN)","def signal_handler(aggregator, liveness_probe, signal):\n\n if signal == signal.SIGTERM:\n liveness_probe.close()\n\n # Wait aggregator handle with all the received events before close it\n while (\n any([not x.channel.empty() for x in aggregator.subscribers])\n or RequestTimeLogger.current_requests_count > 0\n ):\n print(\"There are events to handle yet.\")\n\n aggregator.stop()\n exit(0)","def ctrl_break_trapper(signum: int, stackframe) -> None:\n log.critical(\n \"Ignoring CTRL+BREAK (signal {}); use the GUI to quit\", signum\n )","def sigterm_caught(sig, frame):\n global child_pid\n print 'SIGTERM caught, killing wicd-monitor...'\n os.kill(child_pid, signal.SIGTERM)\n print 'Removing PID file...'\n if os.path.exists(wpath.pidfile):\n os.remove(wpath.pidfile)\n print 'Shutting down...'\n sys.exit(0)","async def stop_signal():\n global user_exit\n user_exit = True\n await cancel_async_tasks()","def signal_handler(signal, frame):\n\n print('Aborted. Will shut down all httperf processes')\n for client in Httperf.all_clients:\n command = ('ssh {0} -q -o StrictHostKeyChecking=no -o '\n 'UserKnownHostsFile=/dev/null \"pkill httperf \"').format(client)\n subprocess.call(command, shell=True)\n sys.exit(0)","def test_control_c_is_possible(self):\n if platform.type != \"posix\":\n raise SkipTest(\"I don't have the energy to fight Windows semantics.\")\n program = \"\"\"\\\nimport os, threading, signal, time, sys\nimport crochet\ncrochet.setup()\nfrom twisted.internet.defer import Deferred\n\nif sys.platform.startswith('win'):\n signal.signal(signal.SIGBREAK, signal.default_int_handler)\n sig_int=signal.CTRL_BREAK_EVENT\n sig_kill=signal.SIGTERM\nelse:\n sig_int=signal.SIGINT\n sig_kill=signal.SIGKILL\n\n\ndef interrupt():\n time.sleep(0.1) # Make sure we've hit wait()\n os.kill(os.getpid(), sig_int)\n time.sleep(1)\n # Still running, test shall fail...\n os.kill(os.getpid(), sig_kill)\n\nt = threading.Thread(target=interrupt, daemon=True)\nt.start()\n\n@crochet.%s\ndef wait():\n return Deferred()\n\ntry:\n wait()\nexcept KeyboardInterrupt:\n sys.exit(23)\n\"\"\" % (self.DECORATOR_CALL, )\n kw = {'cwd': crochet_directory}\n if platform.type.startswith('win'):\n kw['creationflags'] = subprocess.CREATE_NEW_PROCESS_GROUP\n process = subprocess.Popen([sys.executable, \"-c\", program], **kw)\n self.assertEqual(process.wait(), 23)","def checkInterrupt():\n if wasInterrupted():\n raise KeyboardInterrupt()","def _handle_ctrl_c(self):\n # There is a race condition here, we should lock on the value of\n # executing() to avoid accidentally raising KeyboardInterrupt after\n # execution has finished. Deal with this later…\n if self._executing():\n self._cancel()\n else:\n self._last_input = ''\n self.stdout.write('^C\\n')\n self._output_inserted = False\n self._more = False\n self._update_ps(self._more)\n self._show_ps()","def hash_pool_initializer():\n signal.signal(signal.SIGINT, signal.SIG_IGN)","def signal_handler(sig, frame):\n global shutdown_flag, orig_sighandler\n signal.signal(signal.SIGTERM, signal.SIG_IGN) # Disable SIGTERM\n logger.warning(\"SIGTERM received! Normally this triggered by the walltime limit.\")\n shutdown_flag.set()\n return","def signal(self):\n self.mainloop().signal()","def capture_signals():\n # Both Linux and Windows signals\n signal.signal(signal.SIGINT, stop_server)\n signal.signal(signal.SIGTERM, stop_server)\n\n if platform.system() == \"Linux\": # Linux only\n signal.signal(signal.SIGQUIT, stop_server)\n signal.signal(signal.SIGHUP, stop_server)","def _signal_handler(*_: typing.Any) -> None:\n shutdown_event.set()","def signal_handler(*args):\n if station:\n station.shutdown()","def interrupt(v):\n print(\" \" + bcolors.OKBLUE + \"[!] Detected CTRL+C ! restoring setting, please wait...\" + bcolors.ENDC)\n bash = \"ip link delete dummy type dummy\"\n os.system(bash)\n if v.spoof:\n restoreSpoof(v)\n if v.ntpStatus:\n ntpToggle(v)\n print(\" \" + bcolors.OKGREEN + \"Done\")\n print(\" --------------------------------------------------------\" + bcolors.ENDC)\n exit()","def OnCancelScripts(self, event):\n # self.shutdown()\n print(\"Cancel multiprocessor\")\n event.Skip()","def signal_handler(signum, frame):\n main.CLOSE = True","def on_terminate(self):\n pass","def signal_handler(signal, frame):\n output.write(\"SIGTERM received (launch_simulations talking)\\n\")\n p.kill(15)\n sys.exit(1)","def signal_handler(sig, frame):\n sys.exit(0)","def restart_worker_sig_handler(*args):\n set_in_sighandler(True)\n safe_say('Restarting celeryd (%s)' % (' '.join(sys.argv), ))\n import atexit\n atexit.register(_clone_current_worker)\n from celery.worker import state\n state.should_stop = True","def signal_handler(signal, frame):\n sys.exit(0)","def signal_handler(signal, frame):\n sys.exit(0)","def signal_handler(signal, frame):\n sys.exit(0)","def _continue_running(self):\n if self._signal_recieved == signal.SIGINT:\n return False\n\n return True","def ctrl_c():\n from pynput.keyboard import Key, Controller\n kb = Controller()\n kb.press(Key.ctrl)\n kb.press('c')\n kb.release('c')\n kb.release(Key.ctrl)","def abort_signal(self, signal, frame):\r\n\r\n print \"\\nMANUAL TERMINATION: Stopping all threads...\"\r\n self.stop(True)\r\n sys.exit(0)","def cancel_workers(self):\n pass","def test_ignore_return(self):\n from signal import signal, SIGINT, SIG_DFL, SIG_IGN\n\n try:\n for handler in SIG_DFL, SIG_IGN, lambda *a: None:\n signal(SIGINT, SIG_IGN)\n assert signal(SIGINT, handler) == SIG_IGN\n finally:\n signal(SIGINT, SIG_DFL)","def stop(self):\n # trying this instead of SIGTERM\n # http://stackoverflow.com/a/6659191/3380530\n # self._process.send_signal(SIGINT)\n # Or not. SIGINT doesn't exist on Windows\n self._process.terminate()","def sighandler(signum, frame):\n global _terminate\n global _interruptcnt\n print >> FileKeyUtils.WMSlog, 'sighandler> ', signum\n ++_interruptcnt \n if signum in(signal.SIGABRT, signal.SIGINT, signal.SIGTERM):\n print >> FileKeyUtils.WMSlog, 'sighandler> terminate pid: ', os.getpid(), signum\n _terminate = True\n elif signum in(signal.SIGHUP, signal.SIGTSTP):\n print >> FileKeyUtils.WMSlog, 'sighandler> suspend/stop/pause pid: ', os.getpid(), signum\n signal.pause()\n else:\n print >> FileKeyUtils.WMSlog, 'sighandler> resume/continue pid: ', os.getpid(), signum\n _terminate = False","def sigterm_trapper(signum: int, stackframe) -> None:\n log.critical(\"Ignoring SIGTERM (signal {}); use the GUI to quit\", signum)","def handle_signal(sig, frame):\n IOLoop.instance().add_callback(IOLoop.instance().stop)","def stop_controller(signum, frame):\n if controller:\n print('Stopping controller...')\n # If stop() hangs, old ctrl+c behaviour will be restored\n signal.signal(signal.SIGINT, kill_handler)\n controller.stop()","def signal_terminate_handler(signum, frame):\n \n print(\"Received signal: {}. Your server is terminated \".format(signum))\n client.close()\n socket_sm.close()\n sys.exit(0)","def interrupt_handler(self, signo, frame):\n log.debug(\"interrupting run\")\n self._keep_running = False","def _sigint(self, signal, frame):\n self.disconnect = True\n if self.cardinal:\n self.cardinal.quit('Received SIGINT.')","def cleanup(self, sig, func=None):\n\n print \"Closing up shop...\"\n\n # Disconnect all of our remote controllers\n for c in self.config_list:\n self.config_list[c].disconnect()\n\n # Kill our data handler\n self.INPUT_QUEUE.put(G.CTRL_CMD_KILL)\n\n # Terminate the consumers and producers\n self.in_queue.put(G.CTRL_CMD_KILL)\n self.out_queue.put(G.CTRL_CMD_KILL)\n for child in self.comm_processes:\n child.stop()","def _signal_workaround(shutdown: asyncio.Future) -> None:\n\n async def wakeup() -> None:\n while not shutdown.done():\n await asyncio.sleep(0.1)\n\n def signint_handler(signalnum: int, frame: types.FrameType):\n shutdown.set_result(None)\n\n signal.signal(signal.SIGINT, signint_handler)\n asyncio.get_running_loop().create_task(wakeup())","def signal_handler(self, sig, frame):\n print('You pressed Ctrl+C!')\n response = input(\"Would you like to terminate a user session? [y/n] \")\n if response.lower() == 'exit':\n print(\"fast exiting..\")\n sys.exit(0)\n\n\n if response.lower() == 'y':\n trying = 'y'\n while trying.lower() == 'y':\n print(\"Choose a user to remove:\\n\")\n user_list = []\n for client in self.clients:\n user_list.append(self.clients[client]['data'].decode('utf-8'))\n for user in user_list: print(user)\n response = input(\"Enter user to remove: \")\n for client in self.clients:\n if self.clients[client]['data'].decode('utf-8') == response:\n msg = f\"Booting client {self.clients[client]} from server...\"\n self.log_and_send(client, msg)\n print(\"Closing socket...\")\n self.sockets_list.remove(client)\n del self.clients[client]\n client.shutdown(socket.SHUT_RDWR)\n print(f\"Client {response} booted. Returning to listening...\")\n return\n trying = input(\"No matching client found. Try again? [y/n] \")\n\n response = input(\"Save config? [y/n] \")\n\n if response.lower() == 'y' or response == '\\n':\n print('Saving config and closing all sockets...')\n for _socket in self.clients:\n self.pp.pprint(_socket)\n _socket.close()\n self.save_config()\n \n response = input(\"Terminate server session? [y/n] \")\n if response.lower() == 'y':\n print('Exiting, good')\n sys.exit(0)","def _signal_handler(*args):\n self._user_exit = True","def signal_handler(signal, _): \n import signal\n import sys\n from time import localtime, strftime\n signal.signal(signal.SIGINT, original_sigint)\n thetime = strftime(\"%H:%M:%S\", localtime())\n INPUTFUNC('\\n\\n%s: Paused. Press any key to resume, or ctrl+c to quit.\\n' % thetime)\n time = strftime(\"%H:%M:%S\", localtime())\n print('%s: Interrogation resumed.\\n' % time)\n signal.signal(signal.SIGINT, signal_handler)","def _sigterm_handler(signum: int, _frame: FrameType) -> None:\n sys.exit('from sigterm handler')","def trap_signal(sig, _):\n CONSUL.agent.service.deregister(service_id=\"pyTest-{}\".format(iServicePort))\n exit()","def sigint_handler(*args):\n sys.stderr.write('\\r')\n QtGui.QApplication.quit()","def interrupt_kernel(self):","def _signal_handler(signum, frame):\n res_mgr()\n sys.exit(0)","def trap_sigint(handler, ignoreNum=0):\n handlers = _SIGINT_HANDLERS\n handlers.attach_override_unix(signal.SIGINT)\n handlers.register(handler, ignoreNum)","def stop(self, signal):\n pass","def stop(self, signal):\n pass","def signal_handler(signal, frame):\n map(lambda xcnode: xcnode.fd.close(), xcnodes)\n print 'Exiting program!'\n sys.exit(0)","def _termination_handler(self, signum, frame):\n print '[i] Shutting down...'\n self.sensor.close()\n sys.exit(1)","def register_exit_signals(self):\n signal.signal(signal.SIGINT, self._exit_gracefully)\n signal.signal(signal.SIGTERM, self._exit_gracefully)\n # So that we ignore the debug dump signal, making it easier to send\n signal.signal(signal.SIGUSR2, signal.SIG_IGN)","def handleKeyboardInterupt():\n System.stopExecution(TERMINATED_BY_USER)"],"string":"[\n \"def allowCtrlC():\\n signal.signal(signal.SIGINT, signal.SIG_DFL)\",\n \"def signal_handler(*unused_argvs):\\n sys.stderr.write(\\\"\\\\nCtrl^C caught, bailing...\\\\n\\\")\\n sys.exit(0)\",\n \"def worker_initializer():\\n signal.signal(signal.SIGINT, signal.SIG_IGN)\",\n \"def _init_worker():\\n signal.signal(signal.SIGINT, signal.SIG_IGN)\",\n \"def signal_handler(self, signal, frame):\\n logger.info('CTRL+C pressed')\\n self.trigger_stop()\",\n \"def __sigint_handler(signal, frame):\\n logging.debug(\\\"SIGINT or SIGTERM catched\\\")\\n logging.debug(\\\"Raise t_stop_event\\\")\\n t_stop_event.set() # Set stop flag to true for all launched threads\\n logging.info(\\\"Stopping daemons...\\\")\\n sleep(1)\",\n \"def ctrl_c(signum, frame):\\n global shutdown_event\\n raise SystemExit('\\\\nCancelling...')\",\n \"def ctrl_c_trapper(signum: int, stackframe) -> None:\\n log.critical(\\\"Ignoring CTRL+C (signal {}); use the GUI to quit\\\", signum)\",\n \"def ctrlc_catcher(*excargs, **exckwargs):\\n\\n # Depending on the number of input arguments, we're either in Jupyter/iPython\\n # or \\\"regular\\\" Python - this matters for actually handling the raised exception\\n if len(excargs) == 3:\\n isipy = False\\n etype, evalue, etb = excargs\\n else:\\n shell, = excargs\\n etype, evalue, etb = sys.exc_info()\\n try: # careful: if iPython is used to launch a script, ``get_ipython`` is not defined\\n get_ipython()\\n isipy = True\\n sys.last_traceback = etb # smartify ``sys``\\n except NameError:\\n isipy = False\\n\\n # Prepare to log any uncaught exceptions\\n log = logging.getLogger(\\\"ACME\\\")\\n\\n # The only exception we really care about is a `KeyboardInterrupt`: if CTRL + C\\n # is pressed, ensure graceful shutdown of any parallel processing clients\\n if issubclass(etype, KeyboardInterrupt):\\n try:\\n client = dd.get_client()\\n except ValueError:\\n client = None\\n if client is not None:\\n for st in client.futures.values():\\n st.cancel()\\n client.futures.clear()\\n dh.cluster_cleanup(client)\\n log.debug(\\\"CTRL + C acknowledged, client and workers successfully killed\\\")\\n\\n # Relay exception handling back to appropriate system tools\\n if isipy:\\n shell.ipyTBshower(shell, exc_tuple=(etype, evalue, etb), **exckwargs)\\n else:\\n sys.__excepthook__(etype, evalue, etb)\\n\\n # Write to all logging locations, manually print traceback to file (stdout\\n # printing was handled above)\\n log.error(\\\"Exception received.\\\")\\n memHandler = [h for h in log.handlers if isinstance(h, handlers.MemoryHandler)][0]\\n if memHandler.target is not None:\\n memHandler.acquire()\\n with open(memHandler.target.baseFilename, \\\"a\\\", encoding=\\\"utf-8\\\") as logfile:\\n logfile.write(\\\"\\\".join(traceback.format_exception_only(etype, evalue)))\\n logfile.write(\\\"\\\".join(traceback.format_tb(etb)))\\n memHandler.release()\\n\\n return\",\n \"def signal_handler(signal, frame):\\n\\n process_id = multiprocessing.current_process().name\\n if process_id == 'child':\\n return\\n logger = logging.getlogger('signal_handler')\\n logger.info('ctrl-c received.')\\n logger.info('telling pipeline to shutdown')\\n global pipeline\\n pipeline.shutdown()\",\n \"def signal_handler(self, signal, frame):\\r\\n print 'You pressed Ctrl+C!'\\r\\n sys.exit(0)\",\n \"def signal_handler(sig, frame):\\n print(\\\"\\\")\\n print(\\\"You pressed Ctrl+C! Closing ros client and shell.\\\")\\n rclpy.try_shutdown()\\n sys.exit(0)\",\n \"def test_ctrl_c(u_boot_console):\\n\\n u_boot_console.kill(signal.SIGINT)\\n assert(u_boot_console.validate_exited())\",\n \"def signal_handler(sig, frame):\\r\\n print('You pressed Control+C')\\r\\n led.off()\\r\\n sys.exit(0)\",\n \"def trap_ctrl_c_ctrl_break() -> None: # noqa\\n\\n signal.signal(signal.SIGINT, ctrl_c_trapper)\\n signal.signal(signal.SIGTERM, sigterm_trapper)\\n if platform.system() == \\\"Windows\\\":\\n # SIGBREAK isn't in the Linux signal module\\n # noinspection PyUnresolvedReferences\\n signal.signal(signal.SIGBREAK, ctrl_break_trapper)\",\n \"def stop(self, signum, dummy):\\n if signum == signal.SIGINT:\\n self.writer.lock.acquire()\\n self.stopped = True\\n logging.info('Ctrl-C issued')\\n self.writer.lock.release()\",\n \"def sigint_handler(*dummy):\\n print \\\"Received SIGINT. Stopping everything.\\\"\\n executor.Stop()\\n server.Stop()\",\n \"def cli():\\n signal.signal(signal.SIGINT, signal_handler)\\n pass\",\n \"def interrupt_handler(signum, frame): #pylint: disable=W0613\\n cleanup()\\n sys.exit(-2) # Terminate process here as catching the signal\\n # removes the close process behaviour of Ctrl-C\",\n \"def on_interrupt(self, *args) -> None: #pylint: disable=unused-argument\\r\\n if not self.stop_requested:\\r\\n self.stop_requested = True\\r\\n self.logger.critical('SIGINT detected - will stop at the end of the current evolution')\\r\\n else:\\r\\n stop_from = time.time() - 5000\\r\\n if self.last_stop_request > stop_from:\\r\\n raise KeyboardInterrupt\\r\\n else:\\r\\n self.last_stop_request = time.time()\\r\\n self.logger.critical('SIGINT suppressed - repeat within 5 seconds to sigterm')\",\n \"def catch_keyboard_interrupt() -> Callable:\\n return signal.signal(signal.SIGINT, keyboard_interrupt_handler)\",\n \"def signal_handler(signum, frame):\\n self.log.error(\\\"Received SIGTERM. Terminating subprocesses\\\")\\n self.task_runner.terminate()\\n self.handle_task_exit(128 + signum)\",\n \"def signal_handler(self):\\n\\t\\twith open(\\\"/dev/null\\\") as sys.stderr:\\n\\t\\t\\tself._thread_executor.shutdown(wait=False)\\n\\t\\t\\t[task.cancel() for task in Task.all_tasks() if task is not Task.current_task()]\\n\\t\\t\\tself._event_loop.stop()\\n\\t\\t\\tself._dump_test_parser_log()\",\n \"def keyboard_interrupt_handler(sig: int, _: object) -> None:\\n logger.warning(f'KeyboardInterrupt (id: {sig}) has been caught...')\\n logger.info('Terminating the session gracefully...')\\n ray.shutdown()\\n minio_leftovers = glob('*.part.minio')\\n for leftover in minio_leftovers:\\n Path(leftover).unlink()\\n sys.exit(1)\",\n \"def sig_handler(sig, frame):\\n if sig == signal.SIGINT:\\n stop_ros()\\n print(\\\"Shutting down...\\\")\\n sys.exit(0)\",\n \"def signal_handler(signum, frame):\\n monitor.stop()\\n sys.exit(0)\",\n \"def finish(self):\\n super(InterruptibleMixin, self).finish()\\n signal(SIGINT, self.original_handler)\",\n \"def sigterm_handler(signal, frame):\\n GPIO.cleanup()\\n print('WARN : %s Received Kill' % PROG_NAME)\\n print('INFO : Performed GPIO.cleanup. Bye ...')\\n sys.exit(0)\",\n \"def handle_sigint(signum, frame):\\n print(\\\"\\\\nInterrupted by SIGINT\\\\n\\\")\\n sys.exit()\",\n \"def sigint_handler(signal, frame):\\n rclpy.shutdown()\\n if prev_sigint_handler is not None:\\n prev_sigint_handler(signal)\",\n \"def SIGINT(self, signum, frame):\\n for t in [t for t in threading.enumerate() if t.name != 'MainThread']:\\n if hasattr(t, 'stop') and callable(t.stop):\\n t.stop()\\n\\n for t in [t for t in threading.enumerate() if t.name != 'MainThread']:\\n t.join()\\n\\n self.exit(1)\",\n \"def test_control_c_is_possible(self):\\n if platform.type != \\\"posix\\\":\\n raise SkipTest(\\\"I don't have the energy to fight Windows semantics.\\\")\\n program = \\\"\\\"\\\"\\\\\\nimport os, threading, signal, time, sys\\nimport crochet\\ncrochet.setup()\\nfrom twisted.internet.defer import Deferred\\n\\nif sys.platform.startswith('win'):\\n signal.signal(signal.SIGBREAK, signal.default_int_handler)\\n sig_int=signal.CTRL_BREAK_EVENT\\n sig_kill=signal.SIGTERM\\nelse:\\n sig_int=signal.SIGINT\\n sig_kill=signal.SIGKILL\\n\\n\\ndef interrupt():\\n time.sleep(0.1) # Make sure we've hit wait()\\n os.kill(os.getpid(), sig_int)\\n time.sleep(1)\\n # Still running, test shall fail...\\n os.kill(os.getpid(), sig_kill)\\n\\nt = threading.Thread(target=interrupt, daemon=True)\\nt.start()\\n\\nd = Deferred()\\ne = crochet.EventualResult(d, None)\\n\\ntry:\\n e.wait(10000)\\nexcept KeyboardInterrupt:\\n sys.exit(23)\\n\\\"\\\"\\\"\\n kw = {'cwd': crochet_directory}\\n # on Windows the only way to interrupt a subprocess reliably is to\\n # create a new process group:\\n # http://docs.python.org/2/library/subprocess.html#subprocess.CREATE_NEW_PROCESS_GROUP\\n if platform.type.startswith('win'):\\n kw['creationflags'] = subprocess.CREATE_NEW_PROCESS_GROUP\\n process = subprocess.Popen([sys.executable, \\\"-c\\\", program], **kw)\\n self.assertEqual(process.wait(), 23)\",\n \"def SIGINT_handler(signal, frame):\\n exit(2)\",\n \"def interrupt_handler(signum, frame):\\n if DOCKER_MONITOR:\\n util.log.warning(\\\"Signal %d received - Tearing down monitoring\\\"\\n % (signum))\\n DOCKER_MONITOR.tear_down_all()\\n sys.exit(0)\",\n \"def setup_termination():\\n setpgrp()\\n\\n def terminate(signum, frame):\\n logger.debug(\\\"SIGKILL received!\\\")\\n logger.debug(\\\"%d, %s\\\", signum, frame)\\n killpg(0, SIGKILL)\\n\\n signal(SIGINT, terminate)\",\n \"def sigint_handler(signal, frame):\\n print(\\\"SIGINT received by run_end_to_end.py. Terminating process.\\\")\\n exit_gracefully()\\n sys.exit()\",\n \"async def shutdown(signal, loop):\\n print(f\\\"Received exit signal {signal.name}...\\\")\\n print(\\\"Closing redis connections\\\")\\n print(\\\"Nacking outstanding messages\\\")\\n tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]\\n\\n [task.cancel() for task in tasks]\\n\\n print(f\\\"Cancelling {len(tasks)} outstanding tasks\\\")\\n await asyncio.gather(*tasks, return_exceptions=True)\\n print(f\\\"Flushing metrics\\\")\\n loop.stop()\",\n \"def sigint_handler(sig, frame):\\n print(\\\"[i] Caught SIGINT, cleaning up...\\\")\\n server.close()\\n exit(0)\",\n \"def sigterm(signum, frame):\\n loop.stop()\",\n \"def signal_handler(signal_number, stack_frame):\\n if signal_number in [signal.SIGTERM, signal.SIGINT]:\\n terminate_surveillance()\",\n \"def signal_handler(signum, frame):\\n sys.exit(0)\",\n \"def register_signal_handler(self):\\n signal.signal(signal.SIGINT, self.quit_gracefully)\\n signal.signal(signal.SIGTERM, self.quit_gracefully)\\n return\",\n \"def graceful_exit():\\n print(\\\"KeyboardInterrupt, exit(1)\\\")\\n exit(1)\",\n \"def __before_termination__(self, sig):\\n print(\\\"Ahhhh! I'm going to be killed. My pid:{}, signal received:{}\\\".format(self.pid, sig ) )\",\n \"def sigterm_handler(signum: int, stack_frame) -> None:\\n\\n del signum\\n del stack_frame\\n\\n logger.info(\\\"Terminating promqtt. Bye!\\\")\\n sys.exit(0)\",\n \"def IgnoreSigint():\\n signal.signal(signal.SIGINT, signal.SIG_IGN)\",\n \"def signal_handler(aggregator, liveness_probe, signal):\\n\\n if signal == signal.SIGTERM:\\n liveness_probe.close()\\n\\n # Wait aggregator handle with all the received events before close it\\n while (\\n any([not x.channel.empty() for x in aggregator.subscribers])\\n or RequestTimeLogger.current_requests_count > 0\\n ):\\n print(\\\"There are events to handle yet.\\\")\\n\\n aggregator.stop()\\n exit(0)\",\n \"def ctrl_break_trapper(signum: int, stackframe) -> None:\\n log.critical(\\n \\\"Ignoring CTRL+BREAK (signal {}); use the GUI to quit\\\", signum\\n )\",\n \"def sigterm_caught(sig, frame):\\n global child_pid\\n print 'SIGTERM caught, killing wicd-monitor...'\\n os.kill(child_pid, signal.SIGTERM)\\n print 'Removing PID file...'\\n if os.path.exists(wpath.pidfile):\\n os.remove(wpath.pidfile)\\n print 'Shutting down...'\\n sys.exit(0)\",\n \"async def stop_signal():\\n global user_exit\\n user_exit = True\\n await cancel_async_tasks()\",\n \"def signal_handler(signal, frame):\\n\\n print('Aborted. Will shut down all httperf processes')\\n for client in Httperf.all_clients:\\n command = ('ssh {0} -q -o StrictHostKeyChecking=no -o '\\n 'UserKnownHostsFile=/dev/null \\\"pkill httperf \\\"').format(client)\\n subprocess.call(command, shell=True)\\n sys.exit(0)\",\n \"def test_control_c_is_possible(self):\\n if platform.type != \\\"posix\\\":\\n raise SkipTest(\\\"I don't have the energy to fight Windows semantics.\\\")\\n program = \\\"\\\"\\\"\\\\\\nimport os, threading, signal, time, sys\\nimport crochet\\ncrochet.setup()\\nfrom twisted.internet.defer import Deferred\\n\\nif sys.platform.startswith('win'):\\n signal.signal(signal.SIGBREAK, signal.default_int_handler)\\n sig_int=signal.CTRL_BREAK_EVENT\\n sig_kill=signal.SIGTERM\\nelse:\\n sig_int=signal.SIGINT\\n sig_kill=signal.SIGKILL\\n\\n\\ndef interrupt():\\n time.sleep(0.1) # Make sure we've hit wait()\\n os.kill(os.getpid(), sig_int)\\n time.sleep(1)\\n # Still running, test shall fail...\\n os.kill(os.getpid(), sig_kill)\\n\\nt = threading.Thread(target=interrupt, daemon=True)\\nt.start()\\n\\n@crochet.%s\\ndef wait():\\n return Deferred()\\n\\ntry:\\n wait()\\nexcept KeyboardInterrupt:\\n sys.exit(23)\\n\\\"\\\"\\\" % (self.DECORATOR_CALL, )\\n kw = {'cwd': crochet_directory}\\n if platform.type.startswith('win'):\\n kw['creationflags'] = subprocess.CREATE_NEW_PROCESS_GROUP\\n process = subprocess.Popen([sys.executable, \\\"-c\\\", program], **kw)\\n self.assertEqual(process.wait(), 23)\",\n \"def checkInterrupt():\\n if wasInterrupted():\\n raise KeyboardInterrupt()\",\n \"def _handle_ctrl_c(self):\\n # There is a race condition here, we should lock on the value of\\n # executing() to avoid accidentally raising KeyboardInterrupt after\\n # execution has finished. Deal with this later…\\n if self._executing():\\n self._cancel()\\n else:\\n self._last_input = ''\\n self.stdout.write('^C\\\\n')\\n self._output_inserted = False\\n self._more = False\\n self._update_ps(self._more)\\n self._show_ps()\",\n \"def hash_pool_initializer():\\n signal.signal(signal.SIGINT, signal.SIG_IGN)\",\n \"def signal_handler(sig, frame):\\n global shutdown_flag, orig_sighandler\\n signal.signal(signal.SIGTERM, signal.SIG_IGN) # Disable SIGTERM\\n logger.warning(\\\"SIGTERM received! Normally this triggered by the walltime limit.\\\")\\n shutdown_flag.set()\\n return\",\n \"def signal(self):\\n self.mainloop().signal()\",\n \"def capture_signals():\\n # Both Linux and Windows signals\\n signal.signal(signal.SIGINT, stop_server)\\n signal.signal(signal.SIGTERM, stop_server)\\n\\n if platform.system() == \\\"Linux\\\": # Linux only\\n signal.signal(signal.SIGQUIT, stop_server)\\n signal.signal(signal.SIGHUP, stop_server)\",\n \"def _signal_handler(*_: typing.Any) -> None:\\n shutdown_event.set()\",\n \"def signal_handler(*args):\\n if station:\\n station.shutdown()\",\n \"def interrupt(v):\\n print(\\\" \\\" + bcolors.OKBLUE + \\\"[!] Detected CTRL+C ! restoring setting, please wait...\\\" + bcolors.ENDC)\\n bash = \\\"ip link delete dummy type dummy\\\"\\n os.system(bash)\\n if v.spoof:\\n restoreSpoof(v)\\n if v.ntpStatus:\\n ntpToggle(v)\\n print(\\\" \\\" + bcolors.OKGREEN + \\\"Done\\\")\\n print(\\\" --------------------------------------------------------\\\" + bcolors.ENDC)\\n exit()\",\n \"def OnCancelScripts(self, event):\\n # self.shutdown()\\n print(\\\"Cancel multiprocessor\\\")\\n event.Skip()\",\n \"def signal_handler(signum, frame):\\n main.CLOSE = True\",\n \"def on_terminate(self):\\n pass\",\n \"def signal_handler(signal, frame):\\n output.write(\\\"SIGTERM received (launch_simulations talking)\\\\n\\\")\\n p.kill(15)\\n sys.exit(1)\",\n \"def signal_handler(sig, frame):\\n sys.exit(0)\",\n \"def restart_worker_sig_handler(*args):\\n set_in_sighandler(True)\\n safe_say('Restarting celeryd (%s)' % (' '.join(sys.argv), ))\\n import atexit\\n atexit.register(_clone_current_worker)\\n from celery.worker import state\\n state.should_stop = True\",\n \"def signal_handler(signal, frame):\\n sys.exit(0)\",\n \"def signal_handler(signal, frame):\\n sys.exit(0)\",\n \"def signal_handler(signal, frame):\\n sys.exit(0)\",\n \"def _continue_running(self):\\n if self._signal_recieved == signal.SIGINT:\\n return False\\n\\n return True\",\n \"def ctrl_c():\\n from pynput.keyboard import Key, Controller\\n kb = Controller()\\n kb.press(Key.ctrl)\\n kb.press('c')\\n kb.release('c')\\n kb.release(Key.ctrl)\",\n \"def abort_signal(self, signal, frame):\\r\\n\\r\\n print \\\"\\\\nMANUAL TERMINATION: Stopping all threads...\\\"\\r\\n self.stop(True)\\r\\n sys.exit(0)\",\n \"def cancel_workers(self):\\n pass\",\n \"def test_ignore_return(self):\\n from signal import signal, SIGINT, SIG_DFL, SIG_IGN\\n\\n try:\\n for handler in SIG_DFL, SIG_IGN, lambda *a: None:\\n signal(SIGINT, SIG_IGN)\\n assert signal(SIGINT, handler) == SIG_IGN\\n finally:\\n signal(SIGINT, SIG_DFL)\",\n \"def stop(self):\\n # trying this instead of SIGTERM\\n # http://stackoverflow.com/a/6659191/3380530\\n # self._process.send_signal(SIGINT)\\n # Or not. SIGINT doesn't exist on Windows\\n self._process.terminate()\",\n \"def sighandler(signum, frame):\\n global _terminate\\n global _interruptcnt\\n print >> FileKeyUtils.WMSlog, 'sighandler> ', signum\\n ++_interruptcnt \\n if signum in(signal.SIGABRT, signal.SIGINT, signal.SIGTERM):\\n print >> FileKeyUtils.WMSlog, 'sighandler> terminate pid: ', os.getpid(), signum\\n _terminate = True\\n elif signum in(signal.SIGHUP, signal.SIGTSTP):\\n print >> FileKeyUtils.WMSlog, 'sighandler> suspend/stop/pause pid: ', os.getpid(), signum\\n signal.pause()\\n else:\\n print >> FileKeyUtils.WMSlog, 'sighandler> resume/continue pid: ', os.getpid(), signum\\n _terminate = False\",\n \"def sigterm_trapper(signum: int, stackframe) -> None:\\n log.critical(\\\"Ignoring SIGTERM (signal {}); use the GUI to quit\\\", signum)\",\n \"def handle_signal(sig, frame):\\n IOLoop.instance().add_callback(IOLoop.instance().stop)\",\n \"def stop_controller(signum, frame):\\n if controller:\\n print('Stopping controller...')\\n # If stop() hangs, old ctrl+c behaviour will be restored\\n signal.signal(signal.SIGINT, kill_handler)\\n controller.stop()\",\n \"def signal_terminate_handler(signum, frame):\\n \\n print(\\\"Received signal: {}. Your server is terminated \\\".format(signum))\\n client.close()\\n socket_sm.close()\\n sys.exit(0)\",\n \"def interrupt_handler(self, signo, frame):\\n log.debug(\\\"interrupting run\\\")\\n self._keep_running = False\",\n \"def _sigint(self, signal, frame):\\n self.disconnect = True\\n if self.cardinal:\\n self.cardinal.quit('Received SIGINT.')\",\n \"def cleanup(self, sig, func=None):\\n\\n print \\\"Closing up shop...\\\"\\n\\n # Disconnect all of our remote controllers\\n for c in self.config_list:\\n self.config_list[c].disconnect()\\n\\n # Kill our data handler\\n self.INPUT_QUEUE.put(G.CTRL_CMD_KILL)\\n\\n # Terminate the consumers and producers\\n self.in_queue.put(G.CTRL_CMD_KILL)\\n self.out_queue.put(G.CTRL_CMD_KILL)\\n for child in self.comm_processes:\\n child.stop()\",\n \"def _signal_workaround(shutdown: asyncio.Future) -> None:\\n\\n async def wakeup() -> None:\\n while not shutdown.done():\\n await asyncio.sleep(0.1)\\n\\n def signint_handler(signalnum: int, frame: types.FrameType):\\n shutdown.set_result(None)\\n\\n signal.signal(signal.SIGINT, signint_handler)\\n asyncio.get_running_loop().create_task(wakeup())\",\n \"def signal_handler(self, sig, frame):\\n print('You pressed Ctrl+C!')\\n response = input(\\\"Would you like to terminate a user session? [y/n] \\\")\\n if response.lower() == 'exit':\\n print(\\\"fast exiting..\\\")\\n sys.exit(0)\\n\\n\\n if response.lower() == 'y':\\n trying = 'y'\\n while trying.lower() == 'y':\\n print(\\\"Choose a user to remove:\\\\n\\\")\\n user_list = []\\n for client in self.clients:\\n user_list.append(self.clients[client]['data'].decode('utf-8'))\\n for user in user_list: print(user)\\n response = input(\\\"Enter user to remove: \\\")\\n for client in self.clients:\\n if self.clients[client]['data'].decode('utf-8') == response:\\n msg = f\\\"Booting client {self.clients[client]} from server...\\\"\\n self.log_and_send(client, msg)\\n print(\\\"Closing socket...\\\")\\n self.sockets_list.remove(client)\\n del self.clients[client]\\n client.shutdown(socket.SHUT_RDWR)\\n print(f\\\"Client {response} booted. Returning to listening...\\\")\\n return\\n trying = input(\\\"No matching client found. Try again? [y/n] \\\")\\n\\n response = input(\\\"Save config? [y/n] \\\")\\n\\n if response.lower() == 'y' or response == '\\\\n':\\n print('Saving config and closing all sockets...')\\n for _socket in self.clients:\\n self.pp.pprint(_socket)\\n _socket.close()\\n self.save_config()\\n \\n response = input(\\\"Terminate server session? [y/n] \\\")\\n if response.lower() == 'y':\\n print('Exiting, good')\\n sys.exit(0)\",\n \"def _signal_handler(*args):\\n self._user_exit = True\",\n \"def signal_handler(signal, _): \\n import signal\\n import sys\\n from time import localtime, strftime\\n signal.signal(signal.SIGINT, original_sigint)\\n thetime = strftime(\\\"%H:%M:%S\\\", localtime())\\n INPUTFUNC('\\\\n\\\\n%s: Paused. Press any key to resume, or ctrl+c to quit.\\\\n' % thetime)\\n time = strftime(\\\"%H:%M:%S\\\", localtime())\\n print('%s: Interrogation resumed.\\\\n' % time)\\n signal.signal(signal.SIGINT, signal_handler)\",\n \"def _sigterm_handler(signum: int, _frame: FrameType) -> None:\\n sys.exit('from sigterm handler')\",\n \"def trap_signal(sig, _):\\n CONSUL.agent.service.deregister(service_id=\\\"pyTest-{}\\\".format(iServicePort))\\n exit()\",\n \"def sigint_handler(*args):\\n sys.stderr.write('\\\\r')\\n QtGui.QApplication.quit()\",\n \"def interrupt_kernel(self):\",\n \"def _signal_handler(signum, frame):\\n res_mgr()\\n sys.exit(0)\",\n \"def trap_sigint(handler, ignoreNum=0):\\n handlers = _SIGINT_HANDLERS\\n handlers.attach_override_unix(signal.SIGINT)\\n handlers.register(handler, ignoreNum)\",\n \"def stop(self, signal):\\n pass\",\n \"def stop(self, signal):\\n pass\",\n \"def signal_handler(signal, frame):\\n map(lambda xcnode: xcnode.fd.close(), xcnodes)\\n print 'Exiting program!'\\n sys.exit(0)\",\n \"def _termination_handler(self, signum, frame):\\n print '[i] Shutting down...'\\n self.sensor.close()\\n sys.exit(1)\",\n \"def register_exit_signals(self):\\n signal.signal(signal.SIGINT, self._exit_gracefully)\\n signal.signal(signal.SIGTERM, self._exit_gracefully)\\n # So that we ignore the debug dump signal, making it easier to send\\n signal.signal(signal.SIGUSR2, signal.SIG_IGN)\",\n \"def handleKeyboardInterupt():\\n System.stopExecution(TERMINATED_BY_USER)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7222166","0.72151893","0.7180323","0.71768016","0.6984043","0.6946091","0.69356275","0.6917393","0.6899606","0.6881529","0.6845854","0.6804447","0.67696905","0.6766118","0.67553","0.67504436","0.66279745","0.65575314","0.6528643","0.64279413","0.63987356","0.6369797","0.63381016","0.6297128","0.62945735","0.6290728","0.62819535","0.6192877","0.61848485","0.6180156","0.60982555","0.60896045","0.6078561","0.60673124","0.6014794","0.6002632","0.5969158","0.5940953","0.59008425","0.58876365","0.58736944","0.5870838","0.5867591","0.58667016","0.58602893","0.58507514","0.5846607","0.5822017","0.58055973","0.5803076","0.58007693","0.5795893","0.5783716","0.5773271","0.5769172","0.5751514","0.5739911","0.57163405","0.57094127","0.5695585","0.5690499","0.56900257","0.568183","0.5681611","0.5673143","0.5669527","0.56384957","0.56161845","0.56161845","0.56161845","0.56086564","0.55989987","0.5595068","0.55949396","0.55836606","0.55778396","0.55771077","0.5568739","0.55628","0.55600774","0.55572814","0.5534478","0.55329466","0.5524123","0.55233955","0.55146664","0.55143434","0.55143","0.5496462","0.5495656","0.548516","0.5476141","0.5473788","0.5473609","0.5463762","0.5463762","0.5462991","0.5450966","0.5441163","0.5436293"],"string":"[\n \"0.7222166\",\n \"0.72151893\",\n \"0.7180323\",\n \"0.71768016\",\n \"0.6984043\",\n \"0.6946091\",\n \"0.69356275\",\n \"0.6917393\",\n \"0.6899606\",\n \"0.6881529\",\n \"0.6845854\",\n \"0.6804447\",\n \"0.67696905\",\n \"0.6766118\",\n \"0.67553\",\n \"0.67504436\",\n \"0.66279745\",\n \"0.65575314\",\n \"0.6528643\",\n \"0.64279413\",\n \"0.63987356\",\n \"0.6369797\",\n \"0.63381016\",\n \"0.6297128\",\n \"0.62945735\",\n \"0.6290728\",\n \"0.62819535\",\n \"0.6192877\",\n \"0.61848485\",\n \"0.6180156\",\n \"0.60982555\",\n \"0.60896045\",\n \"0.6078561\",\n \"0.60673124\",\n \"0.6014794\",\n \"0.6002632\",\n \"0.5969158\",\n \"0.5940953\",\n \"0.59008425\",\n \"0.58876365\",\n \"0.58736944\",\n \"0.5870838\",\n \"0.5867591\",\n \"0.58667016\",\n \"0.58602893\",\n \"0.58507514\",\n \"0.5846607\",\n \"0.5822017\",\n \"0.58055973\",\n \"0.5803076\",\n \"0.58007693\",\n \"0.5795893\",\n \"0.5783716\",\n \"0.5773271\",\n \"0.5769172\",\n \"0.5751514\",\n \"0.5739911\",\n \"0.57163405\",\n \"0.57094127\",\n \"0.5695585\",\n \"0.5690499\",\n \"0.56900257\",\n \"0.568183\",\n \"0.5681611\",\n \"0.5673143\",\n \"0.5669527\",\n \"0.56384957\",\n \"0.56161845\",\n \"0.56161845\",\n \"0.56161845\",\n \"0.56086564\",\n \"0.55989987\",\n \"0.5595068\",\n \"0.55949396\",\n \"0.55836606\",\n \"0.55778396\",\n \"0.55771077\",\n \"0.5568739\",\n \"0.55628\",\n \"0.55600774\",\n \"0.55572814\",\n \"0.5534478\",\n \"0.55329466\",\n \"0.5524123\",\n \"0.55233955\",\n \"0.55146664\",\n \"0.55143434\",\n \"0.55143\",\n \"0.5496462\",\n \"0.5495656\",\n \"0.548516\",\n \"0.5476141\",\n \"0.5473788\",\n \"0.5473609\",\n \"0.5463762\",\n \"0.5463762\",\n \"0.5462991\",\n \"0.5450966\",\n \"0.5441163\",\n \"0.5436293\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72294533"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83177,"cells":{"query":{"kind":"string","value":"Wrapper used to pass params to workers"},"document":{"kind":"string","value":"def create_mask_wrapper(args, crop=None, scale=1, flip=False,\n reflective=False, warm=False, reduce_red=False,\n saturate=False):\n input_filename, output_filename = args[0], args[1]\n try:\n img, mask = get_mask(input_filename, crop, scale, flip, reflective,\n warm, reduce_red, saturate)\n except:\n return\n mask = np.expand_dims(mask, axis=2)\n mask = (255 * mask).astype(np.uint8)\n img = np.concatenate((img, mask), axis=2)\n cv2.imwrite(output_filename, img)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _worker(self, args):\n pass","def init_worker(*shared_args_list):\n global SHARED_ARGS\n SHARED_ARGS = shared_args_list","def job_as_parameter(f):\n f.job_as_parameter = True\n return f","def process_task(params):\n params['task'](params)","def set_params(self, params):","def wrapper(*args):","def _submit_unpack_kwargs(self, params):\n return self._submit(**params)","def __init__(**params):","def _get_executor_init(self, workers):\n raise NotImplementedError","def __init__(self, worker_id=0, base_port=5005):","def _shared_params(self):\n params = {}\n if _NUM_BATCHES.value is not None:\n params['num_batches'] = _NUM_BATCHES.value\n if self.output_dir is not None:\n params['benchmark_log_dir'] = self.output_dir\n return benchmark_cnn.make_params(**params)","def exec_worker(self, endpoint, args, request):\n raise NotImplementedError","def params(self):\n pass","def _run_parallel(parameters):\n\n # make parallel context global\n global pc\n\n print parameters\n # create parallel context instance\n pc = h.ParallelContext()\n\n print 'i am', pc.id(), 'of', pc.nhost()\n # start workers, begins an infinitely loop where master workers posts jobs and workers pull jobs until all jobs are finished\n pc.runworker()\n \n # print len(parameters)\n # # # distribute experiment and parameters to workers\n for param in parameters:\n # print len(parameters)\n # print param\n pc.submit(_f_parallel, param)\n # print param\n\n # # continue runnning until all workers are finished\n while pc.working():\n print pc.id(), 'is working'\n\n # # close parallel context \n pc.done()","def main(self, params):\n pass","def executor(self):","def get_params(self):","def params():\n raise NotImplementedError","def worker(self, **options):\n pass","def set_params(self, **kwargs):\n ...","def __init__(self, *args, wick_parallel=0, **kwargs):\n super().__init__(*args, **kwargs)\n self._wick_parallel = wick_parallel","def postprocess_hyperparams(args, config):\n pass","def do_work(self):","def docker_worker():","def run(self, worker, evaluator=None):\n pass","def worker(self, arg):\n # https://stackoverflow.com/questions/16878315/what-is-the-right-way-to-treat-python-argparse-namespace-as-a-dictionary\n # Extract the dictionary __dict__ from the argparse args namespace\n d = vars(self.args)\n # Insert the multiprocess-supplied arg into that __dict__\n d[self.iterable] = arg\n # Call the function, which expects an argparse namespace with\n # the amended __dict__\n self.function(self.args)","def set_params(self):\r\n pass","def __setattr__(self, name, value):\n if hasattr(self, name):\n super(JobSubmission, self).__setattr__(name, value)\n\n else:\n self.params[str(name)] = str(value) #TODO: resolve parameter cases","def __init__(self, worker_device):\n self._worker_device = worker_device\n self._local_map = {}\n self._global_map = {}","def _get_worker_args(worker_id, working_dir, **kwargs):\n args = dict()\n args['worker_id'] = worker_id\n args['working_dir'] = _make_internal_url(working_dir)\n\n accepted_args = ['check_hdfs', 'startup_timeout', 'consensus_address'] + list(args.keys())\n for key in accepted_args:\n if key in kwargs:\n args[key] = kwargs[key]\n return ['--%s=%s' % (k, v) for k, v in args.items()]","def Params(cls):\n p = super().Params()\n p.Define('train_task', None, 'Underlying task')\n p.Define('decode_task', None, 'Underlying task')\n p.Define('train_dataset_name', None, '')\n p.Define('decode_dataset_name', None, '')\n p.Define('train_steps_per_loop', 0, '')\n p.Define('decode_steps_per_loop', 0, '')\n return p","def set_hyperparams(self, params):","def execute_wrapper(self, pool_id, queue, subtasktuples, counter):\n self._saver.set_mode('dict')\n if self._storegate.backend == 'hybrid':\n self._storegate.set_mode('numpy')\n\n for subtasktuple in subtasktuples:\n subtasktuple.env.pool_id = pool_id\n\n result = self.execute_pipeline(subtasktuples, counter)\n queue.put(result)","def set_params(self, *argv, **kwargs):\n pass","def set_params(self, *argv, **kwargs):\n pass","def set_params(self, *argv, **kwargs):\n pass","def set_params(self, *argv, **kwargs):\n pass","def set_params(self, *argv, **kwargs):\n pass","def Params(cls):\n p = hyperparams.InstantiableParams(cls)\n p.Define('task_dict', None, 'dataset_name -> task params')\n p.Define('task_name', None, 'High level task name')\n p.Define('logdir', None, 'Log directory')\n p.Define('train_program', None, 'Train program params')\n p.Define('train_executions_per_eval', 1, '')\n p.Define('eval_programs', [], 'List of eval program params.')\n p.Define('num_splits_per_client', None, '')\n p.Define('dataset_names', [], 'List of all dataset names.')\n p.Define('emails', [], 'List of emails to send metrics.')\n p.Define('summary_exporter', None, 'The summary exporter Params.')\n p.Define('async_postprocess', True,\n 'whether to CPU postprocess asynchronously with TPU train')\n p.Define(\n 'checkpoint_to_load', None,\n 'If set, the program will initially load from this checkpoint, '\n 'ignoring train_dir. Typically used for oneoff decode.')\n\n # TODO(blee): Clean these up.\n p.Define('ml_perf', hyperparams.Params(), 'MlPerf configuration.')\n mlp = p.ml_perf\n mlp.Define('submission_metadata', None,\n 'A dictionary of static submission metadata')\n mlp.Define('benchmark_name', None, 'Benchmark name for compliance log.')\n mlp.Define('steps_per_epoch', None, 'Number of training steps per epoch.')\n mlp.Define('decoder_metric_name', None,\n 'Name of the decoder metric to report for compliance log.')\n mlp.Define('decoder_metric_success_threshold', None,\n 'Benchmark run must exceed this value to succeed.')\n mlp.Define('max_steps_to_train', None,\n 'Maximum number of steps to reach target accuracy')\n return p","def __init__(self, mapper, workers, date, logger):\n \n self.mapper = mapper\n self.workers = workers\n self.date = date\n self.log = logger","def __call__(self, param, xyz=False):\n pass","def getWorker(self):\n pass","def run(self, **kwargs):","def set_params(self, *arg):\n pass","def get_params(self, **params): # pylint: disable=unused-argument\n res = copy.deepcopy(self.sk_params)\n res.update({'build_fn': self.build_fn})\n return res","def test_all_params(self):\n broker = FakeBroker()\n worker_helper = WorkerHelper(\"my_connector\", broker)\n self.assertEqual(worker_helper._connector_name, \"my_connector\")\n self.assertEqual(worker_helper.broker, broker)","def sync_params(params, src_rank=0, group=dist.group.WORLD, comm=None, use_mpi=False):\n datas = [p.data for p in params]\n flatvec = flatten_tensors(datas)\n if use_mpi:\n if comm is None:\n comm = DEFAULT_COMM\n flatvec = th2np(flatvec)\n comm.Bcast(flatvec, root=0)\n flatvec = np2th(flatvec)\n else:\n dist_broadcast(flatvec, src=src_rank, group=group)\n unflatten_to(flatvec, datas)","def _passing_args_impl(self, pool_class_factory):\n DELTA = 12\n ITERATIONS = 100\n pool = pool_class_factory()\n\n pool.start(CoeffMultiplierWorker, {'coeff': DELTA})\n for i in range(ITERATIONS):\n pool.ventilate(message='Vent data {}'.format(i), value=i)\n\n all_results = [pool.get_results() for _ in range(ITERATIONS)]\n self.assertEqual({DELTA}, set(np.diff(sorted(all_results))))\n\n pool.stop()\n pool.join()","def work(self, job):\n pass","def _use_existing_params(self):\n sh = shelve.open(os.path.expanduser('~/.config/scheduler/params'))\n self.params = sh['params']\n sh.close()","def __init__(self, mk_func, *args,\n processes = 1,\n verbose = False,\n queue = SimpleQueue,\n pass_pid = False):\n # Create basic queues:\n todo, done = SimpleQueue (), SimpleQueue ()\n \n pool_size = processes if processes > 0 else max (1, cpu_count () - 1)\n pool = tuple (Process (target = worker_process,\n args = (pid, verbose, mk_func, todo, done,) + args,\n kwargs = dict (pass_pid = pass_pid))\n for pid in range (pool_size))\n\n self.verbose = verbose\n self.todo, self.done, self.pool = todo, done, pool","def _StartWorkerProcess(self, process_name):","def progress_wrapper(user_defined_function: Callable, master_workers_queue: multiprocessing.Queue, index: int, chunk_size: int) -> Callable:\n ...","def __prepare_parameter__(self, in_args):\n if self.__use_remote_sparse_updater__():\n self.__gradient_machine__.prefetch(in_args)\n self.__parameter_updater__.getParametersRemote()","def test_parameters(self):\n class Test(pyperry.Base): pass\n Test.add_processor('read', self.Processor)\n Test.add_processor('read', self.Processor, { 'foo': 'bar' })\n Test.add_processor('read', self.Processor, foo='bar')","def __make_params(args):\n data = {}\n for i in range(len(args)):\n if i == 0: # saltando a primeira iteracao pra\n # saltar o parametro que é o nome do arquivo de execução\n continue\n if not i % 2 == 0:\n data[args[i]] = args[i + 1]\n return data","def exec_worker_passthrough(self, endpoint, args, request):\n method = getattr(requests, request.method.lower())\n data = request.data if request.data else request.form\n url = _join(self.url, endpoint)\n response = method(url, params=request.args, data=data)\n return Response(\n response=response.content,\n status=response.status_code,\n headers=response.headers.items())","def init_params(self):\n blah","def set_params(self):\n raise NotImplementedError","def get_params(self):\n pass","def init_worker(X, X_shape, Y, Y_shape):\n arr_dict['X'] = X\n arr_dict['X_shape'] = X_shape\n arr_dict['Y'] = Y\n arr_dict['Y_shape'] = Y_shape","def __init__(self, num_workers, eval_function, timeout=None, maxtasksperchild=None):\n self.eval_function = eval_function\n self.timeout = timeout\n self.pool = Pool(processes=num_workers, maxtasksperchild=maxtasksperchild)","def parameters(self):","def initialize_params(self, params):\n pass","def setWorker(self, worker):\n pass","def _set_params(self, estimator_args, scaler_args, execution_args, metric_args=None, dim_reduction_args=None):\n \n # Set default values which will be used if execution arguments are not passed\n \n # Default parameters:\n self.model.overwrite = True\n self.model.debug = False\n self.model.test_size = 0.33\n self.model.cv = 0\n self.model.time_series_split = 0\n self.model.max_train_size = None\n self.model.random_state = 42\n self.model.compress = 3\n self.model.retain_data = False\n self.model.scale_hashed = True\n self.model.scale_vectors = True\n self.model.scaler = \"StandardScaler\"\n self.model.scaler_kwargs = {}\n self.model.estimator_kwargs = {}\n self.model.missing = \"zeros\"\n self.model.calc_feature_importances = False\n self.model.importances_n_repeats = 30\n self.model.lags= None\n self.model.lag_target = False\n self.model.scale_target = False\n self.model.scale_lag_target= True\n self.model.make_stationary = None\n self.model.stationarity_lags = [1]\n self.model.using_keras = False\n self.model.current_sample_as_input = True\n self.model.prediction_periods = 1\n \n # Default metric parameters:\n if metric_args is None:\n self.model.metric_args = {}\n \n # Set execution parameters\n \n # If the execution key word arguments were included in the request, get the parameters and values\n if len(execution_args) > 0:\n \n # Transform the string of arguments into a dictionary\n execution_args = utils.get_kwargs(execution_args)\n \n # Set the overwite parameter if any existing model with the specified name should be overwritten\n if 'overwrite' in execution_args:\n self.model.overwrite = 'true' == execution_args['overwrite'].lower()\n \n # Set the test_size parameter that will be used to split the samples into training and testing data sets\n # Default value is 0.33, i.e. we use 66% of the samples for training and 33% for testing\n if 'test_size' in execution_args:\n self.model.test_size = utils.atof(execution_args['test_size'])\n\n # Enable K-fold cross validation. For more information see: http://scikit-learn.org/stable/modules/cross_validation.html#multimetric-cross-validation\n # Default value is 0 in which case a simple holdout strategy based on the test_size parameter is used.\n # If cv > 0 then the model is validated used K = cv folds and the test_size parameter is ignored.\n if 'cv' in execution_args:\n self.model.cv = utils.atoi(execution_args['cv'])\n \n # Enable timeseries backtesting using TimeSeriesSplit. https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.TimeSeriesSplit.html\n # This will select the a validation strategy appropriate for time series and sequential data.\n # The feature definitions must include an 'identifier' field which can be used to sort the series into the correct order.\n # The integer supplied in this parameter will split the data into the given number of subsets for training and testing.\n if 'time_series_split' in execution_args:\n self.model.time_series_split = utils.atoi(execution_args['time_series_split'])\n\n # This parameter can be used together with time_series_split.\n # It specifies the maximum samples to be used for training in each split, which allows for rolling/ walk forward validation.\n if 'max_train_size' in execution_args:\n self.model.max_train_size = utils.atoi(execution_args['max_train_size'])\n\n # Add lag observations to the feature matrix. Only applicable for Keras models.\n # An identifier field must be included in the feature definitions to correctly sort the data for this capability.\n # For e.g. if lags=2, features from the previous two samples will be concatenated as input features for the current sample.\n # This is useful for framing timeseries and sequence prediction problems into 3D or 4D data required for deep learning.\n if 'lags' in execution_args:\n self.model.lags = utils.atoi(execution_args['lags'])\n\n # Include targets in the lag observations\n # If True an additional feature will be created for each sample using the previous value of y \n if 'lag_target' in execution_args:\n self.model.lag_target = 'true' == execution_args['lag_target'].lower()\n \n # Scale the target before fitting\n # The scaling will be inversed before predictions so they are returned in the original scale \n if 'scale_target' in execution_args:\n self.model.scale_target = 'true' == execution_args['scale_target'].lower()\n\n # Scale lag values of the targets before fitting\n # Even if scale_target is set to false, the lag values of targets being used as features can be scaled by setting this to true \n if 'scale_lag_target' in execution_args:\n self.model.scale_lag_target = 'true' == execution_args['scale_lag_target'].lower()\n\n # Make the target series more stationary. This only applies to sequence prediction problems.\n # Valid values are 'log' in which case we apply a logarithm to the target values,\n # or 'difference' in which case we transform the targets into variance from the previous value.\n # The transformation will be reversed before returning predictions.\n if 'make_stationary' in execution_args:\n self.model.make_stationary = execution_args['make_stationary'].lower()\n\n # Provide lags periods for differencing\n # By default the difference will be done with lag = 1. Alternate lags can be provided by passing a list of lags as a list.\n # e.g. 'stationarity_lags=1;12|list|int'\n if 'stationarity_lags' in execution_args:\n self.model.stationarity_lags = utils.get_kwargs_by_type({'stationarity_lags': execution_args['stationarity_lags']})['stationarity_lags']\n\n # Specify if the current sample should be used as input to the model\n # This is to allow for models that only use lag observations to make future predictions\n if 'current_sample_as_input' in execution_args:\n self.model.current_sample_as_input = 'true' == execution_args['current_sample_as_input'].lower()\n\n # Specify the number of predictions expected from the model\n # This can be used to get a model to predict the next m periods given inputs for the previous n periods.\n # This is only valid for Keras models which have a final output layer with more than one node\n if 'prediction_periods' in execution_args:\n self.model.prediction_periods = utils.atoi(execution_args['prediction_periods'])\n \n # Seed used by the random number generator when generating the training testing split\n if 'random_state' in execution_args:\n self.model.random_state = utils.atoi(execution_args['random_state'])\n \n # Compression level between 1-9 used by joblib when saving the model\n if 'compress' in execution_args:\n self.model.compress = utils.atoi(execution_args['compress'])\n \n # Flag to determine if the training and test data should be saved in the model\n if 'retain_data' in execution_args:\n self.model.retain_data = 'true' == execution_args['retain_data'].lower()\n\n # Flag to determine if feature importances should be calculated when the fit method is called\n if 'calculate_importances' in execution_args:\n self.model.calc_feature_importances = 'true' == execution_args['calculate_importances'].lower()\n\n # Sets the number of times a feature is randomly shuffled during the feature importance calculation\n if 'importances_n_repeats' in execution_args:\n self.model.importances_n_repeats = utils.atoi(execution_args['importances_n_repeats'])\n \n # Set the debug option for generating execution logs\n # Valid values are: true, false\n if 'debug' in execution_args:\n self.model.debug = 'true' == execution_args['debug'].lower()\n \n # Additional information is printed to the terminal and logs if the paramater debug = true\n if self.model.debug:\n # Increment log counter for the class. Each instance of the class generates a new log.\n self.__class__.log_no += 1\n\n # Create a log file for the instance\n # Logs will be stored in ..\\logs\\SKLearn Log <n>.txt\n self.logfile = os.path.join(os.getcwd(), 'logs', 'SKLearn Log {}.txt'.format(self.log_no))\n \n # Create dictionary of parameters to display for debug\n self.exec_params = {\"overwrite\":self.model.overwrite, \"test_size\":self.model.test_size, \"cv\":self.model.cv,\\\n \"time_series_split\": self.model.time_series_split, \"max_train_size\":self.model.max_train_size, \"lags\":self.model.lags,\\\n \"lag_target\":self.model.lag_target, \"scale_target\":self.model.scale_target, \"make_stationary\":self.model.make_stationary,\\\n \"random_state\":self.model.random_state, \"compress\":self.model.compress, \"retain_data\":self.model.retain_data,\\\n \"calculate_importances\": self.model.calc_feature_importances, \"importances_n_repeats\": self.model.importances_n_repeats,\\\n \"debug\":self.model.debug}\n\n self._print_log(1)\n \n # If the scaler key word arguments were included in the request, get the parameters and values\n if len(scaler_args) > 0:\n \n # Transform the string of arguments into a dictionary\n scaler_args = utils.get_kwargs(scaler_args)\n \n # Set scaler arguments that will be used when preprocessing the data\n # Valid values are: StandardScaler, MinMaxScaler, MaxAbsScaler, RobustScaler and QuantileTransformer\n # More information here: http://scikit-learn.org/stable/modules/preprocessing.html\n if 'scaler' in scaler_args:\n self.model.scaler = scaler_args.pop('scaler')\n \n if 'missing' in scaler_args:\n self.model.missing = scaler_args.pop('missing').lower()\n \n if 'scale_hashed' in scaler_args:\n self.model.scale_hashed = 'true' == scaler_args.pop('scale_hashed').lower()\n \n if 'scale_vectors' in scaler_args:\n self.model.scale_vectors = 'true' == scaler_args.pop('scale_vectors').lower()\n \n # Get the rest of the scaler parameters, converting values to the correct data type\n self.model.scaler_kwargs = utils.get_kwargs_by_type(scaler_args) \n else:\n err = \"Arguments for scaling did not include the scaler name e.g StandardScaler\"\n raise Exception(err)\n \n # If the estimator key word arguments were included in the request, get the parameters and values\n if len(estimator_args) > 0:\n \n # Transform the string of arguments into a dictionary\n estimator_args = utils.get_kwargs(estimator_args)\n \n # Set estimator arguments that will be used when preprocessing the data\n # The parameters available will depend on the selected estimator\n # More information here: http://scikit-learn.org/stable/modules/classes.html#api-reference\n if 'estimator' in estimator_args:\n self.model.estimator = estimator_args.pop('estimator')\n \n # Set the estimator type for the model\n if self.model.estimator in self.classifiers:\n self.model.estimator_type = \"classifier\"\n elif self.model.estimator in self.regressors:\n self.model.estimator_type = \"regressor\"\n elif self.model.estimator in self.decomposers:\n self.model.estimator_type = \"decomposer\"\n elif self.model.estimator in self.clusterers:\n self.model.estimator_type = \"clusterer\"\n else:\n err = \"Unknown estimator class: {0}\".format(self.model.estimator)\n raise Exception(err)\n\n # Get the rest of the estimator parameters, converting values to the correct data type\n self.model.estimator_kwargs = utils.get_kwargs_by_type(estimator_args) \n else:\n err = \"Arguments for estimator did not include the estimator class e.g. RandomForestClassifier\"\n raise Exception(err)\n \n # If key word arguments for model evaluation metrics are included in the request, get the parameters and values\n if metric_args is not None and len(metric_args) > 0:\n # Transform the string of arguments into a dictionary\n metric_args = utils.get_kwargs(metric_args)\n \n # Get the metric parameters, converting values to the correct data type\n self.model.metric_args = utils.get_kwargs_by_type(metric_args) \n \n # If key word arguments for dimensionality reduction are included in the request, get the parameters and values\n if dim_reduction_args is not None and len(dim_reduction_args) > 0:\n # Transform the string of arguments into a dictionary\n dim_reduction_args = utils.get_kwargs(dim_reduction_args)\n \n # Set dim_reduction arguments that will be used after preprocessing the data\n # The parameters available will depend on the selected dimensionality reduction method\n # Acceptable classes are PCA, KernelPCA, IncrementalPCA, TruncatedSVD\n # More information here: http://scikit-learn.org/stable/modules/classes.html#api-reference\n if 'reduction' in dim_reduction_args:\n self.model.reduction = dim_reduction_args.pop('reduction')\n \n # Get the rest of the dim_reduction parameters, converting values to the correct data type\n self.model.dim_reduction_args = utils.get_kwargs_by_type(dim_reduction_args) \n else:\n err = \"Arguments for dimensionality reduction did not include the class e.g. PCA\"\n raise Exception(err)\n \n # Debug information is printed to the terminal and logs if the paramater debug = true\n if self.model.debug:\n self._print_log(2)","def call(self, *args, **kwargs):","def test_task_params(self, task_mock):\n from sosbeacon.event.message import get_group_broadcast_task\n\n group_key = Mock()\n group_key.urlsafe.return_value = \"AGROUPKEY\"\n\n event_key = Mock()\n event_key.urlsafe.return_value = \"SOMEEVENTKEY\"\n\n message_key = Mock()\n message_key.urlsafe.return_value = \"SOMEMESSAGEKEY\"\n\n batch_id = \"THEBATCHID\"\n iteration = 19\n\n get_group_broadcast_task(\n group_key, event_key, message_key, batch_id, iteration)\n\n check_params = {\n 'group': 'AGROUPKEY',\n 'event': 'SOMEEVENTKEY',\n 'message': 'SOMEMESSAGEKEY',\n 'batch': 'THEBATCHID',\n 'cursor': '',\n 'iter': 19\n }\n self.assertEqual(check_params, task_mock.call_args[1]['params'])","def pull_server_parameters(self, executor: Executor) -> None:\n request = Weights.Request()\n request.id = self._worker_id\n self._future_weights = self._cli['weights'].call_async(request)\n rclpy.spin_until_future_complete(self, self._future_weights, executor)","def Params(cls):\n p = hyperparams.InstantiableParams(cls)\n p.Define('task', None, 'Underlying task')\n p.Define('logdir', None, 'Log directory')\n p.Define('num_splits_per_client', None, '')\n p.Define('steps_per_loop', None, 'Number of steps to run.')\n p.Define('dataset_name', None,\n 'Dataset the program is operating on, eg: \"Test\"')\n p.Define('name', 'base_program', 'Program name.')\n p.Define('task_name', None,\n 'If multi-task, what the high-level task name is')\n p.Define('num_threads', 1, 'Number of threads in multiprocessing pool.')\n p.Define('spmd', False, 'Whether program is running under SPMD mode.')\n p.Define('write_train_input_stats', False,\n 'Whether to write input data stats during training.')\n p.Define('max_metrics', 256, 'Overrides TpuEvalMetrics.max_metrics')\n p.Define('ml_perf', None, 'MLPerf config')\n return p","def update_params(self):\n pass","def execute(self, *args, **kwargs):","def execute(self, *args, **kwargs):","def update(self, params):","def set_params(self, **params):\n if('threshold' in params.keys()):\n self.threshold = params['threshold']\n if('subsample' in params.keys()):\n self.subsample = params['subsample']\n if('estimator' in params.keys()):\n self.estimator = params['estimator']\n if('n_folds' in params.keys()):\n self.n_folds = params['n_folds']\n if('stratify' in params.keys()):\n self.stratify = params['stratify']\n if('random_state' in params.keys()):\n self.random_state = params['random_state']\n if('n_jobs' in params.keys()):\n self.n_jobs = params['n_jobs']","def set_params(self, params: Dict):\n\n if params['training_instances'] is not None:\n self.training_instances = params['training_instances']\n if params['n'] is not None:\n self.n = params['n']\n if params['lda'] is not None:\n self.lda = params['lda']\n if params['verbose'] is not None:\n self.verbose = params['verbose']\n\n self.num_features = self.training_instances[0].get_feature_count()\n self.w = None\n self.b = None","def Params(cls):\n p = hyperparams.InstantiableParams(cls)\n\n p.Define('task_dict', None, 'dataset_name -> task params')\n p.Define('task_name', None, 'High level task name')\n p.Define('logdir', None, 'Log directory')\n p.Define('train_program', None, 'Train program params')\n p.Define('train_executions_per_eval', 1, '')\n p.Define('dataset_names', [], 'List of all dataset names.')\n p.Define('num_splits_per_client', None, '')\n\n p.Define('ml_perf', hyperparams.Params(), 'MlPerf configuration.')\n\n mlp = p.ml_perf\n mlp.Define('benchmark_name', None, 'Benchmark name for compliance log.')\n mlp.Define('decoder_metric_name', None,\n 'Name of the decoder metric to report for compliance log.')\n mlp.Define('decoder_metric_success_threshold', None,\n 'Benchmark run must exceed this value to succeed.')\n mlp.Define('max_steps_to_train', None,\n 'Maximum number of steps to reach target accuracy')\n mlp.Define('steps_per_epoch', None, 'Number of training steps per epoch.')\n mlp.Define('global_batch_size', None, 'Global batch size.')\n mlp.Define('max_sequence_length', None, 'Maximum sequence length.')\n mlp.Define('optimizer_name', None, 'Optimizer used.')\n mlp.Define('base_learning_rate', None, 'Base learning rate.')\n mlp.Define('warmup_steps', None, 'Number of warm-up steps.')\n\n return p","def __init__(self, worker_id: str,\n config: Config) -> None:\n self.worker_id = worker_id\n self.config = config","def get_params(self, deep=...):\n ...","def evaluate_system__initialize_workers(opts, dictionary, features, labels):\n global evaluate_system__worker_cache\n evaluate_system__worker_cache = {\"opts\": opts, \"dictionary\": dictionary, \"features\": features, \"labels\": labels}","def __init__( self, parameters={} ):\n self.params = {}","def __call__(self):\n if grinder.runNumber == 0: self.initialSleep()\n (param1, param2) = self.getParam()\n self.request1(param1, param2)","def task():","def params(cls):\n def method_decorator(method):\n @wraps(method)\n def wrapper(self, *args):\n return method(self, *map(cls, args))\n return wrapper\n return method_decorator","def define_parameters(self):","def setParameter(self,arg,value):\n self._params[arg] = value\n return self._params","def _runner(self, param: Dict[str, Any]):\n formatted_param = self.input_param_formatter(param)\n self.logger.info(f\"Launching => {formatted_param}\")\n\n out = self.func(**param)._asdict()\n\n # TODO: Added as a hack to allow output_param_formatter not to crash\n if self._track_duration:\n out[\"run_duration\"] = None\n # output_param_formatter assumes out to be consistent with out_schema\n formatted_output = self.output_param_formatter(out)\n return formatted_param, formatted_output","def apply(self, external_callable, *args, **kwargs):\n self.work_request_queue.put((external_callable, args, kwargs))\n return self.result_queue.get()","def updateBuildParams(self, job, item, params):\n\n # NOTE(jhesketh): The params need to stay in a key=value data pair\n # as workers cannot necessarily handle lists.\n\n if callable(job.parameter_function):\n pargs = inspect.getargspec(job.parameter_function)\n if len(pargs.args) == 2:\n job.parameter_function(item, params)\n else:\n job.parameter_function(item, job, params)\n self.log.debug(\"Custom parameter function used for job %s, \"\n \"change: %s, params: %s\" % (job, item.change,\n params))\n\n # NOTE(mmedvede): Swift parameter creation should remain after the call\n # to job.parameter_function to make it possible to update LOG_PATH for\n # swift upload url using parameter_function mechanism.\n if job.swift and self.swift.connection:\n\n for name, s in job.swift.items():\n swift_instructions = {}\n s_config = {}\n s_config.update((k, v.format(item=item, job=job,\n change=item.change))\n if isinstance(v, six.string_types)\n else (k, v)\n for k, v in s.items())\n\n (swift_instructions['URL'],\n swift_instructions['HMAC_BODY'],\n swift_instructions['SIGNATURE']) = \\\n self.swift.generate_form_post_middleware_params(\n params['LOG_PATH'], **s_config)\n\n if 'logserver_prefix' in s_config:\n swift_instructions['LOGSERVER_PREFIX'] = \\\n s_config['logserver_prefix']\n elif self.config.has_option('swift',\n 'default_logserver_prefix'):\n swift_instructions['LOGSERVER_PREFIX'] = \\\n self.config.get('swift', 'default_logserver_prefix')\n\n # Create a set of zuul instructions for each instruction-set\n # given in the form of NAME_PARAMETER=VALUE\n for key, value in swift_instructions.items():\n params['_'.join(['SWIFT', name, key])] = value","def __init__(self, pool, params = None):\n\n # initialize thread\n Thread.__init__(self)\n\n # store link to threads pool\n self.pool = pool\n\n # set control parameteres\n self.threadsWorking = 0\n try:\n self.delay = params['delay']\n except KeyError:\n self.delay = 30\n try:\n self.maxJobs = params['jobsToPoll']\n except KeyError:\n self.maxJobs = 100\n\n self.sessionPool = params['sessionPool']\n self.groupsUnderProcessing = Set([])\n self.jobPerTask = None\n\n # start scheduler thread\n self.setDaemon(1)\n self.start()","def _update_params(self):\n pass","def __call__(self, args):","def _handleInput(self, paramInput):\n super()._handleInput(paramInput)\n settings, notFound = paramInput.findNodesAndExtractValues(['n_jobs'])\n # notFound must be empty\n assert(not notFound)\n self.settings = settings","def __init__(self, params):\r\n self.Params = params","def __init__(self, params):\r\n self.Params = params","def __init__(self, params):\r\n self.Params = params","def __init__(self, params):\r\n self.Params = params","def __init__(self, params):\r\n self.Params = params","def __init__(self, params):\r\n self.Params = params","def set_params(self, **kwargs) -> NoReturn:\n pass","def func_star(a_b_c):\n return worker(*a_b_c)"],"string":"[\n \"def _worker(self, args):\\n pass\",\n \"def init_worker(*shared_args_list):\\n global SHARED_ARGS\\n SHARED_ARGS = shared_args_list\",\n \"def job_as_parameter(f):\\n f.job_as_parameter = True\\n return f\",\n \"def process_task(params):\\n params['task'](params)\",\n \"def set_params(self, params):\",\n \"def wrapper(*args):\",\n \"def _submit_unpack_kwargs(self, params):\\n return self._submit(**params)\",\n \"def __init__(**params):\",\n \"def _get_executor_init(self, workers):\\n raise NotImplementedError\",\n \"def __init__(self, worker_id=0, base_port=5005):\",\n \"def _shared_params(self):\\n params = {}\\n if _NUM_BATCHES.value is not None:\\n params['num_batches'] = _NUM_BATCHES.value\\n if self.output_dir is not None:\\n params['benchmark_log_dir'] = self.output_dir\\n return benchmark_cnn.make_params(**params)\",\n \"def exec_worker(self, endpoint, args, request):\\n raise NotImplementedError\",\n \"def params(self):\\n pass\",\n \"def _run_parallel(parameters):\\n\\n # make parallel context global\\n global pc\\n\\n print parameters\\n # create parallel context instance\\n pc = h.ParallelContext()\\n\\n print 'i am', pc.id(), 'of', pc.nhost()\\n # start workers, begins an infinitely loop where master workers posts jobs and workers pull jobs until all jobs are finished\\n pc.runworker()\\n \\n # print len(parameters)\\n # # # distribute experiment and parameters to workers\\n for param in parameters:\\n # print len(parameters)\\n # print param\\n pc.submit(_f_parallel, param)\\n # print param\\n\\n # # continue runnning until all workers are finished\\n while pc.working():\\n print pc.id(), 'is working'\\n\\n # # close parallel context \\n pc.done()\",\n \"def main(self, params):\\n pass\",\n \"def executor(self):\",\n \"def get_params(self):\",\n \"def params():\\n raise NotImplementedError\",\n \"def worker(self, **options):\\n pass\",\n \"def set_params(self, **kwargs):\\n ...\",\n \"def __init__(self, *args, wick_parallel=0, **kwargs):\\n super().__init__(*args, **kwargs)\\n self._wick_parallel = wick_parallel\",\n \"def postprocess_hyperparams(args, config):\\n pass\",\n \"def do_work(self):\",\n \"def docker_worker():\",\n \"def run(self, worker, evaluator=None):\\n pass\",\n \"def worker(self, arg):\\n # https://stackoverflow.com/questions/16878315/what-is-the-right-way-to-treat-python-argparse-namespace-as-a-dictionary\\n # Extract the dictionary __dict__ from the argparse args namespace\\n d = vars(self.args)\\n # Insert the multiprocess-supplied arg into that __dict__\\n d[self.iterable] = arg\\n # Call the function, which expects an argparse namespace with\\n # the amended __dict__\\n self.function(self.args)\",\n \"def set_params(self):\\r\\n pass\",\n \"def __setattr__(self, name, value):\\n if hasattr(self, name):\\n super(JobSubmission, self).__setattr__(name, value)\\n\\n else:\\n self.params[str(name)] = str(value) #TODO: resolve parameter cases\",\n \"def __init__(self, worker_device):\\n self._worker_device = worker_device\\n self._local_map = {}\\n self._global_map = {}\",\n \"def _get_worker_args(worker_id, working_dir, **kwargs):\\n args = dict()\\n args['worker_id'] = worker_id\\n args['working_dir'] = _make_internal_url(working_dir)\\n\\n accepted_args = ['check_hdfs', 'startup_timeout', 'consensus_address'] + list(args.keys())\\n for key in accepted_args:\\n if key in kwargs:\\n args[key] = kwargs[key]\\n return ['--%s=%s' % (k, v) for k, v in args.items()]\",\n \"def Params(cls):\\n p = super().Params()\\n p.Define('train_task', None, 'Underlying task')\\n p.Define('decode_task', None, 'Underlying task')\\n p.Define('train_dataset_name', None, '')\\n p.Define('decode_dataset_name', None, '')\\n p.Define('train_steps_per_loop', 0, '')\\n p.Define('decode_steps_per_loop', 0, '')\\n return p\",\n \"def set_hyperparams(self, params):\",\n \"def execute_wrapper(self, pool_id, queue, subtasktuples, counter):\\n self._saver.set_mode('dict')\\n if self._storegate.backend == 'hybrid':\\n self._storegate.set_mode('numpy')\\n\\n for subtasktuple in subtasktuples:\\n subtasktuple.env.pool_id = pool_id\\n\\n result = self.execute_pipeline(subtasktuples, counter)\\n queue.put(result)\",\n \"def set_params(self, *argv, **kwargs):\\n pass\",\n \"def set_params(self, *argv, **kwargs):\\n pass\",\n \"def set_params(self, *argv, **kwargs):\\n pass\",\n \"def set_params(self, *argv, **kwargs):\\n pass\",\n \"def set_params(self, *argv, **kwargs):\\n pass\",\n \"def Params(cls):\\n p = hyperparams.InstantiableParams(cls)\\n p.Define('task_dict', None, 'dataset_name -> task params')\\n p.Define('task_name', None, 'High level task name')\\n p.Define('logdir', None, 'Log directory')\\n p.Define('train_program', None, 'Train program params')\\n p.Define('train_executions_per_eval', 1, '')\\n p.Define('eval_programs', [], 'List of eval program params.')\\n p.Define('num_splits_per_client', None, '')\\n p.Define('dataset_names', [], 'List of all dataset names.')\\n p.Define('emails', [], 'List of emails to send metrics.')\\n p.Define('summary_exporter', None, 'The summary exporter Params.')\\n p.Define('async_postprocess', True,\\n 'whether to CPU postprocess asynchronously with TPU train')\\n p.Define(\\n 'checkpoint_to_load', None,\\n 'If set, the program will initially load from this checkpoint, '\\n 'ignoring train_dir. Typically used for oneoff decode.')\\n\\n # TODO(blee): Clean these up.\\n p.Define('ml_perf', hyperparams.Params(), 'MlPerf configuration.')\\n mlp = p.ml_perf\\n mlp.Define('submission_metadata', None,\\n 'A dictionary of static submission metadata')\\n mlp.Define('benchmark_name', None, 'Benchmark name for compliance log.')\\n mlp.Define('steps_per_epoch', None, 'Number of training steps per epoch.')\\n mlp.Define('decoder_metric_name', None,\\n 'Name of the decoder metric to report for compliance log.')\\n mlp.Define('decoder_metric_success_threshold', None,\\n 'Benchmark run must exceed this value to succeed.')\\n mlp.Define('max_steps_to_train', None,\\n 'Maximum number of steps to reach target accuracy')\\n return p\",\n \"def __init__(self, mapper, workers, date, logger):\\n \\n self.mapper = mapper\\n self.workers = workers\\n self.date = date\\n self.log = logger\",\n \"def __call__(self, param, xyz=False):\\n pass\",\n \"def getWorker(self):\\n pass\",\n \"def run(self, **kwargs):\",\n \"def set_params(self, *arg):\\n pass\",\n \"def get_params(self, **params): # pylint: disable=unused-argument\\n res = copy.deepcopy(self.sk_params)\\n res.update({'build_fn': self.build_fn})\\n return res\",\n \"def test_all_params(self):\\n broker = FakeBroker()\\n worker_helper = WorkerHelper(\\\"my_connector\\\", broker)\\n self.assertEqual(worker_helper._connector_name, \\\"my_connector\\\")\\n self.assertEqual(worker_helper.broker, broker)\",\n \"def sync_params(params, src_rank=0, group=dist.group.WORLD, comm=None, use_mpi=False):\\n datas = [p.data for p in params]\\n flatvec = flatten_tensors(datas)\\n if use_mpi:\\n if comm is None:\\n comm = DEFAULT_COMM\\n flatvec = th2np(flatvec)\\n comm.Bcast(flatvec, root=0)\\n flatvec = np2th(flatvec)\\n else:\\n dist_broadcast(flatvec, src=src_rank, group=group)\\n unflatten_to(flatvec, datas)\",\n \"def _passing_args_impl(self, pool_class_factory):\\n DELTA = 12\\n ITERATIONS = 100\\n pool = pool_class_factory()\\n\\n pool.start(CoeffMultiplierWorker, {'coeff': DELTA})\\n for i in range(ITERATIONS):\\n pool.ventilate(message='Vent data {}'.format(i), value=i)\\n\\n all_results = [pool.get_results() for _ in range(ITERATIONS)]\\n self.assertEqual({DELTA}, set(np.diff(sorted(all_results))))\\n\\n pool.stop()\\n pool.join()\",\n \"def work(self, job):\\n pass\",\n \"def _use_existing_params(self):\\n sh = shelve.open(os.path.expanduser('~/.config/scheduler/params'))\\n self.params = sh['params']\\n sh.close()\",\n \"def __init__(self, mk_func, *args,\\n processes = 1,\\n verbose = False,\\n queue = SimpleQueue,\\n pass_pid = False):\\n # Create basic queues:\\n todo, done = SimpleQueue (), SimpleQueue ()\\n \\n pool_size = processes if processes > 0 else max (1, cpu_count () - 1)\\n pool = tuple (Process (target = worker_process,\\n args = (pid, verbose, mk_func, todo, done,) + args,\\n kwargs = dict (pass_pid = pass_pid))\\n for pid in range (pool_size))\\n\\n self.verbose = verbose\\n self.todo, self.done, self.pool = todo, done, pool\",\n \"def _StartWorkerProcess(self, process_name):\",\n \"def progress_wrapper(user_defined_function: Callable, master_workers_queue: multiprocessing.Queue, index: int, chunk_size: int) -> Callable:\\n ...\",\n \"def __prepare_parameter__(self, in_args):\\n if self.__use_remote_sparse_updater__():\\n self.__gradient_machine__.prefetch(in_args)\\n self.__parameter_updater__.getParametersRemote()\",\n \"def test_parameters(self):\\n class Test(pyperry.Base): pass\\n Test.add_processor('read', self.Processor)\\n Test.add_processor('read', self.Processor, { 'foo': 'bar' })\\n Test.add_processor('read', self.Processor, foo='bar')\",\n \"def __make_params(args):\\n data = {}\\n for i in range(len(args)):\\n if i == 0: # saltando a primeira iteracao pra\\n # saltar o parametro que é o nome do arquivo de execução\\n continue\\n if not i % 2 == 0:\\n data[args[i]] = args[i + 1]\\n return data\",\n \"def exec_worker_passthrough(self, endpoint, args, request):\\n method = getattr(requests, request.method.lower())\\n data = request.data if request.data else request.form\\n url = _join(self.url, endpoint)\\n response = method(url, params=request.args, data=data)\\n return Response(\\n response=response.content,\\n status=response.status_code,\\n headers=response.headers.items())\",\n \"def init_params(self):\\n blah\",\n \"def set_params(self):\\n raise NotImplementedError\",\n \"def get_params(self):\\n pass\",\n \"def init_worker(X, X_shape, Y, Y_shape):\\n arr_dict['X'] = X\\n arr_dict['X_shape'] = X_shape\\n arr_dict['Y'] = Y\\n arr_dict['Y_shape'] = Y_shape\",\n \"def __init__(self, num_workers, eval_function, timeout=None, maxtasksperchild=None):\\n self.eval_function = eval_function\\n self.timeout = timeout\\n self.pool = Pool(processes=num_workers, maxtasksperchild=maxtasksperchild)\",\n \"def parameters(self):\",\n \"def initialize_params(self, params):\\n pass\",\n \"def setWorker(self, worker):\\n pass\",\n \"def _set_params(self, estimator_args, scaler_args, execution_args, metric_args=None, dim_reduction_args=None):\\n \\n # Set default values which will be used if execution arguments are not passed\\n \\n # Default parameters:\\n self.model.overwrite = True\\n self.model.debug = False\\n self.model.test_size = 0.33\\n self.model.cv = 0\\n self.model.time_series_split = 0\\n self.model.max_train_size = None\\n self.model.random_state = 42\\n self.model.compress = 3\\n self.model.retain_data = False\\n self.model.scale_hashed = True\\n self.model.scale_vectors = True\\n self.model.scaler = \\\"StandardScaler\\\"\\n self.model.scaler_kwargs = {}\\n self.model.estimator_kwargs = {}\\n self.model.missing = \\\"zeros\\\"\\n self.model.calc_feature_importances = False\\n self.model.importances_n_repeats = 30\\n self.model.lags= None\\n self.model.lag_target = False\\n self.model.scale_target = False\\n self.model.scale_lag_target= True\\n self.model.make_stationary = None\\n self.model.stationarity_lags = [1]\\n self.model.using_keras = False\\n self.model.current_sample_as_input = True\\n self.model.prediction_periods = 1\\n \\n # Default metric parameters:\\n if metric_args is None:\\n self.model.metric_args = {}\\n \\n # Set execution parameters\\n \\n # If the execution key word arguments were included in the request, get the parameters and values\\n if len(execution_args) > 0:\\n \\n # Transform the string of arguments into a dictionary\\n execution_args = utils.get_kwargs(execution_args)\\n \\n # Set the overwite parameter if any existing model with the specified name should be overwritten\\n if 'overwrite' in execution_args:\\n self.model.overwrite = 'true' == execution_args['overwrite'].lower()\\n \\n # Set the test_size parameter that will be used to split the samples into training and testing data sets\\n # Default value is 0.33, i.e. we use 66% of the samples for training and 33% for testing\\n if 'test_size' in execution_args:\\n self.model.test_size = utils.atof(execution_args['test_size'])\\n\\n # Enable K-fold cross validation. For more information see: http://scikit-learn.org/stable/modules/cross_validation.html#multimetric-cross-validation\\n # Default value is 0 in which case a simple holdout strategy based on the test_size parameter is used.\\n # If cv > 0 then the model is validated used K = cv folds and the test_size parameter is ignored.\\n if 'cv' in execution_args:\\n self.model.cv = utils.atoi(execution_args['cv'])\\n \\n # Enable timeseries backtesting using TimeSeriesSplit. https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.TimeSeriesSplit.html\\n # This will select the a validation strategy appropriate for time series and sequential data.\\n # The feature definitions must include an 'identifier' field which can be used to sort the series into the correct order.\\n # The integer supplied in this parameter will split the data into the given number of subsets for training and testing.\\n if 'time_series_split' in execution_args:\\n self.model.time_series_split = utils.atoi(execution_args['time_series_split'])\\n\\n # This parameter can be used together with time_series_split.\\n # It specifies the maximum samples to be used for training in each split, which allows for rolling/ walk forward validation.\\n if 'max_train_size' in execution_args:\\n self.model.max_train_size = utils.atoi(execution_args['max_train_size'])\\n\\n # Add lag observations to the feature matrix. Only applicable for Keras models.\\n # An identifier field must be included in the feature definitions to correctly sort the data for this capability.\\n # For e.g. if lags=2, features from the previous two samples will be concatenated as input features for the current sample.\\n # This is useful for framing timeseries and sequence prediction problems into 3D or 4D data required for deep learning.\\n if 'lags' in execution_args:\\n self.model.lags = utils.atoi(execution_args['lags'])\\n\\n # Include targets in the lag observations\\n # If True an additional feature will be created for each sample using the previous value of y \\n if 'lag_target' in execution_args:\\n self.model.lag_target = 'true' == execution_args['lag_target'].lower()\\n \\n # Scale the target before fitting\\n # The scaling will be inversed before predictions so they are returned in the original scale \\n if 'scale_target' in execution_args:\\n self.model.scale_target = 'true' == execution_args['scale_target'].lower()\\n\\n # Scale lag values of the targets before fitting\\n # Even if scale_target is set to false, the lag values of targets being used as features can be scaled by setting this to true \\n if 'scale_lag_target' in execution_args:\\n self.model.scale_lag_target = 'true' == execution_args['scale_lag_target'].lower()\\n\\n # Make the target series more stationary. This only applies to sequence prediction problems.\\n # Valid values are 'log' in which case we apply a logarithm to the target values,\\n # or 'difference' in which case we transform the targets into variance from the previous value.\\n # The transformation will be reversed before returning predictions.\\n if 'make_stationary' in execution_args:\\n self.model.make_stationary = execution_args['make_stationary'].lower()\\n\\n # Provide lags periods for differencing\\n # By default the difference will be done with lag = 1. Alternate lags can be provided by passing a list of lags as a list.\\n # e.g. 'stationarity_lags=1;12|list|int'\\n if 'stationarity_lags' in execution_args:\\n self.model.stationarity_lags = utils.get_kwargs_by_type({'stationarity_lags': execution_args['stationarity_lags']})['stationarity_lags']\\n\\n # Specify if the current sample should be used as input to the model\\n # This is to allow for models that only use lag observations to make future predictions\\n if 'current_sample_as_input' in execution_args:\\n self.model.current_sample_as_input = 'true' == execution_args['current_sample_as_input'].lower()\\n\\n # Specify the number of predictions expected from the model\\n # This can be used to get a model to predict the next m periods given inputs for the previous n periods.\\n # This is only valid for Keras models which have a final output layer with more than one node\\n if 'prediction_periods' in execution_args:\\n self.model.prediction_periods = utils.atoi(execution_args['prediction_periods'])\\n \\n # Seed used by the random number generator when generating the training testing split\\n if 'random_state' in execution_args:\\n self.model.random_state = utils.atoi(execution_args['random_state'])\\n \\n # Compression level between 1-9 used by joblib when saving the model\\n if 'compress' in execution_args:\\n self.model.compress = utils.atoi(execution_args['compress'])\\n \\n # Flag to determine if the training and test data should be saved in the model\\n if 'retain_data' in execution_args:\\n self.model.retain_data = 'true' == execution_args['retain_data'].lower()\\n\\n # Flag to determine if feature importances should be calculated when the fit method is called\\n if 'calculate_importances' in execution_args:\\n self.model.calc_feature_importances = 'true' == execution_args['calculate_importances'].lower()\\n\\n # Sets the number of times a feature is randomly shuffled during the feature importance calculation\\n if 'importances_n_repeats' in execution_args:\\n self.model.importances_n_repeats = utils.atoi(execution_args['importances_n_repeats'])\\n \\n # Set the debug option for generating execution logs\\n # Valid values are: true, false\\n if 'debug' in execution_args:\\n self.model.debug = 'true' == execution_args['debug'].lower()\\n \\n # Additional information is printed to the terminal and logs if the paramater debug = true\\n if self.model.debug:\\n # Increment log counter for the class. Each instance of the class generates a new log.\\n self.__class__.log_no += 1\\n\\n # Create a log file for the instance\\n # Logs will be stored in ..\\\\logs\\\\SKLearn Log <n>.txt\\n self.logfile = os.path.join(os.getcwd(), 'logs', 'SKLearn Log {}.txt'.format(self.log_no))\\n \\n # Create dictionary of parameters to display for debug\\n self.exec_params = {\\\"overwrite\\\":self.model.overwrite, \\\"test_size\\\":self.model.test_size, \\\"cv\\\":self.model.cv,\\\\\\n \\\"time_series_split\\\": self.model.time_series_split, \\\"max_train_size\\\":self.model.max_train_size, \\\"lags\\\":self.model.lags,\\\\\\n \\\"lag_target\\\":self.model.lag_target, \\\"scale_target\\\":self.model.scale_target, \\\"make_stationary\\\":self.model.make_stationary,\\\\\\n \\\"random_state\\\":self.model.random_state, \\\"compress\\\":self.model.compress, \\\"retain_data\\\":self.model.retain_data,\\\\\\n \\\"calculate_importances\\\": self.model.calc_feature_importances, \\\"importances_n_repeats\\\": self.model.importances_n_repeats,\\\\\\n \\\"debug\\\":self.model.debug}\\n\\n self._print_log(1)\\n \\n # If the scaler key word arguments were included in the request, get the parameters and values\\n if len(scaler_args) > 0:\\n \\n # Transform the string of arguments into a dictionary\\n scaler_args = utils.get_kwargs(scaler_args)\\n \\n # Set scaler arguments that will be used when preprocessing the data\\n # Valid values are: StandardScaler, MinMaxScaler, MaxAbsScaler, RobustScaler and QuantileTransformer\\n # More information here: http://scikit-learn.org/stable/modules/preprocessing.html\\n if 'scaler' in scaler_args:\\n self.model.scaler = scaler_args.pop('scaler')\\n \\n if 'missing' in scaler_args:\\n self.model.missing = scaler_args.pop('missing').lower()\\n \\n if 'scale_hashed' in scaler_args:\\n self.model.scale_hashed = 'true' == scaler_args.pop('scale_hashed').lower()\\n \\n if 'scale_vectors' in scaler_args:\\n self.model.scale_vectors = 'true' == scaler_args.pop('scale_vectors').lower()\\n \\n # Get the rest of the scaler parameters, converting values to the correct data type\\n self.model.scaler_kwargs = utils.get_kwargs_by_type(scaler_args) \\n else:\\n err = \\\"Arguments for scaling did not include the scaler name e.g StandardScaler\\\"\\n raise Exception(err)\\n \\n # If the estimator key word arguments were included in the request, get the parameters and values\\n if len(estimator_args) > 0:\\n \\n # Transform the string of arguments into a dictionary\\n estimator_args = utils.get_kwargs(estimator_args)\\n \\n # Set estimator arguments that will be used when preprocessing the data\\n # The parameters available will depend on the selected estimator\\n # More information here: http://scikit-learn.org/stable/modules/classes.html#api-reference\\n if 'estimator' in estimator_args:\\n self.model.estimator = estimator_args.pop('estimator')\\n \\n # Set the estimator type for the model\\n if self.model.estimator in self.classifiers:\\n self.model.estimator_type = \\\"classifier\\\"\\n elif self.model.estimator in self.regressors:\\n self.model.estimator_type = \\\"regressor\\\"\\n elif self.model.estimator in self.decomposers:\\n self.model.estimator_type = \\\"decomposer\\\"\\n elif self.model.estimator in self.clusterers:\\n self.model.estimator_type = \\\"clusterer\\\"\\n else:\\n err = \\\"Unknown estimator class: {0}\\\".format(self.model.estimator)\\n raise Exception(err)\\n\\n # Get the rest of the estimator parameters, converting values to the correct data type\\n self.model.estimator_kwargs = utils.get_kwargs_by_type(estimator_args) \\n else:\\n err = \\\"Arguments for estimator did not include the estimator class e.g. RandomForestClassifier\\\"\\n raise Exception(err)\\n \\n # If key word arguments for model evaluation metrics are included in the request, get the parameters and values\\n if metric_args is not None and len(metric_args) > 0:\\n # Transform the string of arguments into a dictionary\\n metric_args = utils.get_kwargs(metric_args)\\n \\n # Get the metric parameters, converting values to the correct data type\\n self.model.metric_args = utils.get_kwargs_by_type(metric_args) \\n \\n # If key word arguments for dimensionality reduction are included in the request, get the parameters and values\\n if dim_reduction_args is not None and len(dim_reduction_args) > 0:\\n # Transform the string of arguments into a dictionary\\n dim_reduction_args = utils.get_kwargs(dim_reduction_args)\\n \\n # Set dim_reduction arguments that will be used after preprocessing the data\\n # The parameters available will depend on the selected dimensionality reduction method\\n # Acceptable classes are PCA, KernelPCA, IncrementalPCA, TruncatedSVD\\n # More information here: http://scikit-learn.org/stable/modules/classes.html#api-reference\\n if 'reduction' in dim_reduction_args:\\n self.model.reduction = dim_reduction_args.pop('reduction')\\n \\n # Get the rest of the dim_reduction parameters, converting values to the correct data type\\n self.model.dim_reduction_args = utils.get_kwargs_by_type(dim_reduction_args) \\n else:\\n err = \\\"Arguments for dimensionality reduction did not include the class e.g. PCA\\\"\\n raise Exception(err)\\n \\n # Debug information is printed to the terminal and logs if the paramater debug = true\\n if self.model.debug:\\n self._print_log(2)\",\n \"def call(self, *args, **kwargs):\",\n \"def test_task_params(self, task_mock):\\n from sosbeacon.event.message import get_group_broadcast_task\\n\\n group_key = Mock()\\n group_key.urlsafe.return_value = \\\"AGROUPKEY\\\"\\n\\n event_key = Mock()\\n event_key.urlsafe.return_value = \\\"SOMEEVENTKEY\\\"\\n\\n message_key = Mock()\\n message_key.urlsafe.return_value = \\\"SOMEMESSAGEKEY\\\"\\n\\n batch_id = \\\"THEBATCHID\\\"\\n iteration = 19\\n\\n get_group_broadcast_task(\\n group_key, event_key, message_key, batch_id, iteration)\\n\\n check_params = {\\n 'group': 'AGROUPKEY',\\n 'event': 'SOMEEVENTKEY',\\n 'message': 'SOMEMESSAGEKEY',\\n 'batch': 'THEBATCHID',\\n 'cursor': '',\\n 'iter': 19\\n }\\n self.assertEqual(check_params, task_mock.call_args[1]['params'])\",\n \"def pull_server_parameters(self, executor: Executor) -> None:\\n request = Weights.Request()\\n request.id = self._worker_id\\n self._future_weights = self._cli['weights'].call_async(request)\\n rclpy.spin_until_future_complete(self, self._future_weights, executor)\",\n \"def Params(cls):\\n p = hyperparams.InstantiableParams(cls)\\n p.Define('task', None, 'Underlying task')\\n p.Define('logdir', None, 'Log directory')\\n p.Define('num_splits_per_client', None, '')\\n p.Define('steps_per_loop', None, 'Number of steps to run.')\\n p.Define('dataset_name', None,\\n 'Dataset the program is operating on, eg: \\\"Test\\\"')\\n p.Define('name', 'base_program', 'Program name.')\\n p.Define('task_name', None,\\n 'If multi-task, what the high-level task name is')\\n p.Define('num_threads', 1, 'Number of threads in multiprocessing pool.')\\n p.Define('spmd', False, 'Whether program is running under SPMD mode.')\\n p.Define('write_train_input_stats', False,\\n 'Whether to write input data stats during training.')\\n p.Define('max_metrics', 256, 'Overrides TpuEvalMetrics.max_metrics')\\n p.Define('ml_perf', None, 'MLPerf config')\\n return p\",\n \"def update_params(self):\\n pass\",\n \"def execute(self, *args, **kwargs):\",\n \"def execute(self, *args, **kwargs):\",\n \"def update(self, params):\",\n \"def set_params(self, **params):\\n if('threshold' in params.keys()):\\n self.threshold = params['threshold']\\n if('subsample' in params.keys()):\\n self.subsample = params['subsample']\\n if('estimator' in params.keys()):\\n self.estimator = params['estimator']\\n if('n_folds' in params.keys()):\\n self.n_folds = params['n_folds']\\n if('stratify' in params.keys()):\\n self.stratify = params['stratify']\\n if('random_state' in params.keys()):\\n self.random_state = params['random_state']\\n if('n_jobs' in params.keys()):\\n self.n_jobs = params['n_jobs']\",\n \"def set_params(self, params: Dict):\\n\\n if params['training_instances'] is not None:\\n self.training_instances = params['training_instances']\\n if params['n'] is not None:\\n self.n = params['n']\\n if params['lda'] is not None:\\n self.lda = params['lda']\\n if params['verbose'] is not None:\\n self.verbose = params['verbose']\\n\\n self.num_features = self.training_instances[0].get_feature_count()\\n self.w = None\\n self.b = None\",\n \"def Params(cls):\\n p = hyperparams.InstantiableParams(cls)\\n\\n p.Define('task_dict', None, 'dataset_name -> task params')\\n p.Define('task_name', None, 'High level task name')\\n p.Define('logdir', None, 'Log directory')\\n p.Define('train_program', None, 'Train program params')\\n p.Define('train_executions_per_eval', 1, '')\\n p.Define('dataset_names', [], 'List of all dataset names.')\\n p.Define('num_splits_per_client', None, '')\\n\\n p.Define('ml_perf', hyperparams.Params(), 'MlPerf configuration.')\\n\\n mlp = p.ml_perf\\n mlp.Define('benchmark_name', None, 'Benchmark name for compliance log.')\\n mlp.Define('decoder_metric_name', None,\\n 'Name of the decoder metric to report for compliance log.')\\n mlp.Define('decoder_metric_success_threshold', None,\\n 'Benchmark run must exceed this value to succeed.')\\n mlp.Define('max_steps_to_train', None,\\n 'Maximum number of steps to reach target accuracy')\\n mlp.Define('steps_per_epoch', None, 'Number of training steps per epoch.')\\n mlp.Define('global_batch_size', None, 'Global batch size.')\\n mlp.Define('max_sequence_length', None, 'Maximum sequence length.')\\n mlp.Define('optimizer_name', None, 'Optimizer used.')\\n mlp.Define('base_learning_rate', None, 'Base learning rate.')\\n mlp.Define('warmup_steps', None, 'Number of warm-up steps.')\\n\\n return p\",\n \"def __init__(self, worker_id: str,\\n config: Config) -> None:\\n self.worker_id = worker_id\\n self.config = config\",\n \"def get_params(self, deep=...):\\n ...\",\n \"def evaluate_system__initialize_workers(opts, dictionary, features, labels):\\n global evaluate_system__worker_cache\\n evaluate_system__worker_cache = {\\\"opts\\\": opts, \\\"dictionary\\\": dictionary, \\\"features\\\": features, \\\"labels\\\": labels}\",\n \"def __init__( self, parameters={} ):\\n self.params = {}\",\n \"def __call__(self):\\n if grinder.runNumber == 0: self.initialSleep()\\n (param1, param2) = self.getParam()\\n self.request1(param1, param2)\",\n \"def task():\",\n \"def params(cls):\\n def method_decorator(method):\\n @wraps(method)\\n def wrapper(self, *args):\\n return method(self, *map(cls, args))\\n return wrapper\\n return method_decorator\",\n \"def define_parameters(self):\",\n \"def setParameter(self,arg,value):\\n self._params[arg] = value\\n return self._params\",\n \"def _runner(self, param: Dict[str, Any]):\\n formatted_param = self.input_param_formatter(param)\\n self.logger.info(f\\\"Launching => {formatted_param}\\\")\\n\\n out = self.func(**param)._asdict()\\n\\n # TODO: Added as a hack to allow output_param_formatter not to crash\\n if self._track_duration:\\n out[\\\"run_duration\\\"] = None\\n # output_param_formatter assumes out to be consistent with out_schema\\n formatted_output = self.output_param_formatter(out)\\n return formatted_param, formatted_output\",\n \"def apply(self, external_callable, *args, **kwargs):\\n self.work_request_queue.put((external_callable, args, kwargs))\\n return self.result_queue.get()\",\n \"def updateBuildParams(self, job, item, params):\\n\\n # NOTE(jhesketh): The params need to stay in a key=value data pair\\n # as workers cannot necessarily handle lists.\\n\\n if callable(job.parameter_function):\\n pargs = inspect.getargspec(job.parameter_function)\\n if len(pargs.args) == 2:\\n job.parameter_function(item, params)\\n else:\\n job.parameter_function(item, job, params)\\n self.log.debug(\\\"Custom parameter function used for job %s, \\\"\\n \\\"change: %s, params: %s\\\" % (job, item.change,\\n params))\\n\\n # NOTE(mmedvede): Swift parameter creation should remain after the call\\n # to job.parameter_function to make it possible to update LOG_PATH for\\n # swift upload url using parameter_function mechanism.\\n if job.swift and self.swift.connection:\\n\\n for name, s in job.swift.items():\\n swift_instructions = {}\\n s_config = {}\\n s_config.update((k, v.format(item=item, job=job,\\n change=item.change))\\n if isinstance(v, six.string_types)\\n else (k, v)\\n for k, v in s.items())\\n\\n (swift_instructions['URL'],\\n swift_instructions['HMAC_BODY'],\\n swift_instructions['SIGNATURE']) = \\\\\\n self.swift.generate_form_post_middleware_params(\\n params['LOG_PATH'], **s_config)\\n\\n if 'logserver_prefix' in s_config:\\n swift_instructions['LOGSERVER_PREFIX'] = \\\\\\n s_config['logserver_prefix']\\n elif self.config.has_option('swift',\\n 'default_logserver_prefix'):\\n swift_instructions['LOGSERVER_PREFIX'] = \\\\\\n self.config.get('swift', 'default_logserver_prefix')\\n\\n # Create a set of zuul instructions for each instruction-set\\n # given in the form of NAME_PARAMETER=VALUE\\n for key, value in swift_instructions.items():\\n params['_'.join(['SWIFT', name, key])] = value\",\n \"def __init__(self, pool, params = None):\\n\\n # initialize thread\\n Thread.__init__(self)\\n\\n # store link to threads pool\\n self.pool = pool\\n\\n # set control parameteres\\n self.threadsWorking = 0\\n try:\\n self.delay = params['delay']\\n except KeyError:\\n self.delay = 30\\n try:\\n self.maxJobs = params['jobsToPoll']\\n except KeyError:\\n self.maxJobs = 100\\n\\n self.sessionPool = params['sessionPool']\\n self.groupsUnderProcessing = Set([])\\n self.jobPerTask = None\\n\\n # start scheduler thread\\n self.setDaemon(1)\\n self.start()\",\n \"def _update_params(self):\\n pass\",\n \"def __call__(self, args):\",\n \"def _handleInput(self, paramInput):\\n super()._handleInput(paramInput)\\n settings, notFound = paramInput.findNodesAndExtractValues(['n_jobs'])\\n # notFound must be empty\\n assert(not notFound)\\n self.settings = settings\",\n \"def __init__(self, params):\\r\\n self.Params = params\",\n \"def __init__(self, params):\\r\\n self.Params = params\",\n \"def __init__(self, params):\\r\\n self.Params = params\",\n \"def __init__(self, params):\\r\\n self.Params = params\",\n \"def __init__(self, params):\\r\\n self.Params = params\",\n \"def __init__(self, params):\\r\\n self.Params = params\",\n \"def set_params(self, **kwargs) -> NoReturn:\\n pass\",\n \"def func_star(a_b_c):\\n return worker(*a_b_c)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62962055","0.6150441","0.60870606","0.6063529","0.58948","0.5737697","0.57151204","0.5712164","0.56826967","0.56751645","0.5674729","0.5674717","0.5666531","0.5652284","0.56272703","0.56192535","0.5603987","0.559731","0.5591001","0.5564014","0.5558032","0.555758","0.55457395","0.5544851","0.5536626","0.5534182","0.5511632","0.5465722","0.5439092","0.54313743","0.5421675","0.54214245","0.54097235","0.5402301","0.5402301","0.5402301","0.5402301","0.5402301","0.5391432","0.5389867","0.53868055","0.53749174","0.53729314","0.5364865","0.5349833","0.5333762","0.53277063","0.53248686","0.5321506","0.53125954","0.5310714","0.5303248","0.53029025","0.52977425","0.5292317","0.5288985","0.5282827","0.52819693","0.52798206","0.524779","0.5239325","0.52383906","0.52256364","0.5218057","0.52092737","0.51838505","0.5175337","0.51723003","0.5171821","0.5164176","0.5158404","0.51496416","0.51496416","0.5138154","0.51368874","0.51354843","0.51338255","0.5125578","0.51229054","0.51216125","0.51215136","0.51196223","0.51161873","0.51143014","0.5110768","0.5106143","0.50970006","0.5096124","0.5087535","0.5080704","0.5078366","0.50777334","0.50739574","0.506893","0.506893","0.506893","0.506893","0.506893","0.506893","0.5064834","0.50628215"],"string":"[\n \"0.62962055\",\n \"0.6150441\",\n \"0.60870606\",\n \"0.6063529\",\n \"0.58948\",\n \"0.5737697\",\n \"0.57151204\",\n \"0.5712164\",\n \"0.56826967\",\n \"0.56751645\",\n \"0.5674729\",\n \"0.5674717\",\n \"0.5666531\",\n \"0.5652284\",\n \"0.56272703\",\n \"0.56192535\",\n \"0.5603987\",\n \"0.559731\",\n \"0.5591001\",\n \"0.5564014\",\n \"0.5558032\",\n \"0.555758\",\n \"0.55457395\",\n \"0.5544851\",\n \"0.5536626\",\n \"0.5534182\",\n \"0.5511632\",\n \"0.5465722\",\n \"0.5439092\",\n \"0.54313743\",\n \"0.5421675\",\n \"0.54214245\",\n \"0.54097235\",\n \"0.5402301\",\n \"0.5402301\",\n \"0.5402301\",\n \"0.5402301\",\n \"0.5402301\",\n \"0.5391432\",\n \"0.5389867\",\n \"0.53868055\",\n \"0.53749174\",\n \"0.53729314\",\n \"0.5364865\",\n \"0.5349833\",\n \"0.5333762\",\n \"0.53277063\",\n \"0.53248686\",\n \"0.5321506\",\n \"0.53125954\",\n \"0.5310714\",\n \"0.5303248\",\n \"0.53029025\",\n \"0.52977425\",\n \"0.5292317\",\n \"0.5288985\",\n \"0.5282827\",\n \"0.52819693\",\n \"0.52798206\",\n \"0.524779\",\n \"0.5239325\",\n \"0.52383906\",\n \"0.52256364\",\n \"0.5218057\",\n \"0.52092737\",\n \"0.51838505\",\n \"0.5175337\",\n \"0.51723003\",\n \"0.5171821\",\n \"0.5164176\",\n \"0.5158404\",\n \"0.51496416\",\n \"0.51496416\",\n \"0.5138154\",\n \"0.51368874\",\n \"0.51354843\",\n \"0.51338255\",\n \"0.5125578\",\n \"0.51229054\",\n \"0.51216125\",\n \"0.51215136\",\n \"0.51196223\",\n \"0.51161873\",\n \"0.51143014\",\n \"0.5110768\",\n \"0.5106143\",\n \"0.50970006\",\n \"0.5096124\",\n \"0.5087535\",\n \"0.5080704\",\n \"0.5078366\",\n \"0.50777334\",\n \"0.50739574\",\n \"0.506893\",\n \"0.506893\",\n \"0.506893\",\n \"0.506893\",\n \"0.506893\",\n \"0.506893\",\n \"0.5064834\",\n \"0.50628215\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83178,"cells":{"query":{"kind":"string","value":"This is the toplevel function for processing data. The function is meant to be passed to the importer (in this case GuiIO). The importer will call this function after it has parsed the raw data."},"document":{"kind":"string","value":"def processing_function(raw):\r\n\r\n # Sort stewarded & unstewarded depts\r\n STEWARDED_DEPTS = set(stewards.keys()) & kt.ALL_DEPTS\r\n UNSTEWARDED_DEPTS = kt.ALL_DEPTS - STEWARDED_DEPTS\r\n\r\n ##############################\r\n # Filter data in all the ways\r\n ##############################\r\n actives = kt.filterdata(raw, kt.selectors.allactives)\r\n nc = kt.filterdata(actives, kt.selectors.northcampus)\r\n\r\n # International Students\r\n itnl = kt.filterdata(actives, kt.selectors.itnl)\r\n permres = kt.filterdata(actives, kt.selectors.permres)\r\n\r\n # Stewarded / Unstewarded\r\n stewarded= kt.filterdata(\r\n actives,\r\n lambda person: kt.selectors.bydept(person,STEWARDED_DEPTS)\r\n )\r\n unstewarded= kt.filterdata(\r\n actives,\r\n lambda person: kt.selectors.bydept(person,UNSTEWARDED_DEPTS)\r\n )\r\n\r\n # Hire Date\r\n newhires = kt.filterdata(\r\n actives, \r\n lambda person: kt.selectors.hiredafter(person,NEW_HIRE_DATE)\r\n )\r\n\r\n oldhires = kt.filterdata(\r\n actives, \r\n lambda person: kt.selectors.hiredbefore(person,NEW_HIRE_DATE)\r\n )\r\n\r\n nohiredate = kt.filterdata(actives, kt.selectors.nohiredate)\r\n\r\n # Degree Program\r\n phd = kt.filterdata(\r\n actives, \r\n lambda person: kt.selectors.bydegree(person,['PhD'])\r\n )\r\n masters = kt.filterdata(\r\n actives, \r\n lambda person: kt.selectors.bydegree(person, kt.MASTERS)\r\n )\r\n\r\n ###############\r\n # Count things\r\n ###############\r\n\r\n # Unit sizes\r\n bargaining_unit_size = len(actives)\r\n overall_members = kt.count_duespayers(actives)\r\n\r\n # Number of actives currently stewarded\r\n total_stewarded = len(stewarded)\r\n total_unstewarded = len(unstewarded)\r\n stewarded_members = kt.count_duespayers(stewarded)\r\n unstewarded_members = kt.count_duespayers(unstewarded)\r\n\r\n # International students\r\n total_intl = len(itnl)\r\n total_permres = len(permres)\r\n intl_members = kt.count_duespayers(itnl)\r\n permres_members = kt.count_duespayers(permres)\r\n\r\n # New Hires\r\n total_newhires = len(newhires)\r\n total_oldhires = len(oldhires)\r\n total_nohiredate= len(nohiredate)\r\n newhire_members = kt.count_duespayers(newhires)\r\n oldhire_members = kt.count_duespayers(oldhires)\r\n\r\n\r\n # Degree Program\r\n total_phd = len(phd)\r\n total_masters = len(masters)\r\n phd_members = kt.count_duespayers(phd)\r\n masters_members = kt.count_duespayers(masters)\r\n \r\n\r\n ######################################\r\n # Derived Results\r\n ######################################\r\n labels = []\r\n results= []\r\n\r\n labels += ['Current Bargaining Unit Size']\r\n results+= [bargaining_unit_size]\r\n\r\n labels += ['Relative Number of GSIs with >1 Steward (%)']\r\n results+= [(100.0*total_stewarded)/bargaining_unit_size]\r\n\r\n labels += ['Relative Number of International Students (%)']\r\n results+= [(100.0*total_intl)/bargaining_unit_size]\r\n\r\n # labels += ['Relative Number of NC Permanent Resident Students (%)']\r\n # results+= [(100.0*total_permres)/bargaining_unit_size]\r\n\r\n labels += ['']\r\n results+= ['']\r\n\r\n labels += ['Overall GEO Membership (%)']\r\n results+= [(100.0*overall_members)/bargaining_unit_size]\r\n\r\n labels += ['Membership Among Stewarded Depts (%)']\r\n results+= [(100.0*stewarded_members)/total_stewarded]\r\n\r\n labels += ['Membership Among Unstewarded Depts (%)']\r\n results+= [(100.0*unstewarded_members)/total_unstewarded]\r\n\r\n labels += ['']\r\n results+= ['']\r\n\r\n labels += ['Relative # of International Students (%)']\r\n results+= [(100.0*total_intl)/bargaining_unit_size]\r\n\r\n labels += ['Membership Among International Students (%)']\r\n results+= [(100.0*intl_members)/total_intl]\r\n\r\n # labels += ['Membership Among Permanent Residents (%)']\r\n # results+= [(100.0*permres_members)/total_permres]\r\n\r\n labels += ['']\r\n results+= ['']\r\n\r\n labels += ['Relative # of New Hires (%)']\r\n results+= [(100.0*total_newhires)/bargaining_unit_size]\r\n\r\n labels += ['Membership Among New Hires (%)']\r\n results+= [(100.0*newhire_members)/total_newhires]\r\n\r\n labels += ['Membership Among Old Hires (%)']\r\n results+= [(100.0*oldhire_members)/total_oldhires]\r\n\r\n labels += ['Number of People w/o Known Hire Dates']\r\n results+= [total_nohiredate]\r\n\r\n labels += ['']\r\n results+= ['']\r\n\r\n labels += ['Relative # of Masters Students (%)']\r\n results+= [(100.0*total_masters)/bargaining_unit_size]\r\n\r\n labels += ['Membership Among Masters Students (%)']\r\n results+= [(100.0*masters_members)/total_masters]\r\n\r\n labels += ['Membership Among PhD Students (%)']\r\n results+= [(100.0*phd_members)/total_phd]\r\n\r\n labels += ['']\r\n results+= ['']\r\n\r\n\r\n\r\n # Display summary results\r\n print('\\n')\r\n display_results(labels,results)\r\n\r\n print('Unstewarded Departments:')\r\n for d in UNSTEWARDED_DEPTS: print(d)\r\n\r\n print('\\n')\r\n\r\n\r\n\r\n # Print summary results to csv\r\n kt.writecsv_summary(zip(labels,results), OUT_FILE)\r\n\r\n\r\n\r\n # dump all local variables to file\r\n # v = locals()\r\n\r\n\r\n\r\n return None"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def handle_data(self, data):\n if verbose(): print(\"TIParser.handle_data(self, '%s')\" % (data))\n pass","def processInputs(self):","def run(self, data):\n\t\t# no processing here\n\t\treturn data","def parse_data(self):\n\t\traise NotImplementedError('%s: No parse function implemented!' % self.name)","def processIncoming(self):\n try:\n msg = self.guiqueue.get(False)\n (PK, XERRO, tt) = getDataFromString(msg)\n self.PK0.append(PK[0])\n self.PK1.append(PK[1])\n self.PK2.append(PK[2])\n self.PK3.append(PK[3])\n self.PK4.append(PK[4])\n self.PK5.append(PK[5])\n self.PK6.append(PK[6])\n self.PK7.append(PK[7])\n self.XERRO0.append(XERRO[0])\n self.XERRO1.append(XERRO[1])\n self.XERRO2.append(XERRO[2])\n self.XERRO3.append(XERRO[3])\n self.XERRO4.append(XERRO[4])\n self.XERRO5.append(XERRO[5])\n self.XERRO6.append(XERRO[6])\n self.XERRO7.append(XERRO[7])\n self.t.append(tt)\n \n \n #replota a cada dado novo\n self.updatePlot()\n \n except queue.Empty:\n #print(\"Fila Vazia\")\n pass\n\n self.root.after(25, self.processIncoming)","def handle(self, data):\n pass","def data_processing_interface(root):\n try:\n root.withdraw()\n top = ThemedTk(theme=\"aqua\")\n top.title(\"Data Processing\")\n top.geometry(\"500x300\")\n\n # label at the top of person database name\n my_label = Label(top, text=\"Data Processing\", font=(\"Times New Roman\", 18, \"bold\"))\n my_label.grid(row=0, column=1, padx=(50, 50), pady=(10, 20))\n\n def path_of_image():\n \"\"\" open file explorer to select directory \"\"\"\n top.folder_name = filedialog.askdirectory(title=\"select directory\",\n initialdir=\"C:/Users/Ayush sagore/JUPITER NOTEBOOK ML/CNN Model/\"\n \"test_dataset/\")\n path_name.insert(0, top.folder_name)\n\n # label and input field for path and button right to input field for browsing to data source folder\n path_name_label = Label(top, text=\"Source Path :\", font=(\"Times New Roman\", 12, \"bold\"))\n path_name_label.grid(row=1, column=0, padx=(0, 10), pady=(20, 10))\n\n path_name = Entry(top, width=25, font=(\"Times New Roman\", 12, \"bold\"))\n path_name.grid(row=1, column=1, padx=(13, 10), pady=(20, 10))\n\n path_btn = Button(top, text=\"->\", command=path_of_image)\n path_btn.grid(row=1, column=2, columnspan=2, pady=(15, 0), padx=(0, 0), ipady=1, ipadx=6)\n\n # label and input field for folder name\n folder_name_label = Label(top, text=\"Folder Name :\", font=(\"Times New Roman\", 12, \"bold\"))\n folder_name_label.grid(row=2, column=0, padx=(10, 10), pady=(20, 10))\n\n folder_name = Entry(top, width=25, font=(\"Times New Roman\", 12, \"bold\"))\n folder_name.grid(row=2, column=1, padx=20, pady=(20, 10))\n\n def hide_open2():\n root.deiconify()\n top.destroy()\n\n exit2_btn = Button(top, text=\"EXIT\", font=(\"Times New Roman\", 12, \"bold\"), bg=\"gray\", command=hide_open2)\n exit2_btn.grid(row=20, column=1, columnspan=2, pady=25, padx=(100, 0), ipadx=50)\n\n def check_given_data():\n \"\"\" This function check whether data given by user valid or not. \"\"\"\n if os.path.exists(path_name.get()) and folder_name.get() != \"\":\n # if True:\n progress = ThemedTk(theme=\"aqua\")\n progress.title(\"Progress\")\n\n top.withdraw()\n\n info_label = Label(progress, text=\"Attentive set filtering is on progress\", font=(\"Times New Roman\", 12, \"bold\"))\n info_label.pack(pady=10)\n progress_bar = Progressbar(progress, orient=HORIZONTAL, length=220, mode='determinate')\n progress_bar.pack(pady=20)\n filter_dataset(path_name.get(), folder_name.get(), progress_bar, info_label, progress, root)\n\n else:\n messagebox.showerror(\"Message\", \"Please enter valid directory path\\n \\\n and folder name\")\n\n # show and exit button\n next_page_btn = Button(top, text=\"Next Page\", font=(\"Times New Roman\", 12, \"bold\"), bg=\"gray\",\n command=check_given_data) # next_page_interface(top, root)\n next_page_btn.grid(row=20, column=0, columnspan=2, pady=25, padx=(0, 200), ipadx=22)\n\n except Exception as e:\n messagebox.showerror(\"Message\", \"Error in the data processing interface\")","def _process(self, data: np.ndarray) -> np.ndarray:","def _process(self, data: np.ndarray) -> np.ndarray:","def _data_process(self, v):\n pass","def process_data(self, data):\n return data","def processInputData(self, unformattedData):\n tempList = unformattedData.split('\\n')\n rawNodes = copy.copy(list(self.filterRawNodes(tempList)))\n self.vertices = self.createVertices(rawNodes)\n self.edges = self.createEdges(rawNodes, self.vertices)\n self.createEdgesList(rawNodes, self.vertices)","def recive_data(self, data_waveformreceived):\r\n self.adcollector.save_as_binary(self.savedirectory)\r\n self.channel_number = len(data_waveformreceived)\r\n if self.channel_number == 1: \r\n if 'Vp' in self.readinchan:\r\n self.data_collected_0 = data_waveformreceived[0]\r\n \r\n self.PlotDataItem_patch_voltage = PlotDataItem(self.xlabelhere_all, self.data_collected_0)\r\n #use the same color as before, taking advantages of employing same keys in dictionary\r\n self.PlotDataItem_patch_voltage.setPen('w')\r\n self.pw_data.addItem(self.PlotDataItem_patch_voltage)\r\n \r\n self.textitem_patch_voltage = pg.TextItem(('Vp'), color=('w'), anchor=(1, 1))\r\n self.textitem_patch_voltage.setPos(0, 1)\r\n self.pw_data.addItem(self.textitem_patch_voltage)\r\n elif 'Ip' in self.readinchan:\r\n self.data_collected_0 = data_waveformreceived[0]\r\n \r\n self.PlotDataItem_patch_current = PlotDataItem(self.xlabelhere_all, self.data_collected_0)\r\n #use the same color as before, taking advantages of employing same keys in dictionary\r\n self.PlotDataItem_patch_current.setPen('c')\r\n self.pw_data.addItem(self.PlotDataItem_patch_current)\r\n \r\n self.textitem_patch_current = pg.TextItem(('Ip'), color=('w'), anchor=(1, 1))\r\n self.textitem_patch_current.setPos(0, 1)\r\n self.pw_data.addItem(self.textitem_patch_current) \r\n elif 'PMT' in self.readinchan: # repeatnum, PMT_data_index_array, averagenum, ScanArrayXnum\r\n self.data_collected_0 = data_waveformreceived[0]*-1\r\n self.data_collected_0 = self.data_collected_0[0:len(self.data_collected_0)-1]\r\n \r\n # pmt data could come from raster scanning mode or from contour scanning mode.\r\n try:\r\n for i in range(self.repeatnum):\r\n self.PMT_image_reconstructed_array = self.data_collected_0[np.where(self.PMT_data_index_array_repeated == i+1)]\r\n Dataholder_average = np.mean(self.PMT_image_reconstructed_array.reshape(self.averagenum, -1), axis=0)\r\n Value_yPixels = int(len(self.samples_1)/self.ScanArrayXnum)\r\n self.PMT_image_reconstructed = np.reshape(Dataholder_average, (Value_yPixels, self.ScanArrayXnum))\r\n \r\n # Stack the arrays into a 3d array\r\n if i == 0:\r\n self.PMT_image_reconstructed_stack = self.PMT_image_reconstructed\r\n else:\r\n self.PMT_image_reconstructed_stack = np.concatenate((self.PMT_image_reconstructed_stack, self.PMT_image_reconstructed), axis=0)\r\n \r\n Localimg = Image.fromarray(self.PMT_image_reconstructed) #generate an image object\r\n Localimg.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+str(i)+'.tif')) #save as tif\r\n \r\n plt.figure()\r\n plt.imshow(self.PMT_image_reconstructed, cmap = plt.cm.gray)\r\n plt.show()\r\n except:\r\n np.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+'flatten'), self.data_collected_0)\r\n \r\n elif self.channel_number == 2: \r\n if 'PMT' not in self.readinchan:\r\n self.data_collected_0 = data_waveformreceived[0]\r\n \r\n self.PlotDataItem_patch_voltage = PlotDataItem(self.xlabelhere_all, self.data_collected_0)\r\n #use the same color as before, taking advantages of employing same keys in dictionary\r\n self.PlotDataItem_patch_voltage.setPen('w')\r\n self.pw_data.addItem(self.PlotDataItem_patch_voltage)\r\n \r\n self.textitem_patch_voltage = pg.TextItem(('Vp'), color=('w'), anchor=(1, 1))\r\n self.textitem_patch_voltage.setPos(0, 1)\r\n self.pw_data.addItem(self.textitem_patch_voltage) \r\n \r\n self.data_collected_1 = data_waveformreceived[1]\r\n \r\n self.PlotDataItem_patch_current = PlotDataItem(self.xlabelhere_all, self.data_collected_1)\r\n #use the same color as before, taking advantages of employing same keys in dictionary\r\n self.PlotDataItem_patch_current.setPen('c')\r\n self.pw_data.addItem(self.PlotDataItem_patch_current)\r\n \r\n self.textitem_patch_current = pg.TextItem(('Ip'), color=('w'), anchor=(1, 1))\r\n self.textitem_patch_current.setPos(0, 1)\r\n self.pw_data.addItem(self.textitem_patch_current) \r\n elif 'PMT' in self.readinchan:\r\n self.data_collected_0 = data_waveformreceived[0]*-1\r\n self.data_collected_0 = self.data_collected_0[0:len(self.data_collected_0)-1]\r\n \r\n try:\r\n for i in range(self.repeatnum):\r\n self.PMT_image_reconstructed_array = self.data_collected_0[np.where(self.PMT_data_index_array_repeated == i+1)]\r\n Dataholder_average = np.mean(self.PMT_image_reconstructed_array.reshape(self.averagenum, -1), axis=0)\r\n Value_yPixels = int(len(self.samples_1)/self.ScanArrayXnum)\r\n self.PMT_image_reconstructed = np.reshape(Dataholder_average, (Value_yPixels, self.ScanArrayXnum))\r\n \r\n # Stack the arrays into a 3d array\r\n if i == 0:\r\n self.PMT_image_reconstructed_stack = self.PMT_image_reconstructed\r\n else:\r\n self.PMT_image_reconstructed_stack = np.concatenate((self.PMT_image_reconstructed_stack, self.PMT_image_reconstructed), axis=0)\r\n \r\n Localimg = Image.fromarray(self.PMT_image_reconstructed) #generate an image object\r\n Localimg.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+str(i)+'.tif')) #save as tif\r\n \r\n plt.figure()\r\n plt.imshow(self.PMT_image_reconstructed, cmap = plt.cm.gray)\r\n plt.show()\r\n except:\r\n np.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+'contourscanning'), self.data_collected_0)\r\n \r\n if 'Vp' in self.readinchan:\r\n self.data_collected_1 = data_waveformreceived[1]\r\n \r\n self.PlotDataItem_patch_voltage = PlotDataItem(self.xlabelhere_all, self.data_collected_1)\r\n #use the same color as before, taking advantages of employing same keys in dictionary\r\n self.PlotDataItem_patch_voltage.setPen('w')\r\n self.pw_data.addItem(self.PlotDataItem_patch_voltage)\r\n \r\n self.textitem_patch_voltage = pg.TextItem(('Vp'), color=('w'), anchor=(1, 1))\r\n self.textitem_patch_voltage.setPos(0, 1)\r\n self.pw_data.addItem(self.textitem_patch_voltage)\r\n elif 'Ip' in self.readinchan:\r\n self.data_collected_1 = data_waveformreceived[1]\r\n \r\n self.PlotDataItem_patch_current = PlotDataItem(self.xlabelhere_all, self.data_collected_1)\r\n #use the same color as before, taking advantages of employing same keys in dictionary\r\n self.PlotDataItem_patch_current.setPen('c')\r\n self.pw_data.addItem(self.PlotDataItem_patch_current)\r\n \r\n self.textitem_patch_current = pg.TextItem(('Ip'), color=('w'), anchor=(1, 1))\r\n self.textitem_patch_current.setPos(0, 1)\r\n self.pw_data.addItem(self.textitem_patch_current)","def process_raw_data(data_dir='/home/data/nbc/athena/athena-data/'):\n\n # Calls the process_corpus function, defined below\n # process_corpus reads in the text, performs abbreviation, spelling,\n # translation, and overall text Processing\n # process_corpus outputs the processed text for each file and the stemmed file\n for feature_source in ['abstract', 'full']:\n process_corpus(data_dir, feature_source)\n\n # Calls the label_data function, defined below\n # label_data reads in the metadata csv files, concatenates them, then\n # reads in the processed text files\n # label_data outputs a binary pmid by label metadata matrix\n label_data(data_dir)\n generate_gazetteer(data_dir)","def run(self):\n # FILE INPUT\n if self.text_type == \"file\":\n self.process_files()\n\n # STRING INPUT\n else:\n self.process_strings()\n\n if self.json:\n self.save_json()\n\n if self.errors:\n print(\"\\nThe following file(s) could not be opened:\")\n for error in self.errors:\n print(f\"\\t{error}\")","def process_scene_data(self, scene, data, tmp_dir):\n pass","def processing(self):\n pass","def _read_data(self):","def read_data(self):\n if not self.header['data included']:\n pass\n elif self.header['file type'] in (21, 26):\n self._isotope_data()\n if os.path.exists(self.filename + '_txt'):\n self._isotope_txt_data()\n elif self.header['file type'] == 22:\n # line scan types, no ImageHeader\n warnings.warn('No data read for line scan, fix')\n pass\n elif self.header['file type'] in (31, 35):\n self._beamstability_data()\n else:\n self._image_data()","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def loadData(self, data=None):\n\n super(SimpleControlComponentRig, self).loadData( data )\n\n ctrlSize = data.get('ctrlSize', 1.0)\n ctrlXfo = data.get('ctrlXfo', Xfo())\n\n # ================\n # Resize Controls\n # ================\n self.mainCtrl.setShape('square')\n self.mainCtrl.rotatePoints(90, 0, 0)\n self.mainCtrl.scalePoints(Vec3(ctrlSize, ctrlSize, ctrlSize))\n\n # =======================\n # Set Control Transforms\n # =======================\n self.mainCtrlSpace.xfo = ctrlXfo\n self.mainCtrl.xfo = ctrlXfo\n\n # ============\n # Set IO Xfos\n # ============\n self.mainInputTgt.xfo = ctrlXfo\n self.mainDef.xfo = ctrlXfo\n self.outputTgt.xfo = ctrlXfo\n\n # ====================\n # Evaluate Constraints\n # ====================\n self.mainInputConstraint.evaluate()\n self.mainOutputConstraint.evaluate()\n self.mainDefConstraint.evaluate()\n\n # ====================\n # Evaluate Canvas Ops\n # ====================","def handle_data(self, data):\n \n line_num, offset = self.getpos()\n new_pos = self.new_line_pos[line_num] + offset\n self.data_buffer += self.html_doc[self.current_pos:new_pos]\n\n content = data\n if self.filtering:\n content = self.typogrify._apply_filters(content, self.lasttag)\n self.filtered_data_length = len(content)\n\n self.data_buffer += content\n self.current_pos = new_pos + len(data)","def run(self):\n\n self.load_file()\n self.cat_to_num()\n self.split()","def load_data(self):\n filename = filedialog.askopenfilename(title=\"Select A File\",\n file=((\"csv files\", \"*.csv\"),\n (\"dat files\", \"*.dat\"),\n (\"excel files\", \"*.xlsx\"),\n (\"All Files\", \"*.*\")))\n file_path = filename\n try:\n filename = f\"{file_path}\"\n name = os.path.splitext(os.path.basename(filename))[0]\n if name in ['h2o', 'KED', 'financial']:\n DataLoader.data = load_data(name)\n else:\n DataLoader.data = pd.read_csv(filename)\n except ValueError:\n messagebox.showerror(\"Information\", \"The file you have chosen is invalid.\")\n except FileNotFoundError:\n messagebox.showerror(\"Information\", f\"No such file as {file_path}\")\n self.clear_tree()\n\n self.treeview['columns'] = list(DataLoader.data.columns)\n for i in self.treeview['columns']:\n self.treeview.column(i, anchor=\"w\")\n self.treeview.heading(i, text=i, anchor='w')\n\n for index, row in DataLoader.data.iterrows():\n self.treeview.insert(\"\", 0, text=self.data.shape[0] - 1 - index, values=list(row))\n self.treeview.column('#0', width=100)\n\n self.summary_label = ttk.Label(self, text=f'Data shape: {DataLoader.data.shape}', width=40)\n self.summary_label.grid(row=2, column=0, columnspan=2, sticky=tk.S + tk.N)","def _load_data(self, event):\n if self.parent is not None:\n wx.PostEvent(self.parent, NewLoadDataEvent())","def handle_data(self, text):\n self.pieces.append(text)","def process_data_impl(\n self,\n data_dir: Path,\n output_processed_data_dir: Path,\n ) -> NoReturn:\n pass","def handle_input(data: dict):","def _state_main(self, gui):\n gui.entry.wait_variable(gui.entry_sv)\n\n '''Clean string'''\n files = literal_eval(gui.entry_sv.get())\n\n '''Remove previous images'''\n if hasattr(gui, \"panel\"):\n gui.panel.destroy()\n\n '''Load each image'''\n for file_name in files:\n file_name = file_name.replace(\"{\", \"\").replace(\"}\", \"\")\n # image = tk.PhotoImage(file=file_name)\n if \".CR2\" in file_name:\n '''Rawpy implementation'''\n file_image = rawpy.imread(file_name)\n file_image = file_image.postprocess()\n '''Rawkit implementation'''\n '''file_image = Raw(file_name)\n file_image = np.array(file_image.to_buffer())'''\n '''OpenCV implementation'''\n '''file_image = cv2.imread(file_name)'''\n else:\n file_image = Image.open(file_name)\n '''image = file_image.resize((500, 500), Image.ANTIALIAS)\n image = ImageTk.PhotoImage(image)\n gui.panel = tk.Label(gui.root, image=image)\n gui.panel.image = image\n gui.panel.pack()'''\n # panel.grid(row=2)\n\n image_data = np.array(file_image)\n image_data = cv2.cvtColor(image_data, cv2.COLOR_RGB2GRAY)\n '''print(image_data.shape)\n print(image_data)\n print(len(image_data))\n print(len(image_data[0]))'''\n returned_image = Image.fromarray(image_data)\n '''cv2.imshow(\"Gray\", image_data)\n cv2.waitKey()\n cv2.destroyWindow(\"Gray\")'''\n\n '''enhanced_contrast = ImageEnhance.Contrast(Image.fromarray(file_image))\n enhanced_image = enhanced_contrast.enhance(255)\n enhanced_data = np.array(enhanced_image)\n plot_functions.imshow(enhanced_image)\n plot_functions.show()'''\n\n # color_space = cv2.cvtColor(image_data, cv2.COLOR_RGB2HSV)\n # print(color_space)\n \n '''Create mask for white-ish pixels'''\n '''lower_background = np.array([150, 150, 150])\n upper_background = np.array([255, 255, 255])\n print(image_data)\n white_mask = cv2.inRange(image_data, lower_background, upper_background)\n white_mask = cv2.morphologyEx(white_mask, cv2.MORPH_OPEN, np.ones((3,3),np.uint8))\n white_mask = cv2.morphologyEx(white_mask, cv2.MORPH_DILATE, np.ones((3, 3), np.uint8))\n white_mask = white_mask / 255'''\n\n '''Create mask for black-ish pixels'''\n '''lower_background = np.array([0, 0, 0])\n upper_background = np.array([25, 25, 25])\n black_mask = cv2.inRange(image_data, lower_background, upper_background)\n black_mask = cv2.morphologyEx(black_mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8))\n black_mask = cv2.morphologyEx(black_mask, cv2.MORPH_DILATE, np.ones((3, 3), np.uint8))\n black_mask = black_mask / 255'''\n\n '''Add masks together'''\n '''background_mask = white_mask\n # Ensure no value is above 1\n background_mask = np.clip(background_mask, 0, 1)'''\n \n copied_image_data = np.asarray(returned_image).copy()\n # background_mask = np.logical_not(background_mask)\n '''for row_index, [mask_row, image_row] in enumerate(zip(background_mask, copied_image_data)):\n # place black pixel on corresponding masked pixels\n # copied_image_data[row_index] = np.array([image_row[pixel] * int(mask_row[pixel]) for pixel in range(len(mask_row))])\n # make pixel fully white on corresponding masked pixels\n copied_image_data[row_index] = np.array([np.array([255, 255, 255]) if int(mask_row[pixel]) else image_row[pixel] for pixel in range(len(mask_row))])'''\n\n '''Turn removed pixels red'''\n '''mask_image = Image.fromarray(copied_image_data)\n plot_functions.imshow(mask_image)\n plot_functions.show()'''\n trapezoid_data = copied_image_data.copy()\n\n enhanced_contrast = ImageEnhance.Contrast(Image.fromarray(trapezoid_data))\n enhanced_image = enhanced_contrast.enhance(255)\n trapezoid_data = np.array(enhanced_image)\n\n '''Detect lines'''\n edges = cv2.Canny(trapezoid_data, 75, 150)\n lines = cv2.HoughLinesP(edges, 1, np.pi / 180, 100, maxLineGap=1000)\n # print(lines)\n for line in lines:\n x1, y1, x2, y2 = line[0]\n if y1 == y2:\n cv2.line(copied_image_data, (x1, y1), (x2, y2), (255, 255, 255), 1)\n\n '''Trapezoid attempt'''\n\n # filters image bilaterally and displays it\n bilatImg = cv2.bilateralFilter(trapezoid_data, 5, 175, 175)\n\n # finds edges of bilaterally filtered image and displays it\n edgeImg = cv2.Canny(bilatImg, 75, 200)\n\n # gets contours (outlines) for shapes and sorts from largest area to smallest area\n contours, hierarchy = cv2.findContours(edgeImg, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n contours = sorted(contours, key=cv2.contourArea, reverse=True)\n\n # drawing red contours on the image\n for con in contours:\n cv2.drawContours(trapezoid_data, con, -1, (255, 255, 255), 3)\n\n '''Detect corners'''\n dst = cv2.cornerHarris(edges, 30, 31, 0.001)\n dst = cv2.dilate(dst, None)\n ret, dst = cv2.threshold(dst, 0.01 * dst.max(), 255, 0)\n dst = np.uint8(dst)\n\n # find centroids\n ret, labels, stats, centroids = cv2.connectedComponentsWithStats(dst)\n # define the criteria to stop and refine the corners\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100,\n 0.001)\n corners = cv2.cornerSubPix(edges, np.float32(centroids), (5, 5),\n (-1, -1), criteria)\n\n good_corners = []\n for corner in corners:\n if (corner[1] < 1000) & (corner[1] > 650) & (corner[0] > 250) & (corner[0] < 2250):\n good_corners.append(corner)\n cv2.circle(edges, (corner[0], corner[1]), 10, (255, 255, 255))\n\n print(good_corners)\n if len(good_corners) >= 3:\n corner_combos = itertools.combinations(good_corners, 3)\n elif len(good_corners) > 1:\n corner_combos = itertools.combinations(good_corners, 2)\n\n best_corner_combo = None\n best_coef = np.inf\n for corner_combo in corner_combos:\n regression = LinearRegression().fit(np.array([corner[0] for corner in corner_combo]).reshape(-1, 1),\n np.array([corner[1] for corner in corner_combo]))\n if np.abs(regression.coef_) < best_coef:\n best_coef = np.abs(regression.coef_)\n best_corner_combo = np.array([corner[1] for corner in corner_combo])\n\n y_edge = int(round(np.mean(best_corner_combo)))\n edges = edges[y_edge:3000, 200:2200]\n copied_image_data = copied_image_data[y_edge:2500, 200:2200]\n trapezoid_data = trapezoid_data[y_edge:2500, 200:2200]\n\n # and double-checking the outcome\n cv2.imshow(\"linesEdges\", edges)\n cv2.imshow(\"linesDetected\", copied_image_data)\n cv2.imshow(\"Contours check\", trapezoid_data)\n cv2.waitKey()\n cv2.destroyWindow(\"Contours check\")\n\n # find the perimeter of the first closed contour\n perim = cv2.arcLength(contours[0], True)\n # setting the precision\n epsilon = 0.02 * perim\n # approximating the contour with a polygon\n approxCorners = cv2.approxPolyDP(contours[0], epsilon, True)\n # check how many vertices has the approximate polygon\n approxCornersNumber = len(approxCorners)\n\n for corners in approxCorners:\n cv2.circle(trapezoid_data, (corners[0], corners[1]), radius=10, color=(255, 255, 255), thickness=-1)\n cv2.imshow(\"Vertex position\", trapezoid_data)\n cv2.waitKey()\n cv2.destroyWindow(\"Vertex position\")\n cv2.imshow(\"linesEdges\", edges)\n cv2.imshow(\"linesDetected\", copied_image_data)\n cv2.waitKey(0)\n cv2.destroyAllWindows()","def run(self):\n self.load_template()\n self.load_data()\n self.load_files()\n self.render_content()\n self.process()\n # pprint(self.data)","def process_data(self, windowed_data):\n return","def process_data(self):\n\n self.init_class()\n self.squirtle.setpos(self.x, self.y)\n\n _range = self.data.get(self.quantity_txt)\n _distance = self.data.get(self.distance_txt)\n\n for i in range(1, _range):\n self.squirtle.pendown()\n for sides in range(1, 5):\n self.squirtle.forward(_distance * i*3)\n self.squirtle.setheading(sides * 90)\n self.squirtle.penup()\n self.squirtle.goto(self.x * i*2.5, self.y * i*2.5)\n \n self.squirtle.goto(self.x, self.y)","def data_process(self):\n logging.info('Processing the data and split files')\n lines = Utility.file_len(self.fname)\n self.lines_to_be, self.split_files = Utility.split_files(self.fname, lines,\n cpu_count().real)","def __init__(self,root):\n ###\n #create window to read in the data\n ###\n self.popup = tk.Frame(root,width=100,height=20)\n self.popup.grid(columns=2,rows=3)\n self.intro = tk.Label(self.popup, text='Enter the path to the A-form data file (usually csv)')\n self.intro.grid(column=1,row=0,columnspan=2)\n self.data_file = tk.StringVar() \n self.docstring = tk.Entry(self.popup, textvariable=self.data_file)\n self.docstring.grid(column=1,row=2)\n self.docstring.config(width=75)\n \n #set default value for the data file\n self.data_file.set('./interests.csv')\n \n ###\n #browse button\n ###\n self.browse = tk.Button(self.popup, text='Browse', command = self.browse_files_in)\n self.browse.grid(column=2,row=2)\n \n ###\n #read button\n ###\n self.read = tk.Button(self.popup, text='OK', command = self.read_data)\n self.read.grid(column=1,row=3)","def Test(self):\n\t\tself.filename = \"NC-Xy_norm_bgsub.txt\"\n\t\tself.dirname = \"data\"\n\t\tself.FileText.SetLabel(\"File: \"+self.filename)\n\t\t#self.raw_file = self.LoadData(os.path.join(self.dirname, self.filename))\n\t\tself.AddBackgroundCheckBox.SetValue(True)\n\t\tself.combine_data()\n\t\tself.PP_AlgorithmRadio.SetValue(True)\n\t\tself.plot_data()","def handle_data(self, data):\n # Not defined in init due to Python2/Python3 complications.\n # pylint: disable=attribute-defined-outside-init\n self._text.append(data)","def process(self):","def process(self):","def process(self):","def preprocess(self, data, label):\n\t\traise NotImplementedError","def _async_process_data(self):\n raise NotImplementedError","def main():\n print(\"Album Tracker 1.6 - by Yu hui Hua\")\n main_menu()\n data_file.close()","def processor(self, data):\n streaming_data = self.decoder.decodeData(data)\n # Add Your code here to process data and handle transport/storage","def processor(self, data):\n streaming_data = self.decoder.decodeData(data)\n # Add Your code here to process data and handle transport/storage","def processor(self, data):\n streaming_data = self.decoder.decodeData(data)\n # Add Your code here to process data and handle transport/storage","def processor(self, data):\n streaming_data = self.decoder.decodeData(data)\n # Add Your code here to process data and handle transport/storage","def processor(self, data):\n streaming_data = self.decoder.decodeData(data)\n # Add Your code here to process data and handle transport/storage","def processor(self, data):\n streaming_data = self.decoder.decodeData(data)\n # Add Your code here to process data and handle transport/storage","def process(self):\n self.extract()\n self.transform()\n self.load()","def handle_data(self, data):\n\n # Medium export files have a footer with junk that's not part of the original post.\n # Stop processing entirely if we hit the document footer.\n if self.seen_footer:\n return\n\n # If this text is part of an image caption, slap that caption on the last Image card so the caption\n # ends up in the right place and bail out.\n if \"figcaption\" in self.tag_stack:\n self.cards[-1][1][\"caption\"] = data\n return\n\n # If we are nested inside a <pre>, we are dealing with code content. Just append it to the current code\n # card and bail.\n if \"pre\" in self.tag_stack:\n self.cards[-1][1][\"code\"] += data\n return\n\n # If we got this fair, we have regular HTML text that may or may not be nested inside a <strong>, <em>, etc tag.\n # In Mobiledoc, the easiest way to to annotate each text string with all the formats (strong, em) etc that apply\n # to it.\n # So let's loop through the html tag stack and see all the formatting tags that apply to this piece of text.\n markups_for_data = []\n markup_count = 0\n\n body = []\n if \"a\" in self.tag_stack:\n markups_for_data.append(len(self.markups) - 1)\n markup_count += 1\n if \"em\" in self.tag_stack:\n markups_for_data.append(0)\n markup_count += 1\n if \"strong\" in self.tag_stack:\n markups_for_data.append(1)\n markup_count += 1\n\n # Finally, generate a Mobiledoc tag containing the text and all the formatting tags that apply to it.\n body = [0, markups_for_data, markup_count, data]\n\n self.current_markers.append(body)","def handle(self, rawdata):\r\n\r\n return self.__filter(self.__handler(rawdata))","def load_data(self) -> None:","def _process(self):\n self.kwargs[\"collect\"].process_scan_form_data(self.kwargs[\"data\"])","def _extract_data(self, *args, **kwargs) -> None:\n raise NotImplementedError","def process(self, data) :\n rData = Core.Processlib.Data()\n rData.frameNumber = data.frameNumber\n rData.buffer = self._worker.process(data.buffer)\n if self._writer: #optional HDF5 writer\n self._writer.write(rData.buffer, rData.frameNumber)","def parse(self, data):\n raise NotImplementedError","def process(self):\n parser = csv.reader(self.reader,delimiter=self.delimiter_DIC[self.delim])\n firstRec = True\n for fields in parser:\n if firstRec:\n fieldNames = fields\n firstRec = False\n else:\n self.dicts.append({})\n for i,f in enumerate(fields):\n try:\n self.dicts[-1][fieldNames[i]] = f\n except:\n import pdb\n pdb.set_trace()\n if self.eng is \"spectrumMill\":\n for i,row in enumerate(self.dicts):\n fileSM = row[self.engine[self.eng][0]]\n acNoSM = row[self.engine[self.eng][1]]\n masSM=row[self.engine[self.eng][2]]\n chrgeSM=row[self.engine[self.eng][3]]\n preAmSM=row[self.engine[self.eng][4]].replace('(','').replace(')','')\n pepSM=row[self.engine[self.eng][5]]\n nAmSM=row[self.engine[self.eng][6]].replace('(','').replace(')','')\n modSM=row[self.engine[self.eng][7]].split('\\s')+row[self.engine[self.eng][8]].split('\\s')\n modLis = [mod.strip() for mod in modSM if mod!=' ']\n modSM = ';'.join(modLis)\n scoreSM=row[self.engine[self.eng][9]]\n descrimentSM=row[self.engine[self.eng][10]]\n if modSM !='':\n modPepInHupaFormat=self.modTermDic.spectrumMill(preAmSM,pepSM,nAmSM,modSM,self.eng)\n parsedData=acNoSM+'\\t'+masSM+'\\t'+chrgeSM+'\\t'+modPepInHupaFormat+'\\t'+scoreSM+'\\n'\n data = self.mapCaller(parsedData,self.eng)\n #print >>self.writer,data\n else:\n parsedData=acNoSM+'\\t'+masSM+'\\t'+chrgeSM+'\\t'+preAmSM+'.'+pepSM+'.'+nAmSM+'\\t'+'-'+'\\t'+scoreSM+'\\n'\n data = self.mapCaller(parsedData,self.eng)\n #print >>self.writer,data\n\n if self.eng is \"mascot\":\n \"\"\"\n In Mascot, under every gi (protein) corresponding peptide information will be there\n \"\"\"\n giFound=True\n for i,row in enumerate(self.dicts):\n if row[self.engine[self.eng][0]]!='':\n giAsKey = row[self.engine[self.eng][0]]\n giFound=False\n if giFound==False:\n massM=row[self.engine[self.eng][1]]\n chargeM=row[self.engine[self.eng][2]]\n preAmM=row[self.engine[self.eng][3]]\n pepM=row[self.engine[self.eng][4]]\n nAmM = row[self.engine[self.eng][5]]\n modM=row[self.engine[self.eng][6]]\n modSiteM=row[self.engine[self.eng][7]]\n scoreM=row[self.engine[self.eng][8]]\n evalM=row[self.engine[self.eng][9]]\n if modM !='':\n \"\"\"\n modificationFormat from modification.py creates a MASTER_UNIMOD dictionary \n Where all modifications of unimod would be available. \n At same time formatMod function in modificationFormat class would convert modification format \"\"\"\n modPepInHupaFormat=self.modTermDic.mascot(preAmM,pepM,nAmM,modSiteM,modM,self.eng)\n parsedData=giAsKey+'\\t'+massM+'\\t'+chargeM+'\\t'+modPepInHupaFormat+'\\t'+scoreM+'\\n'\n data=self.mapCaller(parsedData,self.eng)\n #print >>self.writer,data\n else:\n \n parsedData=giAsKey+'\\t'+massM+'\\t'+chargeM+'\\t'+preAmM+'.'+pepM+'.'+nAmM+'\\t'+'-'+'\\t'+scoreM+'\\n'\n data=self.mapCaller(parsedData,self.eng)\n #print >>self.writer,data\n\n if self.eng is \"inspect\":\n \"\"\"\n InSpect does not have mass information in TSV file\n So we need to fetch it from spectrum file (this is not yet done)\n \"\"\"\n for i,row in enumerate(self.dicts):\n data = row[self.engine[self.eng][0]]+'\\t'+row[self.engine[self.eng][1]]+'\\t'+row[self.engine[self.eng][2]]+'\\t'+row[self.engine[self.eng][3]]+'\\t'+row[self.engine[self.eng][4]]+'\\t'+row[self.engine[self.eng][5]]+'\\n'\n #return data\n #data = self.mapCaller(data)\n #self.writer.write(data)\n\n if self.eng is \"omssa\":\n #OMSSA csv doesnot contain start and last residue of the peptide, instead contains position. So start and last residue need to fetch from protein sequence\n for i,row in enumerate(self.dicts):\n giO = row[self.engine[self.eng][6]]\n massO= row[self.engine[self.eng][5]]\n chargeO=row[self.engine[self.eng][8]]\n preAmO = row[self.engine[self.eng][1]]#position in protein\n pepO = row[self.engine[self.eng][2]]\n nextAmO = row[self.engine[self.eng][3]] #position in protein\n scoreO= row[self.engine[self.eng][4]]\n modO=row[self.engine[self.eng][7]]\n if modO !='':\n #parsedData=giO+'#'+massO+'#'+chargeO+'#'+preAmO+'.'+pepO+'.'+nextAmO+'#'+modO+'#'+scoreO\n modPepInHupaFormat=self.modTermDic.omssa(preAmO,pepO,nextAmO,modO,self.eng)\n parsedData=giO+'\\t'+massO+'\\t'+chargeO+'\\t'+modPepInHupaFormat+'\\t'+scoreO+'\\n'\n self.mapCaller(parsedData,self.eng)\n else:\n parsedData=giO+'\\t'+massO+'\\t'+chargeO+'\\t'+preAmO+'.'+pepO+'.'+nextAmO+'\\t'+'-'+'\\t'+scoreO+'\\n'\n self.mapCaller(parsedData,self.eng)","def prepareData(self, *data):\n arguments = 8\n (self.X, self.X_name, self.Y, self.Y_name, self.alignment,\n self.model, self.annotations, self.args) = tuple(data[:arguments])\n \n self.width = self.args.beam_width\n self.mathType = self.args.mathType\n self.io_files = {\n 'input': self.args.intermediate_input_files,\n 'output': self.args.intermediate_output_files\n }\n self.repeat_width = self.args.repeat_width\n self.cons_count = self.args.cons_count\n self.posterior_processors = self.args.posterior_processors \n\n self.positionGenerator = \\\n list(AlignmentBeamGenerator(self.alignment, self.width))\n \n for i in range(len(self.model.states)):\n self.model.states[i].computeHints(self)\n\n return data[arguments:]","def loadPreviewData(self):\n # parameters for data load from GUI\n self.loadDataModel.pathToDataSet = self.entryPath.get()\n self.loadDataModel.firstRowIsTitle = bool(self.checkVarRow.get())\n self.loadDataModel.firstColIsRowNbr = bool(self.checkVarCol.get())\n # if entry field is empty, set nbrOfCategories to 0\n if len(self.entrytrainRowNbr.get()) == 0: # Code for this line from: https://stackoverflow.com/questions/15455113/tkinter-check-if-entry-box-is-empty\n self.loadDataModel.trainRowNumber = 0\n else:\n self.loadDataModel.trainRowNumber = int(self.entrytrainRowNbr.get())\n # if entry field is empty, set nbrOfCategories to 0\n if len(\n self.entryNbrCategories.get()) == 0: # Code for this line from: https://stackoverflow.com/questions/15455113/tkinter-check-if-entry-box-is-empty\n self.loadDataModel.nbrOfCategories = 0\n else:\n self.loadDataModel.nbrOfCategories = int(self.entryNbrCategories.get())\n self.loadDataModel.dataIsForTraining = True\n\n # Load data\n try:\n self.loadDataModel.loadData()\n print(\"LoadDataView: self.loadDataModel.data: \", self.loadDataModel.data)\n except FileNotFoundError:\n tk.messagebox.showerror(\"Error\", \" File not found.\")\n except ValueError:\n tk.messagebox.showerror(\"Error\", \"The number of categories entered is incorrect. Enter number > 0 and smaller\"\n \" the number of columns in the dataset.\")\n except:\n print(\"Load data failed because of something different than nbrOfCategories entered or file not found.\")\n else: # if data load worked do the following\n self.loadDataInformation.config(text=\"Data has been successfully loaded and stored.\", fg=\"green\")\n self.previewData()","def main():\n df_data = import_clean_process()\n plot_data_matplotlib(df_data)\n return","def run(self):\r\n self.collect_data()","def processData(self,data_file,directory,comment = '',way='mpcc',opt=[1024]):\n self.dirs = [name for name in os.listdir(directory)\n if os.path.isdir(os.path.join(directory, name))]\n\n # directory names are names of instruments\n #self.dirs =\n # ['cel', 'cla', 'flu', 'gac', 'gel', 'org', 'pia', 'sax', 'tru', 'vio', 'voi']\n self.dirs = [name for name in os.listdir(directory)\n if os.path.isdir(os.path.join(directory, name))]\n \n # example: self.files['sax'] =\n # IRMAS-TrainingData\\sax\\006__[sax][nod][cla]1686__1.wav\n self.files = {}\n for d in self.dirs:\n self.files[d] = [] \n sub_dir = os.path.join(directory, d)\n for filename in glob.glob(os.path.join(sub_dir, '*.wav')):\n self.files[d].append(filename)\n\n # Ex) self.output['cel']: np.array([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n i = 0\n for name in self.dirs:\n temp = []\n for j in range(len(self.dirs)):\n if i == j:\n temp.append(1)\n else:\n temp.append(0)\n self.output[name] = np.array(temp)\n i +=1\n\n #self.X = [] # list of input vectors\n #self.Y = [] # list of output vectors\n t0 = time.time()\n for name in self.dirs:\n t1 = time.time()\n for file in self.files[name]:\n #input_vector = processFile(file,length=length1,q=q1,fs_in=fs_in1,divide=divide1,plot = False)\n if way == 'mpcc':\n input_vector = processMPCC(file,*opt)\n elif way == 'fft':\n input_vector = processFFT(file,*opt)\n else:\n raise ValueError('Invalid Way, valid types include: \\'mpcc\\' or \\'fft\\'')\n if input_vector != 'failed':\n self.X.append(input_vector)\n self.Y.append(self.output[name])\n print('Time take to process '+str(name)+ ': ' + str((time.time()-t1)/60)[0:4] + ' min.')\n print('Total Processing Time: ' + str((time.time()-t0)/60)[0:4] + ' min.')\n\n # Now we can store all of the data in a json\n # Need to store self.X, self.Y, self.dirs,self.output,self.files,self.data\n # self.dirs is a list of strings -> fine\n # self.files is a dict() with string:string -> fine\n # self.output is a dict() with string:np.array\n output = {}\n for d in self.output:\n out_list = []\n for value in self.output[d]:\n out_list.append(int(value))\n output[d] = out_list # -> fine\n #self.X is a list of np.arrays\n X = []\n for i in range(len(self.X)):\n x = []\n for ele in self.X[i]:\n x.append(float(ele))\n X.append(x) # -> fine\n #self.Y is a list of np.arrays\n Y = []\n for i in range(len(self.Y)):\n y = []\n for ele in self.Y[i]:\n y.append(float(ele))\n Y.append(y) # -> fine\n \n store = {}\n store['dirs'] = self.dirs # good\n store['output'] = output # good\n store['files'] = self.files # good\n store['X'] = X # good\n store['Y'] = Y # good\n store['comment'] = comment\n with open(data_file, 'w') as outfile:\n json.dump(store, outfile)\n print('Preprocessed data stored in ' + str(data_file))\n return","def read(self, handler_name, rawdata):\r\n\r\n if handler_name in self.__events:\r\n data = self.__events[handler_name].handle(rawdata)\r\n if data.toflow() is not None:\r\n self.__to_flow.send(data.toflow())\r\n if data.todata() is not None:\r\n self.__to_data.send(data.todata())\r\n if data.toui() is not None:\r\n self.__to_ui.send(data.toui())\r\n else:\r\n raise MGPError('InputArea.read(): Tried to read for non-existing name \"{}\".'\r\n .format(handler_name))","def process(\n self,\n makeGlyphs=True,\n makeKerning=True,\n makeInfo=True,\n bendLocations=False,\n ):\n if self.logger:\n self.logger.info(\"Reading %s\", self.path)\n self.readInstances(\n makeGlyphs=makeGlyphs,\n makeKerning=makeKerning,\n makeInfo=makeInfo,\n bendLocations=bendLocations,\n )\n self.reportProgress(\"done\", 'stop')","def process(self):\n # check already processed\n proc_dir = os.path.join(self.root, self.processed_dir)\n train_path = os.path.join(proc_dir, self.train_fn)\n test_path = os.path.join(proc_dir, self.test_fn)\n if os.path.exists(train_path) and os.path.exists(test_path):\n # already exists => load process file\n print(\"processed dataset already exists; load it\")\n self.train_data = torch.load(train_path)\n self.test_data = torch.load(test_path)\n return\n\n # read and process raw data\n print(\"read and process raw dataset ...\")\n label_path = os.path.join(self.root, self.raw_dir, \"labels.txt\")\n image_path_format = os.path.join(self.root, self.raw_dir, \"img_{}.png\")\n \n with open(label_path) as f:\n for line in f:\n if not line.strip():\n break\n \n idx, label = map(int, line.strip().split('\\t'))\n image_path = image_path_format.format(idx)\n image = load_image(image_path)\n \n if idx <= self.split:\n self.train_data.append((image, label))\n elif idx > self.split:\n self.test_data.append((image, label))\n\n # write processed file\n if not os.path.exists(proc_dir):\n os.mkdir(proc_dir)\n\n with open(train_path, 'wb') as f:\n torch.save(self.train_data, f)\n with open(test_path, 'wb') as f:\n torch.save(self.test_data, f)\n\n print(\"Done!\")","def main():\n Tkinter.Tk().withdraw()\n try:\n #Ask user for the file and open the file in read mode\n file=tkFileDialog.askopenfile()\n\n try:\n #Read the file, split contents by lines, then split lines into words using \",\" as separator and\n # use the words to create carEvaluation object\n carevaluation_list=[CarEvaluation(*lines.split(\",\")) for lines in file.read().splitlines()]\n process_records(carevaluation_list)\n except Exception, e:\n print \"Error: Parsing file. Terminating the program! \" + str(e)\n sys.exit(e)\n finally:\n file.close()\n except Exception, e:\n print \"Error: Could not open the file to read. Terminating the program! \" + str(e)\n sys.exit(e)","def process_input(data):\n if data == \"NAME\":\n return get_name()\n \n elif data == \"SHIP PLACEMENT\":\n return get_ship_placements()\n \n elif data == \"SHOT LOCATION\":\n return get_shot_location()\n \n elif data == \"MISS\":\n MY_SHOTS[LAST_SHOT[0]][LAST_SHOT[1]] = data\n \n elif data == \"HIT\":\n MY_SHOTS[LAST_SHOT[0]][LAST_SHOT[1]] = data\n \n elif data[:4] == \"SUNK\":\n MY_SHOTS[LAST_SHOT[0]][LAST_SHOT[1]] = data\n \n elif data[:13] == \"OPPONENT SHOT\":\n tokens = data[14:].split(\",\")\n OPPONENT_SHOTS.append((int(tokens[0]), int(tokens[1]), tokens[2]))\n \n elif data == \"WIN\":\n return False\n \n elif data == \"LOSE\":\n return False\n \n elif data == \"ERROR\":\n return False\n \n return None","def prepare_data(self):","def load_data(self):","def processData(self, rawData, queryMeta=None):\n\t\treturn self.service.run(self, rawData, queryMeta)","def __init__(self,gui:bool=True):\n\t\t#TODO CHANGES.TXT, study standard format\n #TODO add INSTALLING\n self.LOG_FORMAT=\"%(levelname)s %(asctime)s %(pathname)s at %(lineno)s - %(message)s\"\n logging.basicConfig(filename='readTobiiGlasses.log',\n level=logging.DEBUG,\n format=self.LOG_FORMAT)\n self.logger=logging.getLogger()\n\n\n self.logger.debug('creating tk root..')\n self.root = Tk()\n self.root.geometry('640x400')\n self.root.title('Read Tobii Glasses')\n\n self.rootMenu = Menu(self.root)\n self.root.config(menu=self.rootMenu)\n\n\n self.logger.debug('creating report and status widgets...')\n self.status = Label(self.root, bd=1, relief=RIDGE, anchor=W)\n self.status.config(text='Please select settings or batch file.')\n self.status.pack(side=BOTTOM,fill=X)\n\n self.report=Text(self.root, bg='lightgray', relief=SUNKEN, wrap=WORD)\n self.report.insert('0.0',datetime.now().strftime('%Y-%m-%d') + '\\n')\n self.appendReport('ReadTobiiGlasses started.')\n self.report.pack(side=LEFT,anchor=NW,fill=BOTH)\n\n\n #setup other classes\n self.logger.debug('instantiating classes...')\n self.settingsReader = SettingsReader(self)\n self.multiData = MultiData(self)\n self.pivotData = PivotData(self)\n self.dataReader = DataReader(self)\n self.dataExporter = DataExporter(self)\n\n self.stats = Stats(self)\n self.stubPlot = StubPlot(self)\n self.tempoPlot = TempoPlot(self)\n self.spatialPlot = SpatialPlot(self)\n self.combiPlot = CombiPlot(self)\n\n self.logger.debug('populating menus...')\n #populate menu\n settingsMenu = Menu(self.rootMenu, tearoff=0)\n settingsMenu.add_command(label=\"Select...\", command=self.settingsReader.select)\n settingsMenu.add_command(label=\"Modify in external editor\", command=self.settingsReader.open)\n settingsMenu.add_command(label=\"Run batch and pivot tables...\", command=lambda: self.settingsReader.selectBatch(self.pivotData,self.stats))\n self.rootMenu.add_cascade(label=\"Settings\", menu=settingsMenu)\n\n dataMenu = Menu(self.rootMenu, tearoff=0)\n dataMenu.add_command(label=\"Parse settings and read data\", command=lambda: self.dataReader.read(self.settingsReader,self.multiData))\n dataMenu.add_command(label=\"Summary and validation\", command=self.multiData.validate)\n dataMenu.add_command(label=\"Standartization\", command=lambda: self.setStatus('Not implemented.'))\n exportMenu = Menu(dataMenu, tearoff=0)\n exportMenu.add_command(label=\"Fixations/saccades to Excel\", command=lambda: self.dataExporter.exportFixations(self.multiData,'xls'))\n exportMenu.add_command(label=\"Fixations/saccades to CSV\", command=lambda: self.dataExporter.exportFixations(self.multiData,'csv'))\n exportMenu.add_command(label=\"Gyroscope data\", command=lambda: self.dataExporter.exportGyro(self.multiData))\n exportMenu.add_command(label=\"Voc/ocul combined\", command=lambda: self.setStatus('Not implemented.'))\n dataMenu.add_cascade(label=\"Export\", menu=exportMenu)\n self.rootMenu.add_cascade(label=\"Data\", menu=dataMenu)\n\n statsMenu = Menu(self.rootMenu, tearoff=0)\n statsMenu.add_command(label=\"Descriptive\", command=lambda: self.stats.descriptive(self.multiData))\n statsMenu.add_command(label=\"Difference\", command=lambda: self.stats.difference(self.pivotData))\n statsMenu.add_command(label=\"Variance\", command=lambda: self.setStatus('Not implemented.'))\n # экспортируем и сразу открываем\n # statsMenu.add_command(label=\"Save report to Excel\", command=self.stats.save)\n self.rootMenu.add_cascade(label=\"Statistics\", menu=statsMenu)\n\n vizMenu = Menu(self.rootMenu, tearoff=0)\n plotMenu = Menu(vizMenu, tearoff=0)\n plotMenu.add_command(label=\"Temporal\", command=lambda: self.tempoPlot.draw(self.multiData))\n plotMenu.add_command(label=\"Spatial\", command=lambda: self.spatialPlot.draw(self.multiData))\n plotMenu.add_command(label=\"Combined\", command=lambda: self.combiPlot.draw(self.multiData))\n vizMenu.add_cascade(label=\"Plots\", menu=plotMenu)\n distrMenu = Menu(vizMenu, tearoff=0)\n distrMenu.add_command(label=\"Histogram\", command=self.stubPlot.draw)\n distrMenu.add_command(label=\"Density\", command=self.stubPlot.draw)\n distrMenu.add_command(label=\"Cumulative\", command=self.stubPlot.draw)\n distrMenu.add_command(label=\"Spectrogram\", command=self.stubPlot.draw)\n vizMenu.add_cascade(label=\"Distribution\", menu=distrMenu)\n vizMenu.add_command(label=\"Gaze overlay animation\", command=self.stubPlot.draw)\n vizMenu.add_command(label=\"3D gaze vectors\", command=self.stubPlot.draw)\n vizMenu.add_command(label=\"Heatmap\", command=self.stubPlot.draw)\n vizMenu.add_command(label=\"Distance matrix\", command=self.stubPlot.draw)\n self.rootMenu.add_cascade(label=\"Visualizations\", menu=vizMenu)\n\n helpMenu = Menu(self.rootMenu, tearoff=0)\n manualsMenu = Menu(helpMenu, tearoff=0)\n manualsMenu.add_command(label=\"Tobii gyroscope data format\", command=lambda: self.gotoWeb('glasses2API'))\n manualsMenu.add_command(label=\"Tobii coordinate systems\", command=lambda: self.gotoWeb('coordSys'))\n helpMenu.add_cascade(label=\"Manuals\", menu=manualsMenu)\n helpMenu.add_command(label=\"Repository\", command=lambda: self.gotoWeb('repo'))\n helpMenu.add_command(label=\"Wiki\", command=lambda: self.gotoWeb('wiki'))\n self.rootMenu.add_cascade(label=\"Help\", menu=helpMenu)\n\n self.logger.debug('starting tk main loop...')\n if gui:\n self.root.mainloop()","def main():\r\n conn = psycopg2.connect(\"host=127.0.0.1 dbname=sparkifydb2 user=postgres password=261998\")\r\n cur = conn.cursor()\r\n\r\n process_data(cur, conn, filepath='C:/Users/AG/Downloads/Data-engineering-nanodegree-master/Data-engineering-nanodegree-master/1_dend_data_modeling/P1_Postgres_Data_Modeling_and_ETL/data/song_data', func=process_song_file)\r\n process_data(cur, conn, filepath='C:/Users/AG/Downloads/Data-engineering-nanodegree-master/Data-engineering-nanodegree-master/1_dend_data_modeling/P1_Postgres_Data_Modeling_and_ETL/data/log_data', func=process_log_file)\r\n\r\n conn.close()","def execute_event(self):\n try:\n with open(self._import_path_input.get(), 'r') as \\\n raw_data_file, \\\n open(self._export_path_input.get(),\n 'w', newline='') as processed_data_file:\n\n # all situation counter\n count_true = 0\n count_false = 0\n count_tag = 0\n count_not_found = 0\n\n # get the user input api(url)\n original_url = self._url_input.get()\n\n # true/false and tag/NotFound flags\n flag_true_false = False\n flag_tag_notfound = False\n\n # set the flag\n temp_line = raw_data_file.readline().strip().strip('\\r\\n')\n temp_clean_url = original_url[:-8] + temp_line\n temp_response = self.api_dealer(temp_clean_url)\n if temp_response == 't' or temp_response == 'f':\n flag_true_false = True\n else:\n flag_tag_notfound = True\n\n # process the file\n for line in raw_data_file:\n clean_line = line.strip().strip('\\r\\n')\n if clean_line == '':\n tk.messagebox.showinfo('info', 'end of file or '\n 'unexpected newline in '\n 'the end')\n break\n # get rid of the '<target>' ending of the original url\n # and combine with the real target\n clean_url = original_url[:-8] + clean_line\n response = self.api_dealer(clean_url)\n\n # deal with different kinds of output and update the counter\n if response == 't':\n count_true += 1\n elif response == 'f':\n count_false += 1\n elif response == 'Not Found':\n count_not_found += 1\n else:\n count_tag += 1\n\n # create the output row and write to file\n output_row = clean_line + ' ' + response + '\\r\\n'\n processed_data_file.write(output_row)\n\n # now output the ratio\n if flag_true_false:\n self._ratio_var.set(str(count_true) + '/' + str(\n count_true + count_false))\n elif flag_tag_notfound:\n self._ratio_var.set(str(count_tag) + '/' + str(count_tag\n + count_not_found))\n\n tk.messagebox.showinfo('message', 'job done! have a nice day!')\n\n except Exception as e:\n tk.messagebox.showerror('error', e)","def process(self):\n\n # validate processing\n if self.is_acceptable():\n # handle data and write log\n self.handle()","def handle_mouse_data(data):\n pass","def execute_event(self):\n # step1: process the tag file and produce the tag dictionary\n try:\n tag_dict = self.tag_file_process(self._tag_file_input.get())\n except Exception as e:\n tk.messagebox.showerror('error', e)\n\n # step2: load the result csv file and the writing file\n try:\n with open(self._import_path_input.get(), 'r', encoding='utf-8') as raw_data_file, \\\n open(self._export_path_input.get(), 'w', encoding='utf-8-sig', newline='') as \\\n processed_data_file:\n # to solved the chinese character output but it does not work\n # as expected\n #processed_data_file.write(codecs.BOM_UTF8)\n reader = csv.reader(raw_data_file)\n writer = csv.writer(processed_data_file, dialect='excel')\n rows = []\n for row in reader:\n row[0] = row[0].encode('utf-8').decode('utf-8-sig')\n rows.append(row)\n\n # now transform the row list to column list\n columns = self.row_to_column_helper(len(rows[0]), rows)\n\n # now process all the columns and translate all tags\n # do modifications directly on the columns list\n self.tag_translator(tag_dict, columns)\n\n # now transfer the columns back to rows\n output_rows = self.column_to_row_helper(columns)\n\n # write each row back to the csv file\n writer.writerows(output_rows)\n\n tk.messagebox.showinfo('Good News', 'Job Done!')\n\n except Exception as e:\n tk.messagebox.showerror('error', e)","def run(self):\n\n argsdict = self.collect_users_input()\n cmd = 'python3 ./widgets/tools/polygonize.py ' + argsdict['rasterpath']+ argsdict['labels']+ argsdict['shapefile_path']+ argsdict['layer_name'] + argsdict['class_name'] + argsdict['idfield'] +argsdict['lstcostumelabels']\n self.process.cmd = cmd\n self.process.start_process2()\n newlayer= argsdict['layerfullpath']\n #self.process.process.finished.connect(lambda: self.legendwidget.add_to_canvas([newlayer]))\n self.process.process.finished.connect(lambda: self.load_results(newlayer))","def _load_general_data_page(self):\r\n\r\n # Load the editable gtk.Widgets().\r\n self.txtCode.handler_block(self._lst_handler_id[0])\r\n self.txtCode.set_text(str(self._function_model.function_code))\r\n self.txtCode.handler_unblock(self._lst_handler_id[0])\r\n\r\n _textview = self.txtName.get_child().get_child()\r\n _textview.handler_block(self._lst_handler_id[1])\r\n _textbuffer = _textview.get_buffer()\r\n _textbuffer.set_text(self._function_model.name)\r\n _textview.handler_unblock(self._lst_handler_id[1])\r\n\r\n _textview = self.txtRemarks.get_child().get_child()\r\n _textview.handler_block(self._lst_handler_id[2])\r\n _textbuffer = _textview.get_buffer()\r\n _textbuffer.set_text(self._function_model.remarks)\r\n _textview.handler_unblock(self._lst_handler_id[2])\r\n\r\n # Load the non-editable gtk.Widgets().\r\n self.txtTotalCost.set_text(\r\n str(locale.currency(self._function_model.cost)))\r\n self.txtModeCount.set_text(\r\n str('{0:d}'.format(self._function_model.n_modes)))\r\n self.txtPartCount.set_text(\r\n str('{0:d}'.format(self._function_model.n_parts)))\r\n\r\n return False","def _process(self):\n self.output[\"data\"] = get_form_data(self.kwargs[\"collect\"].ona_scan_form_pk)","def handle_data(self, data):\n if len(data.strip()) > 0:\n self.table += data\n # print(data, end=\" \")","def preProcess(self, datum):\n pass","def callback_dat(fd_):\n # receive data\n data = os.read(fd_, 8)\n if data == '':\n return\n data, = struct.unpack('<Q', data)\n # TODO: Interpret data","def parse_data(fp):\n pass","def __call__(self,data):\n\n log.debug('got data: %s' % (len(data)))\n\n # if we don't have args yet, these must be them\n if not self.args:\n self.parse_args(data)\n\n else:\n # we've already got args, must\n # be a message\n self.handle_send(data)","def recive_data(self):\n # read all available data\n while self.ser.inWaiting() > self.INPUT_DATA_SIZE+1:\n data = array.array('c')\n # search the header\n data.append(self.ser.read(1))\n while data[0] != chr(1):\n data[0] = self.ser.read(1)\n \n # wait for all available data\n while self.ser.inWaiting() < (self.INPUT_DATA_SIZE-1):\n time.sleep(0.03);\n \n # recives data\n data = self.ser.read(self.INPUT_DATA_SIZE-1)\n \n # prove if you want graphical data\n if self.pushButton_monitor.isChecked():\n # decodes the data\n t = struct.unpack('I', data[3]+data[2]+data[1]+data[0])\n r = struct.unpack('f', data[4]+data[5]+data[6]+data[7])\n x0 = struct.unpack('f', data[8]+data[9]+data[10]+data[11])\n x1 = struct.unpack('f', data[12]+data[13]+data[14]+data[15])\n u = struct.unpack('f', data[16]+data[17]+data[18]+data[19])\n \n self.time = t[0]*25e-9\n \n # prepare the string output\n aux_str = \" t = \"+str(self.time)+\"\\t\"\n aux_str += \" r = \"+str(r[0])+\"\\t\"\n aux_str += \" u = \"+str(u[0])+\"\\t\"\n aux_str += \" x1 = \"+str(x1[0])+\"\\t\"\n aux_str += \" x0 = \"+str(x0[0])+\"\\n\"\n # print string output\n self.textBrowser.insertPlainText(aux_str)\n \n # append data to the arrays\n self.graf_t.append(self.time)\n self.graf_r.append(r[0])\n self.graf_x0.append(x0[0])\n self.graf_x1.append(x1[0])\n self.graf_u.append(u[0])\n \n # remove one value if the arrays have maximum length\n if self.graf_t.buffer_info()[1] >= NUM_SAMPLES:\n self.graf_t.pop(0)\n self.graf_r.pop(0)\n self.graf_x0.pop(0)\n self.graf_x1.pop(0)\n self.graf_u.pop(0)\n \n # reload number of samples lavel\n self.label_samples_value.setText(str(self.graf_t.buffer_info()[1]))\n # reload number of waiting chars in serial rx buffer\n self.label_rx_buff_value.setText(str(self.ser.inWaiting()))\n\n # reload mutex area\n self.updated_data = 1\n \n # prove if there are available id's\n if (self.actionPC_Monitor.isChecked() and data[20] == chr(2)):\n # if it is true, looks how much id's\n i = struct.unpack('B', data[21])\n\n if i[0] < STACK_SIZE:\n for z in range(i[0]):\n new_device = struct.unpack('B', data[z+22])\n new_string = str(new_device[0])\n \n llista = self.listWidget_link.findItems(new_string, QtCore.Qt.MatchExactly)\n if len(llista) == 0:\n self.listWidget_link.addItem(new_string)","def processData(args):\n inputfile=args.inputfile\n threshold=args.threshold\n mask_file=args.maskfile\n crop=args.crop\n voxelsize=args.voxelsize\n binaryClosing=args.binaryclosing\n binaryOpening=args.binaryopening\n vtfile=args.vtfile\n vt2esofspy=args.vt2esofspy\n output_report_csv_file=args.output_report_csv_file\n \n # Reading/Generating data\n if inputfile is None: # # Using generated sample data\n logger.info('Generating sample data...')\n metadata = {'voxelsize_mm': [1, 1, 1]}\n data3d = generate_sample_data(1, 0, 0)\n else: # Normal runtime\n dr = datareader.DataReader()\n data3d, metadata = dr.Get3DData(inputfile)\n\n # Custom voxel size\n if voxelsize is not None:\n metadata['voxelsize_mm'] = voxelsize\n\n # Crop data\n if crop is not None:\n logger.debug('Croping data: %s', str(crop))\n data3d = data3d[crop[0]:crop[1], crop[2]:crop[3], crop[4]:crop[5]].copy()\n\n # Init HistologyAnalyser object\n logger.debug('Init HistologyAnalyser object')\n ha = HistologyAnalyser(data3d, metadata, threshold, \n binaryClosing=binaryClosing, binaryOpening=binaryOpening, \n nogui=True, aggregate_near_nodes_distance=args.aggregatenearnodes,\n hist_length_range=args.hist_length_range,\n hist_radius_range=args.hist_radius_range\n )\n\n # Remove Area = Load mask from file\n if mask_file is not None:\n logger.debug('Loading mask from file...')\n mask = misc.obj_from_file(filename=mask_file, filetype='pickle')\n if ha.data3d.shape == mask.shape:\n ha.data3d_masked = mask\n ha.data3d[mask == 0] = np.min(ha.data3d)\n else:\n raise ValueError('Mask file has wrong dimensions '+str(mask.shape))\n \n # Segmentation\n logger.debug('Segmentation')\n ha.data_to_skeleton()\n\n # Computing statistics\n logger.info(\"# ## ## ## ## statistics\")\n ha.data_to_statistics()\n\n # Saving files\n logger.info(\"# ## ## write stats to file\")\n ha.writeStatsToCSV()\n if vtfile is not None:\n ha.writeStatsToYAML(vtfile)\n if vt2esofspy is not None:\n ha.exportVT2esofspy(vt2esofspy)\n\n # ## Histology report\n logger.info(\"# ## ## Histology report\")\n hr = HistologyReport(ha.hr_hist_length_range, ha.hr_hist_radius_range)\n hr.data = ha.stats\n\n # Add results Record\n if crop is not None:\n label = str(crop[0])+\"-\"+str(crop[1])\n else:\n label = \"0-end\"\n # pass label into addResultRecord with stats\n hr.data['general']['label'] = label\n\n hr.generateStats()\n # TODO Rename functions\n hr.writeReportToCSV()\n hr.writeReportToYAML()\n\n \n if inputfile is None:\n hr.addResultsRecord(label=label, recordfilename=output_report_csv_file)\n else:\n hr.addResultsRecord(label=label, datapath=inputfile, recordfilename=output_report_csv_file)\n\n # ## End\n logger.info('Finished')","def justhandle(self, rawdata):\r\n\r\n return self.__handler(rawdata)","def process(self):\n # Opening and preprocessing of the input file\n if self.options.mbtiles_fromdisk or self.options.mbtiles_todisk:\n if self.options.mbtiles_fromdisk:\n i_parm=10\n if self.options.mbtiles_todisk:\n i_parm=11\n if self.options.verbose:\n print \"GDAL2MbTiles :mbtiles from/to disk [\",i_parm,\"] mbtiles_fromdisk[\",self.options.mbtiles_fromdisk,\"] mbtiles_todisk[\",self.options.mbtiles_todisk,\"]\"\n self.mbtiles_setup(i_parm)\n return\n else:\n if self.options.verbose:\n print \"GDAL2MbTiles :tile creation mbtiles[\",self.options.mbtiles,\"]\"\n self.open_input()\n # Generation of main metadata files and HTML viewers\n self.generate_metadata()\n # Generation of the lowest tiles\n self.generate_base_tiles()\n # Generation of the overview tiles (higher in the pyramid)\n self.generate_overview_tiles()\n # Generating of KML\n self.generate_kml()","def input(self, data, output = None):\n\t\tif (self.isLoaded()):\n\t\t\tif output != None:\n\t\t\t\tself.loader.input(data, output)\n\t\t\telse:\n\t\t\t\tself.loader.input(data)","def generate_gui():\n layout = [\n [sg.Text(\"Load from file: \", size=(40, 1),\n font=(38,), key=\"-LOAD_STATUS-\")],\n [sg.InputText(\"\"), sg.FileBrowse(\"Browse\")],\n [sg.Button(\"Load\")],\n [sg.Text(\"Query:\"), sg.Text(\"\", size=(40, 1), key=\"-OUTPUT-\")],\n [sg.Input(key=\"-QUERY-\")],\n [sg.Button(\"Output - CSV\"), sg.Button(\"Output - Images\"), sg.Exit()],\n ]\n\n window = sg.Window(\"MTG SQL Interface\", layout)\n\n while True:\n event, values = window.Read()\n if event in (None, \"Exit\"):\n break\n\n if event == \"Load\":\n # load file into Deck object & database\n if values[\"Browse\"] != \"\":\n p = Path(values[\"Browse\"])\n _, db = file_to_db(p, window)\n window[\"-QUERY-\"].Update(f\"\"\"SELECT * FROM {p.stem} WHERE\"\"\")\n\n if event == \"Output - CSV\":\n # query database, store output as csv\n p = Path(values[\"Browse\"]).stem + \".db\"\n d = query_db(p, values[\"-QUERY-\"], output=\"text\")\n window[\"-OUTPUT-\"].Update(\"written to CSV\")\n\n if event == \"Output - Images\":\n # query database, download corresponding images\n p = Path(values[\"Browse\"]).stem + \".db\"\n d = query_db(p, values[\"-QUERY-\"], output=\"images\")\n window[\"-OUTPUT-\"].Update(\"images saved\")\n\n window.Close()","def pass_data(self, data):\n self.data = data\n self.load_input_fields()","def __process_element(data):\n print('prosessing {}'.format(data))\n x_i = data[0]\n y_i = data[1]\n\n file_name = FeatureExtractor.get_file_name(x_i, feature_name)\n try:\n # try to load if file already exist\n np.load(out_path / file_name, allow_pickle=True)\n print('info: {} loaded from .npy !'.format(file_name))\n new_labels.append([file_name, y_i])\n except FileNotFoundError or OSError or EOFError:\n # OSError and EOFError are raised if file are inconsistent\n voice_activation = np.load(source_path / x_i, allow_pickle=True)\n mean_voice_activation = FeatureExtractor.get_mean_voice_activation(voice_activation[0])\n # this is kind-of standard\n FeatureExtractor.save_feature([voice_activation[0], mean_voice_activation], feature_name, out_path, x_i,\n y_i, new_labels)","def process(self):\n pass","def collect_incoming_data(self, data):\n self.__input.append(data)","def addLoadPaths(self):\n #create a static boxsizer\n load_box = wx.StaticBox(self, label=\"Step 1: Input Data\")\n box_sizer = wx.StaticBoxSizer(load_box, wx.VERTICAL)\n fgs = wx.FlexGridSizer(rows=2, cols=2, vgap=10, hgap=10)\n box_sizer.Add(fgs, proportion=1, flag=wx.EXPAND)\n\n #actual data handled by a FGS\n self.data_btn = wx.Button(self, label=\"Load Data\")\n self.data_btn.Bind(wx.EVT_BUTTON, self.onLoadData)\n\n self.assign_btn = wx.Button(self, label=\"Add Assignments\")\n self.assign_btn.Bind(wx.EVT_BUTTON, self.onAddAssignment)\n self.assign_btn.Disable()\n\n pub.subscribe(self.dataLoaded, \"data_loaded\")\n \n fgs.Add(self.data_btn, proportion=1, flag = wx.EXPAND)\n fgs.Add(wx.StaticText(self), proportion=1, flag = wx.EXPAND)\n\n fgs.Add(self.assign_btn)\n btn_label = wx.StaticText(self, label=\"(optional)\")\n new_font = btn_label.GetFont()\n new_font.SetStyle(wx.FONTSTYLE_ITALIC)\n btn_label.SetFont(new_font)\n fgs.Add(btn_label)\n \n \n fgs.Add(wx.StaticText(self), proportion=1, flag = wx.EXPAND)\n\n self.SetSizerAndFit(box_sizer)","def populate_data(self):\r\n # Importing StationData with the standard imports causes a redundancy\r\n # problem, so it is imported here only when it is needed.\r\n from stationData import StationData\r\n # Find data requirements from all plumes.\r\n requirements = describe.PLUMES\r\n # Loop over plumes and define parameters to be used for pulling data.\r\n grib_file = pygrib.open(self.grib_file_path)\r\n for req in requirements:\r\n (plume,data_types,grid_level_type,grid_level,unused) = req\r\n selected = grib_file.select(shortName=data_types,\r\n typeOfLevel=grid_level_type,\r\n level=grid_level)\r\n for i, message in enumerate(selected):\r\n if i % 20 == 0:\r\n print '%s %s/%s Grib messages processed for %s' %\\\r\n (PRETEXT, i + 1, len(selected), req[0])\r\n for sdo in StationData.instances:\r\n if sdo.grib_i is None:\r\n StationData.populate_grid_information(message,\r\n self.config)\r\n sdo.add_data(plume,self.member_name,message)\r\n grib_file.close()\r\n return","def got_data(self, data):\n if self.get_current_state() == SBE37ProtocolState.DIRECT_ACCESS:\n # direct access mode\n if len(data) > 0:\n mi_logger.debug(\"SBE37Protocol._got_data(): <\" + data + \">\") \n if self._driver_event:\n self._driver_event(DriverAsyncEvent.DIRECT_ACCESS, data)\n # TODO: what about logging this as an event?\n return\n \n if len(data)>0:\n # Call the superclass to update line and prompt buffers.\n CommandResponseInstrumentProtocol.got_data(self, data)\n \n # If in streaming mode, process the buffer for samples to publish.\n cur_state = self.get_current_state()\n if cur_state == SBE37ProtocolState.AUTOSAMPLE:\n if SBE37_NEWLINE in self._linebuf:\n lines = self._linebuf.split(SBE37_NEWLINE)\n self._linebuf = lines[-1]\n for line in lines:\n self._extract_sample(line)"],"string":"[\n \"def handle_data(self, data):\\n if verbose(): print(\\\"TIParser.handle_data(self, '%s')\\\" % (data))\\n pass\",\n \"def processInputs(self):\",\n \"def run(self, data):\\n\\t\\t# no processing here\\n\\t\\treturn data\",\n \"def parse_data(self):\\n\\t\\traise NotImplementedError('%s: No parse function implemented!' % self.name)\",\n \"def processIncoming(self):\\n try:\\n msg = self.guiqueue.get(False)\\n (PK, XERRO, tt) = getDataFromString(msg)\\n self.PK0.append(PK[0])\\n self.PK1.append(PK[1])\\n self.PK2.append(PK[2])\\n self.PK3.append(PK[3])\\n self.PK4.append(PK[4])\\n self.PK5.append(PK[5])\\n self.PK6.append(PK[6])\\n self.PK7.append(PK[7])\\n self.XERRO0.append(XERRO[0])\\n self.XERRO1.append(XERRO[1])\\n self.XERRO2.append(XERRO[2])\\n self.XERRO3.append(XERRO[3])\\n self.XERRO4.append(XERRO[4])\\n self.XERRO5.append(XERRO[5])\\n self.XERRO6.append(XERRO[6])\\n self.XERRO7.append(XERRO[7])\\n self.t.append(tt)\\n \\n \\n #replota a cada dado novo\\n self.updatePlot()\\n \\n except queue.Empty:\\n #print(\\\"Fila Vazia\\\")\\n pass\\n\\n self.root.after(25, self.processIncoming)\",\n \"def handle(self, data):\\n pass\",\n \"def data_processing_interface(root):\\n try:\\n root.withdraw()\\n top = ThemedTk(theme=\\\"aqua\\\")\\n top.title(\\\"Data Processing\\\")\\n top.geometry(\\\"500x300\\\")\\n\\n # label at the top of person database name\\n my_label = Label(top, text=\\\"Data Processing\\\", font=(\\\"Times New Roman\\\", 18, \\\"bold\\\"))\\n my_label.grid(row=0, column=1, padx=(50, 50), pady=(10, 20))\\n\\n def path_of_image():\\n \\\"\\\"\\\" open file explorer to select directory \\\"\\\"\\\"\\n top.folder_name = filedialog.askdirectory(title=\\\"select directory\\\",\\n initialdir=\\\"C:/Users/Ayush sagore/JUPITER NOTEBOOK ML/CNN Model/\\\"\\n \\\"test_dataset/\\\")\\n path_name.insert(0, top.folder_name)\\n\\n # label and input field for path and button right to input field for browsing to data source folder\\n path_name_label = Label(top, text=\\\"Source Path :\\\", font=(\\\"Times New Roman\\\", 12, \\\"bold\\\"))\\n path_name_label.grid(row=1, column=0, padx=(0, 10), pady=(20, 10))\\n\\n path_name = Entry(top, width=25, font=(\\\"Times New Roman\\\", 12, \\\"bold\\\"))\\n path_name.grid(row=1, column=1, padx=(13, 10), pady=(20, 10))\\n\\n path_btn = Button(top, text=\\\"->\\\", command=path_of_image)\\n path_btn.grid(row=1, column=2, columnspan=2, pady=(15, 0), padx=(0, 0), ipady=1, ipadx=6)\\n\\n # label and input field for folder name\\n folder_name_label = Label(top, text=\\\"Folder Name :\\\", font=(\\\"Times New Roman\\\", 12, \\\"bold\\\"))\\n folder_name_label.grid(row=2, column=0, padx=(10, 10), pady=(20, 10))\\n\\n folder_name = Entry(top, width=25, font=(\\\"Times New Roman\\\", 12, \\\"bold\\\"))\\n folder_name.grid(row=2, column=1, padx=20, pady=(20, 10))\\n\\n def hide_open2():\\n root.deiconify()\\n top.destroy()\\n\\n exit2_btn = Button(top, text=\\\"EXIT\\\", font=(\\\"Times New Roman\\\", 12, \\\"bold\\\"), bg=\\\"gray\\\", command=hide_open2)\\n exit2_btn.grid(row=20, column=1, columnspan=2, pady=25, padx=(100, 0), ipadx=50)\\n\\n def check_given_data():\\n \\\"\\\"\\\" This function check whether data given by user valid or not. \\\"\\\"\\\"\\n if os.path.exists(path_name.get()) and folder_name.get() != \\\"\\\":\\n # if True:\\n progress = ThemedTk(theme=\\\"aqua\\\")\\n progress.title(\\\"Progress\\\")\\n\\n top.withdraw()\\n\\n info_label = Label(progress, text=\\\"Attentive set filtering is on progress\\\", font=(\\\"Times New Roman\\\", 12, \\\"bold\\\"))\\n info_label.pack(pady=10)\\n progress_bar = Progressbar(progress, orient=HORIZONTAL, length=220, mode='determinate')\\n progress_bar.pack(pady=20)\\n filter_dataset(path_name.get(), folder_name.get(), progress_bar, info_label, progress, root)\\n\\n else:\\n messagebox.showerror(\\\"Message\\\", \\\"Please enter valid directory path\\\\n \\\\\\n and folder name\\\")\\n\\n # show and exit button\\n next_page_btn = Button(top, text=\\\"Next Page\\\", font=(\\\"Times New Roman\\\", 12, \\\"bold\\\"), bg=\\\"gray\\\",\\n command=check_given_data) # next_page_interface(top, root)\\n next_page_btn.grid(row=20, column=0, columnspan=2, pady=25, padx=(0, 200), ipadx=22)\\n\\n except Exception as e:\\n messagebox.showerror(\\\"Message\\\", \\\"Error in the data processing interface\\\")\",\n \"def _process(self, data: np.ndarray) -> np.ndarray:\",\n \"def _process(self, data: np.ndarray) -> np.ndarray:\",\n \"def _data_process(self, v):\\n pass\",\n \"def process_data(self, data):\\n return data\",\n \"def processInputData(self, unformattedData):\\n tempList = unformattedData.split('\\\\n')\\n rawNodes = copy.copy(list(self.filterRawNodes(tempList)))\\n self.vertices = self.createVertices(rawNodes)\\n self.edges = self.createEdges(rawNodes, self.vertices)\\n self.createEdgesList(rawNodes, self.vertices)\",\n \"def recive_data(self, data_waveformreceived):\\r\\n self.adcollector.save_as_binary(self.savedirectory)\\r\\n self.channel_number = len(data_waveformreceived)\\r\\n if self.channel_number == 1: \\r\\n if 'Vp' in self.readinchan:\\r\\n self.data_collected_0 = data_waveformreceived[0]\\r\\n \\r\\n self.PlotDataItem_patch_voltage = PlotDataItem(self.xlabelhere_all, self.data_collected_0)\\r\\n #use the same color as before, taking advantages of employing same keys in dictionary\\r\\n self.PlotDataItem_patch_voltage.setPen('w')\\r\\n self.pw_data.addItem(self.PlotDataItem_patch_voltage)\\r\\n \\r\\n self.textitem_patch_voltage = pg.TextItem(('Vp'), color=('w'), anchor=(1, 1))\\r\\n self.textitem_patch_voltage.setPos(0, 1)\\r\\n self.pw_data.addItem(self.textitem_patch_voltage)\\r\\n elif 'Ip' in self.readinchan:\\r\\n self.data_collected_0 = data_waveformreceived[0]\\r\\n \\r\\n self.PlotDataItem_patch_current = PlotDataItem(self.xlabelhere_all, self.data_collected_0)\\r\\n #use the same color as before, taking advantages of employing same keys in dictionary\\r\\n self.PlotDataItem_patch_current.setPen('c')\\r\\n self.pw_data.addItem(self.PlotDataItem_patch_current)\\r\\n \\r\\n self.textitem_patch_current = pg.TextItem(('Ip'), color=('w'), anchor=(1, 1))\\r\\n self.textitem_patch_current.setPos(0, 1)\\r\\n self.pw_data.addItem(self.textitem_patch_current) \\r\\n elif 'PMT' in self.readinchan: # repeatnum, PMT_data_index_array, averagenum, ScanArrayXnum\\r\\n self.data_collected_0 = data_waveformreceived[0]*-1\\r\\n self.data_collected_0 = self.data_collected_0[0:len(self.data_collected_0)-1]\\r\\n \\r\\n # pmt data could come from raster scanning mode or from contour scanning mode.\\r\\n try:\\r\\n for i in range(self.repeatnum):\\r\\n self.PMT_image_reconstructed_array = self.data_collected_0[np.where(self.PMT_data_index_array_repeated == i+1)]\\r\\n Dataholder_average = np.mean(self.PMT_image_reconstructed_array.reshape(self.averagenum, -1), axis=0)\\r\\n Value_yPixels = int(len(self.samples_1)/self.ScanArrayXnum)\\r\\n self.PMT_image_reconstructed = np.reshape(Dataholder_average, (Value_yPixels, self.ScanArrayXnum))\\r\\n \\r\\n # Stack the arrays into a 3d array\\r\\n if i == 0:\\r\\n self.PMT_image_reconstructed_stack = self.PMT_image_reconstructed\\r\\n else:\\r\\n self.PMT_image_reconstructed_stack = np.concatenate((self.PMT_image_reconstructed_stack, self.PMT_image_reconstructed), axis=0)\\r\\n \\r\\n Localimg = Image.fromarray(self.PMT_image_reconstructed) #generate an image object\\r\\n Localimg.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+str(i)+'.tif')) #save as tif\\r\\n \\r\\n plt.figure()\\r\\n plt.imshow(self.PMT_image_reconstructed, cmap = plt.cm.gray)\\r\\n plt.show()\\r\\n except:\\r\\n np.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+'flatten'), self.data_collected_0)\\r\\n \\r\\n elif self.channel_number == 2: \\r\\n if 'PMT' not in self.readinchan:\\r\\n self.data_collected_0 = data_waveformreceived[0]\\r\\n \\r\\n self.PlotDataItem_patch_voltage = PlotDataItem(self.xlabelhere_all, self.data_collected_0)\\r\\n #use the same color as before, taking advantages of employing same keys in dictionary\\r\\n self.PlotDataItem_patch_voltage.setPen('w')\\r\\n self.pw_data.addItem(self.PlotDataItem_patch_voltage)\\r\\n \\r\\n self.textitem_patch_voltage = pg.TextItem(('Vp'), color=('w'), anchor=(1, 1))\\r\\n self.textitem_patch_voltage.setPos(0, 1)\\r\\n self.pw_data.addItem(self.textitem_patch_voltage) \\r\\n \\r\\n self.data_collected_1 = data_waveformreceived[1]\\r\\n \\r\\n self.PlotDataItem_patch_current = PlotDataItem(self.xlabelhere_all, self.data_collected_1)\\r\\n #use the same color as before, taking advantages of employing same keys in dictionary\\r\\n self.PlotDataItem_patch_current.setPen('c')\\r\\n self.pw_data.addItem(self.PlotDataItem_patch_current)\\r\\n \\r\\n self.textitem_patch_current = pg.TextItem(('Ip'), color=('w'), anchor=(1, 1))\\r\\n self.textitem_patch_current.setPos(0, 1)\\r\\n self.pw_data.addItem(self.textitem_patch_current) \\r\\n elif 'PMT' in self.readinchan:\\r\\n self.data_collected_0 = data_waveformreceived[0]*-1\\r\\n self.data_collected_0 = self.data_collected_0[0:len(self.data_collected_0)-1]\\r\\n \\r\\n try:\\r\\n for i in range(self.repeatnum):\\r\\n self.PMT_image_reconstructed_array = self.data_collected_0[np.where(self.PMT_data_index_array_repeated == i+1)]\\r\\n Dataholder_average = np.mean(self.PMT_image_reconstructed_array.reshape(self.averagenum, -1), axis=0)\\r\\n Value_yPixels = int(len(self.samples_1)/self.ScanArrayXnum)\\r\\n self.PMT_image_reconstructed = np.reshape(Dataholder_average, (Value_yPixels, self.ScanArrayXnum))\\r\\n \\r\\n # Stack the arrays into a 3d array\\r\\n if i == 0:\\r\\n self.PMT_image_reconstructed_stack = self.PMT_image_reconstructed\\r\\n else:\\r\\n self.PMT_image_reconstructed_stack = np.concatenate((self.PMT_image_reconstructed_stack, self.PMT_image_reconstructed), axis=0)\\r\\n \\r\\n Localimg = Image.fromarray(self.PMT_image_reconstructed) #generate an image object\\r\\n Localimg.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+str(i)+'.tif')) #save as tif\\r\\n \\r\\n plt.figure()\\r\\n plt.imshow(self.PMT_image_reconstructed, cmap = plt.cm.gray)\\r\\n plt.show()\\r\\n except:\\r\\n np.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+'contourscanning'), self.data_collected_0)\\r\\n \\r\\n if 'Vp' in self.readinchan:\\r\\n self.data_collected_1 = data_waveformreceived[1]\\r\\n \\r\\n self.PlotDataItem_patch_voltage = PlotDataItem(self.xlabelhere_all, self.data_collected_1)\\r\\n #use the same color as before, taking advantages of employing same keys in dictionary\\r\\n self.PlotDataItem_patch_voltage.setPen('w')\\r\\n self.pw_data.addItem(self.PlotDataItem_patch_voltage)\\r\\n \\r\\n self.textitem_patch_voltage = pg.TextItem(('Vp'), color=('w'), anchor=(1, 1))\\r\\n self.textitem_patch_voltage.setPos(0, 1)\\r\\n self.pw_data.addItem(self.textitem_patch_voltage)\\r\\n elif 'Ip' in self.readinchan:\\r\\n self.data_collected_1 = data_waveformreceived[1]\\r\\n \\r\\n self.PlotDataItem_patch_current = PlotDataItem(self.xlabelhere_all, self.data_collected_1)\\r\\n #use the same color as before, taking advantages of employing same keys in dictionary\\r\\n self.PlotDataItem_patch_current.setPen('c')\\r\\n self.pw_data.addItem(self.PlotDataItem_patch_current)\\r\\n \\r\\n self.textitem_patch_current = pg.TextItem(('Ip'), color=('w'), anchor=(1, 1))\\r\\n self.textitem_patch_current.setPos(0, 1)\\r\\n self.pw_data.addItem(self.textitem_patch_current)\",\n \"def process_raw_data(data_dir='/home/data/nbc/athena/athena-data/'):\\n\\n # Calls the process_corpus function, defined below\\n # process_corpus reads in the text, performs abbreviation, spelling,\\n # translation, and overall text Processing\\n # process_corpus outputs the processed text for each file and the stemmed file\\n for feature_source in ['abstract', 'full']:\\n process_corpus(data_dir, feature_source)\\n\\n # Calls the label_data function, defined below\\n # label_data reads in the metadata csv files, concatenates them, then\\n # reads in the processed text files\\n # label_data outputs a binary pmid by label metadata matrix\\n label_data(data_dir)\\n generate_gazetteer(data_dir)\",\n \"def run(self):\\n # FILE INPUT\\n if self.text_type == \\\"file\\\":\\n self.process_files()\\n\\n # STRING INPUT\\n else:\\n self.process_strings()\\n\\n if self.json:\\n self.save_json()\\n\\n if self.errors:\\n print(\\\"\\\\nThe following file(s) could not be opened:\\\")\\n for error in self.errors:\\n print(f\\\"\\\\t{error}\\\")\",\n \"def process_scene_data(self, scene, data, tmp_dir):\\n pass\",\n \"def processing(self):\\n pass\",\n \"def _read_data(self):\",\n \"def read_data(self):\\n if not self.header['data included']:\\n pass\\n elif self.header['file type'] in (21, 26):\\n self._isotope_data()\\n if os.path.exists(self.filename + '_txt'):\\n self._isotope_txt_data()\\n elif self.header['file type'] == 22:\\n # line scan types, no ImageHeader\\n warnings.warn('No data read for line scan, fix')\\n pass\\n elif self.header['file type'] in (31, 35):\\n self._beamstability_data()\\n else:\\n self._image_data()\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def loadData(self, data=None):\\n\\n super(SimpleControlComponentRig, self).loadData( data )\\n\\n ctrlSize = data.get('ctrlSize', 1.0)\\n ctrlXfo = data.get('ctrlXfo', Xfo())\\n\\n # ================\\n # Resize Controls\\n # ================\\n self.mainCtrl.setShape('square')\\n self.mainCtrl.rotatePoints(90, 0, 0)\\n self.mainCtrl.scalePoints(Vec3(ctrlSize, ctrlSize, ctrlSize))\\n\\n # =======================\\n # Set Control Transforms\\n # =======================\\n self.mainCtrlSpace.xfo = ctrlXfo\\n self.mainCtrl.xfo = ctrlXfo\\n\\n # ============\\n # Set IO Xfos\\n # ============\\n self.mainInputTgt.xfo = ctrlXfo\\n self.mainDef.xfo = ctrlXfo\\n self.outputTgt.xfo = ctrlXfo\\n\\n # ====================\\n # Evaluate Constraints\\n # ====================\\n self.mainInputConstraint.evaluate()\\n self.mainOutputConstraint.evaluate()\\n self.mainDefConstraint.evaluate()\\n\\n # ====================\\n # Evaluate Canvas Ops\\n # ====================\",\n \"def handle_data(self, data):\\n \\n line_num, offset = self.getpos()\\n new_pos = self.new_line_pos[line_num] + offset\\n self.data_buffer += self.html_doc[self.current_pos:new_pos]\\n\\n content = data\\n if self.filtering:\\n content = self.typogrify._apply_filters(content, self.lasttag)\\n self.filtered_data_length = len(content)\\n\\n self.data_buffer += content\\n self.current_pos = new_pos + len(data)\",\n \"def run(self):\\n\\n self.load_file()\\n self.cat_to_num()\\n self.split()\",\n \"def load_data(self):\\n filename = filedialog.askopenfilename(title=\\\"Select A File\\\",\\n file=((\\\"csv files\\\", \\\"*.csv\\\"),\\n (\\\"dat files\\\", \\\"*.dat\\\"),\\n (\\\"excel files\\\", \\\"*.xlsx\\\"),\\n (\\\"All Files\\\", \\\"*.*\\\")))\\n file_path = filename\\n try:\\n filename = f\\\"{file_path}\\\"\\n name = os.path.splitext(os.path.basename(filename))[0]\\n if name in ['h2o', 'KED', 'financial']:\\n DataLoader.data = load_data(name)\\n else:\\n DataLoader.data = pd.read_csv(filename)\\n except ValueError:\\n messagebox.showerror(\\\"Information\\\", \\\"The file you have chosen is invalid.\\\")\\n except FileNotFoundError:\\n messagebox.showerror(\\\"Information\\\", f\\\"No such file as {file_path}\\\")\\n self.clear_tree()\\n\\n self.treeview['columns'] = list(DataLoader.data.columns)\\n for i in self.treeview['columns']:\\n self.treeview.column(i, anchor=\\\"w\\\")\\n self.treeview.heading(i, text=i, anchor='w')\\n\\n for index, row in DataLoader.data.iterrows():\\n self.treeview.insert(\\\"\\\", 0, text=self.data.shape[0] - 1 - index, values=list(row))\\n self.treeview.column('#0', width=100)\\n\\n self.summary_label = ttk.Label(self, text=f'Data shape: {DataLoader.data.shape}', width=40)\\n self.summary_label.grid(row=2, column=0, columnspan=2, sticky=tk.S + tk.N)\",\n \"def _load_data(self, event):\\n if self.parent is not None:\\n wx.PostEvent(self.parent, NewLoadDataEvent())\",\n \"def handle_data(self, text):\\n self.pieces.append(text)\",\n \"def process_data_impl(\\n self,\\n data_dir: Path,\\n output_processed_data_dir: Path,\\n ) -> NoReturn:\\n pass\",\n \"def handle_input(data: dict):\",\n \"def _state_main(self, gui):\\n gui.entry.wait_variable(gui.entry_sv)\\n\\n '''Clean string'''\\n files = literal_eval(gui.entry_sv.get())\\n\\n '''Remove previous images'''\\n if hasattr(gui, \\\"panel\\\"):\\n gui.panel.destroy()\\n\\n '''Load each image'''\\n for file_name in files:\\n file_name = file_name.replace(\\\"{\\\", \\\"\\\").replace(\\\"}\\\", \\\"\\\")\\n # image = tk.PhotoImage(file=file_name)\\n if \\\".CR2\\\" in file_name:\\n '''Rawpy implementation'''\\n file_image = rawpy.imread(file_name)\\n file_image = file_image.postprocess()\\n '''Rawkit implementation'''\\n '''file_image = Raw(file_name)\\n file_image = np.array(file_image.to_buffer())'''\\n '''OpenCV implementation'''\\n '''file_image = cv2.imread(file_name)'''\\n else:\\n file_image = Image.open(file_name)\\n '''image = file_image.resize((500, 500), Image.ANTIALIAS)\\n image = ImageTk.PhotoImage(image)\\n gui.panel = tk.Label(gui.root, image=image)\\n gui.panel.image = image\\n gui.panel.pack()'''\\n # panel.grid(row=2)\\n\\n image_data = np.array(file_image)\\n image_data = cv2.cvtColor(image_data, cv2.COLOR_RGB2GRAY)\\n '''print(image_data.shape)\\n print(image_data)\\n print(len(image_data))\\n print(len(image_data[0]))'''\\n returned_image = Image.fromarray(image_data)\\n '''cv2.imshow(\\\"Gray\\\", image_data)\\n cv2.waitKey()\\n cv2.destroyWindow(\\\"Gray\\\")'''\\n\\n '''enhanced_contrast = ImageEnhance.Contrast(Image.fromarray(file_image))\\n enhanced_image = enhanced_contrast.enhance(255)\\n enhanced_data = np.array(enhanced_image)\\n plot_functions.imshow(enhanced_image)\\n plot_functions.show()'''\\n\\n # color_space = cv2.cvtColor(image_data, cv2.COLOR_RGB2HSV)\\n # print(color_space)\\n \\n '''Create mask for white-ish pixels'''\\n '''lower_background = np.array([150, 150, 150])\\n upper_background = np.array([255, 255, 255])\\n print(image_data)\\n white_mask = cv2.inRange(image_data, lower_background, upper_background)\\n white_mask = cv2.morphologyEx(white_mask, cv2.MORPH_OPEN, np.ones((3,3),np.uint8))\\n white_mask = cv2.morphologyEx(white_mask, cv2.MORPH_DILATE, np.ones((3, 3), np.uint8))\\n white_mask = white_mask / 255'''\\n\\n '''Create mask for black-ish pixels'''\\n '''lower_background = np.array([0, 0, 0])\\n upper_background = np.array([25, 25, 25])\\n black_mask = cv2.inRange(image_data, lower_background, upper_background)\\n black_mask = cv2.morphologyEx(black_mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8))\\n black_mask = cv2.morphologyEx(black_mask, cv2.MORPH_DILATE, np.ones((3, 3), np.uint8))\\n black_mask = black_mask / 255'''\\n\\n '''Add masks together'''\\n '''background_mask = white_mask\\n # Ensure no value is above 1\\n background_mask = np.clip(background_mask, 0, 1)'''\\n \\n copied_image_data = np.asarray(returned_image).copy()\\n # background_mask = np.logical_not(background_mask)\\n '''for row_index, [mask_row, image_row] in enumerate(zip(background_mask, copied_image_data)):\\n # place black pixel on corresponding masked pixels\\n # copied_image_data[row_index] = np.array([image_row[pixel] * int(mask_row[pixel]) for pixel in range(len(mask_row))])\\n # make pixel fully white on corresponding masked pixels\\n copied_image_data[row_index] = np.array([np.array([255, 255, 255]) if int(mask_row[pixel]) else image_row[pixel] for pixel in range(len(mask_row))])'''\\n\\n '''Turn removed pixels red'''\\n '''mask_image = Image.fromarray(copied_image_data)\\n plot_functions.imshow(mask_image)\\n plot_functions.show()'''\\n trapezoid_data = copied_image_data.copy()\\n\\n enhanced_contrast = ImageEnhance.Contrast(Image.fromarray(trapezoid_data))\\n enhanced_image = enhanced_contrast.enhance(255)\\n trapezoid_data = np.array(enhanced_image)\\n\\n '''Detect lines'''\\n edges = cv2.Canny(trapezoid_data, 75, 150)\\n lines = cv2.HoughLinesP(edges, 1, np.pi / 180, 100, maxLineGap=1000)\\n # print(lines)\\n for line in lines:\\n x1, y1, x2, y2 = line[0]\\n if y1 == y2:\\n cv2.line(copied_image_data, (x1, y1), (x2, y2), (255, 255, 255), 1)\\n\\n '''Trapezoid attempt'''\\n\\n # filters image bilaterally and displays it\\n bilatImg = cv2.bilateralFilter(trapezoid_data, 5, 175, 175)\\n\\n # finds edges of bilaterally filtered image and displays it\\n edgeImg = cv2.Canny(bilatImg, 75, 200)\\n\\n # gets contours (outlines) for shapes and sorts from largest area to smallest area\\n contours, hierarchy = cv2.findContours(edgeImg, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n contours = sorted(contours, key=cv2.contourArea, reverse=True)\\n\\n # drawing red contours on the image\\n for con in contours:\\n cv2.drawContours(trapezoid_data, con, -1, (255, 255, 255), 3)\\n\\n '''Detect corners'''\\n dst = cv2.cornerHarris(edges, 30, 31, 0.001)\\n dst = cv2.dilate(dst, None)\\n ret, dst = cv2.threshold(dst, 0.01 * dst.max(), 255, 0)\\n dst = np.uint8(dst)\\n\\n # find centroids\\n ret, labels, stats, centroids = cv2.connectedComponentsWithStats(dst)\\n # define the criteria to stop and refine the corners\\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100,\\n 0.001)\\n corners = cv2.cornerSubPix(edges, np.float32(centroids), (5, 5),\\n (-1, -1), criteria)\\n\\n good_corners = []\\n for corner in corners:\\n if (corner[1] < 1000) & (corner[1] > 650) & (corner[0] > 250) & (corner[0] < 2250):\\n good_corners.append(corner)\\n cv2.circle(edges, (corner[0], corner[1]), 10, (255, 255, 255))\\n\\n print(good_corners)\\n if len(good_corners) >= 3:\\n corner_combos = itertools.combinations(good_corners, 3)\\n elif len(good_corners) > 1:\\n corner_combos = itertools.combinations(good_corners, 2)\\n\\n best_corner_combo = None\\n best_coef = np.inf\\n for corner_combo in corner_combos:\\n regression = LinearRegression().fit(np.array([corner[0] for corner in corner_combo]).reshape(-1, 1),\\n np.array([corner[1] for corner in corner_combo]))\\n if np.abs(regression.coef_) < best_coef:\\n best_coef = np.abs(regression.coef_)\\n best_corner_combo = np.array([corner[1] for corner in corner_combo])\\n\\n y_edge = int(round(np.mean(best_corner_combo)))\\n edges = edges[y_edge:3000, 200:2200]\\n copied_image_data = copied_image_data[y_edge:2500, 200:2200]\\n trapezoid_data = trapezoid_data[y_edge:2500, 200:2200]\\n\\n # and double-checking the outcome\\n cv2.imshow(\\\"linesEdges\\\", edges)\\n cv2.imshow(\\\"linesDetected\\\", copied_image_data)\\n cv2.imshow(\\\"Contours check\\\", trapezoid_data)\\n cv2.waitKey()\\n cv2.destroyWindow(\\\"Contours check\\\")\\n\\n # find the perimeter of the first closed contour\\n perim = cv2.arcLength(contours[0], True)\\n # setting the precision\\n epsilon = 0.02 * perim\\n # approximating the contour with a polygon\\n approxCorners = cv2.approxPolyDP(contours[0], epsilon, True)\\n # check how many vertices has the approximate polygon\\n approxCornersNumber = len(approxCorners)\\n\\n for corners in approxCorners:\\n cv2.circle(trapezoid_data, (corners[0], corners[1]), radius=10, color=(255, 255, 255), thickness=-1)\\n cv2.imshow(\\\"Vertex position\\\", trapezoid_data)\\n cv2.waitKey()\\n cv2.destroyWindow(\\\"Vertex position\\\")\\n cv2.imshow(\\\"linesEdges\\\", edges)\\n cv2.imshow(\\\"linesDetected\\\", copied_image_data)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\",\n \"def run(self):\\n self.load_template()\\n self.load_data()\\n self.load_files()\\n self.render_content()\\n self.process()\\n # pprint(self.data)\",\n \"def process_data(self, windowed_data):\\n return\",\n \"def process_data(self):\\n\\n self.init_class()\\n self.squirtle.setpos(self.x, self.y)\\n\\n _range = self.data.get(self.quantity_txt)\\n _distance = self.data.get(self.distance_txt)\\n\\n for i in range(1, _range):\\n self.squirtle.pendown()\\n for sides in range(1, 5):\\n self.squirtle.forward(_distance * i*3)\\n self.squirtle.setheading(sides * 90)\\n self.squirtle.penup()\\n self.squirtle.goto(self.x * i*2.5, self.y * i*2.5)\\n \\n self.squirtle.goto(self.x, self.y)\",\n \"def data_process(self):\\n logging.info('Processing the data and split files')\\n lines = Utility.file_len(self.fname)\\n self.lines_to_be, self.split_files = Utility.split_files(self.fname, lines,\\n cpu_count().real)\",\n \"def __init__(self,root):\\n ###\\n #create window to read in the data\\n ###\\n self.popup = tk.Frame(root,width=100,height=20)\\n self.popup.grid(columns=2,rows=3)\\n self.intro = tk.Label(self.popup, text='Enter the path to the A-form data file (usually csv)')\\n self.intro.grid(column=1,row=0,columnspan=2)\\n self.data_file = tk.StringVar() \\n self.docstring = tk.Entry(self.popup, textvariable=self.data_file)\\n self.docstring.grid(column=1,row=2)\\n self.docstring.config(width=75)\\n \\n #set default value for the data file\\n self.data_file.set('./interests.csv')\\n \\n ###\\n #browse button\\n ###\\n self.browse = tk.Button(self.popup, text='Browse', command = self.browse_files_in)\\n self.browse.grid(column=2,row=2)\\n \\n ###\\n #read button\\n ###\\n self.read = tk.Button(self.popup, text='OK', command = self.read_data)\\n self.read.grid(column=1,row=3)\",\n \"def Test(self):\\n\\t\\tself.filename = \\\"NC-Xy_norm_bgsub.txt\\\"\\n\\t\\tself.dirname = \\\"data\\\"\\n\\t\\tself.FileText.SetLabel(\\\"File: \\\"+self.filename)\\n\\t\\t#self.raw_file = self.LoadData(os.path.join(self.dirname, self.filename))\\n\\t\\tself.AddBackgroundCheckBox.SetValue(True)\\n\\t\\tself.combine_data()\\n\\t\\tself.PP_AlgorithmRadio.SetValue(True)\\n\\t\\tself.plot_data()\",\n \"def handle_data(self, data):\\n # Not defined in init due to Python2/Python3 complications.\\n # pylint: disable=attribute-defined-outside-init\\n self._text.append(data)\",\n \"def process(self):\",\n \"def process(self):\",\n \"def process(self):\",\n \"def preprocess(self, data, label):\\n\\t\\traise NotImplementedError\",\n \"def _async_process_data(self):\\n raise NotImplementedError\",\n \"def main():\\n print(\\\"Album Tracker 1.6 - by Yu hui Hua\\\")\\n main_menu()\\n data_file.close()\",\n \"def processor(self, data):\\n streaming_data = self.decoder.decodeData(data)\\n # Add Your code here to process data and handle transport/storage\",\n \"def processor(self, data):\\n streaming_data = self.decoder.decodeData(data)\\n # Add Your code here to process data and handle transport/storage\",\n \"def processor(self, data):\\n streaming_data = self.decoder.decodeData(data)\\n # Add Your code here to process data and handle transport/storage\",\n \"def processor(self, data):\\n streaming_data = self.decoder.decodeData(data)\\n # Add Your code here to process data and handle transport/storage\",\n \"def processor(self, data):\\n streaming_data = self.decoder.decodeData(data)\\n # Add Your code here to process data and handle transport/storage\",\n \"def processor(self, data):\\n streaming_data = self.decoder.decodeData(data)\\n # Add Your code here to process data and handle transport/storage\",\n \"def process(self):\\n self.extract()\\n self.transform()\\n self.load()\",\n \"def handle_data(self, data):\\n\\n # Medium export files have a footer with junk that's not part of the original post.\\n # Stop processing entirely if we hit the document footer.\\n if self.seen_footer:\\n return\\n\\n # If this text is part of an image caption, slap that caption on the last Image card so the caption\\n # ends up in the right place and bail out.\\n if \\\"figcaption\\\" in self.tag_stack:\\n self.cards[-1][1][\\\"caption\\\"] = data\\n return\\n\\n # If we are nested inside a <pre>, we are dealing with code content. Just append it to the current code\\n # card and bail.\\n if \\\"pre\\\" in self.tag_stack:\\n self.cards[-1][1][\\\"code\\\"] += data\\n return\\n\\n # If we got this fair, we have regular HTML text that may or may not be nested inside a <strong>, <em>, etc tag.\\n # In Mobiledoc, the easiest way to to annotate each text string with all the formats (strong, em) etc that apply\\n # to it.\\n # So let's loop through the html tag stack and see all the formatting tags that apply to this piece of text.\\n markups_for_data = []\\n markup_count = 0\\n\\n body = []\\n if \\\"a\\\" in self.tag_stack:\\n markups_for_data.append(len(self.markups) - 1)\\n markup_count += 1\\n if \\\"em\\\" in self.tag_stack:\\n markups_for_data.append(0)\\n markup_count += 1\\n if \\\"strong\\\" in self.tag_stack:\\n markups_for_data.append(1)\\n markup_count += 1\\n\\n # Finally, generate a Mobiledoc tag containing the text and all the formatting tags that apply to it.\\n body = [0, markups_for_data, markup_count, data]\\n\\n self.current_markers.append(body)\",\n \"def handle(self, rawdata):\\r\\n\\r\\n return self.__filter(self.__handler(rawdata))\",\n \"def load_data(self) -> None:\",\n \"def _process(self):\\n self.kwargs[\\\"collect\\\"].process_scan_form_data(self.kwargs[\\\"data\\\"])\",\n \"def _extract_data(self, *args, **kwargs) -> None:\\n raise NotImplementedError\",\n \"def process(self, data) :\\n rData = Core.Processlib.Data()\\n rData.frameNumber = data.frameNumber\\n rData.buffer = self._worker.process(data.buffer)\\n if self._writer: #optional HDF5 writer\\n self._writer.write(rData.buffer, rData.frameNumber)\",\n \"def parse(self, data):\\n raise NotImplementedError\",\n \"def process(self):\\n parser = csv.reader(self.reader,delimiter=self.delimiter_DIC[self.delim])\\n firstRec = True\\n for fields in parser:\\n if firstRec:\\n fieldNames = fields\\n firstRec = False\\n else:\\n self.dicts.append({})\\n for i,f in enumerate(fields):\\n try:\\n self.dicts[-1][fieldNames[i]] = f\\n except:\\n import pdb\\n pdb.set_trace()\\n if self.eng is \\\"spectrumMill\\\":\\n for i,row in enumerate(self.dicts):\\n fileSM = row[self.engine[self.eng][0]]\\n acNoSM = row[self.engine[self.eng][1]]\\n masSM=row[self.engine[self.eng][2]]\\n chrgeSM=row[self.engine[self.eng][3]]\\n preAmSM=row[self.engine[self.eng][4]].replace('(','').replace(')','')\\n pepSM=row[self.engine[self.eng][5]]\\n nAmSM=row[self.engine[self.eng][6]].replace('(','').replace(')','')\\n modSM=row[self.engine[self.eng][7]].split('\\\\s')+row[self.engine[self.eng][8]].split('\\\\s')\\n modLis = [mod.strip() for mod in modSM if mod!=' ']\\n modSM = ';'.join(modLis)\\n scoreSM=row[self.engine[self.eng][9]]\\n descrimentSM=row[self.engine[self.eng][10]]\\n if modSM !='':\\n modPepInHupaFormat=self.modTermDic.spectrumMill(preAmSM,pepSM,nAmSM,modSM,self.eng)\\n parsedData=acNoSM+'\\\\t'+masSM+'\\\\t'+chrgeSM+'\\\\t'+modPepInHupaFormat+'\\\\t'+scoreSM+'\\\\n'\\n data = self.mapCaller(parsedData,self.eng)\\n #print >>self.writer,data\\n else:\\n parsedData=acNoSM+'\\\\t'+masSM+'\\\\t'+chrgeSM+'\\\\t'+preAmSM+'.'+pepSM+'.'+nAmSM+'\\\\t'+'-'+'\\\\t'+scoreSM+'\\\\n'\\n data = self.mapCaller(parsedData,self.eng)\\n #print >>self.writer,data\\n\\n if self.eng is \\\"mascot\\\":\\n \\\"\\\"\\\"\\n In Mascot, under every gi (protein) corresponding peptide information will be there\\n \\\"\\\"\\\"\\n giFound=True\\n for i,row in enumerate(self.dicts):\\n if row[self.engine[self.eng][0]]!='':\\n giAsKey = row[self.engine[self.eng][0]]\\n giFound=False\\n if giFound==False:\\n massM=row[self.engine[self.eng][1]]\\n chargeM=row[self.engine[self.eng][2]]\\n preAmM=row[self.engine[self.eng][3]]\\n pepM=row[self.engine[self.eng][4]]\\n nAmM = row[self.engine[self.eng][5]]\\n modM=row[self.engine[self.eng][6]]\\n modSiteM=row[self.engine[self.eng][7]]\\n scoreM=row[self.engine[self.eng][8]]\\n evalM=row[self.engine[self.eng][9]]\\n if modM !='':\\n \\\"\\\"\\\"\\n modificationFormat from modification.py creates a MASTER_UNIMOD dictionary \\n Where all modifications of unimod would be available. \\n At same time formatMod function in modificationFormat class would convert modification format \\\"\\\"\\\"\\n modPepInHupaFormat=self.modTermDic.mascot(preAmM,pepM,nAmM,modSiteM,modM,self.eng)\\n parsedData=giAsKey+'\\\\t'+massM+'\\\\t'+chargeM+'\\\\t'+modPepInHupaFormat+'\\\\t'+scoreM+'\\\\n'\\n data=self.mapCaller(parsedData,self.eng)\\n #print >>self.writer,data\\n else:\\n \\n parsedData=giAsKey+'\\\\t'+massM+'\\\\t'+chargeM+'\\\\t'+preAmM+'.'+pepM+'.'+nAmM+'\\\\t'+'-'+'\\\\t'+scoreM+'\\\\n'\\n data=self.mapCaller(parsedData,self.eng)\\n #print >>self.writer,data\\n\\n if self.eng is \\\"inspect\\\":\\n \\\"\\\"\\\"\\n InSpect does not have mass information in TSV file\\n So we need to fetch it from spectrum file (this is not yet done)\\n \\\"\\\"\\\"\\n for i,row in enumerate(self.dicts):\\n data = row[self.engine[self.eng][0]]+'\\\\t'+row[self.engine[self.eng][1]]+'\\\\t'+row[self.engine[self.eng][2]]+'\\\\t'+row[self.engine[self.eng][3]]+'\\\\t'+row[self.engine[self.eng][4]]+'\\\\t'+row[self.engine[self.eng][5]]+'\\\\n'\\n #return data\\n #data = self.mapCaller(data)\\n #self.writer.write(data)\\n\\n if self.eng is \\\"omssa\\\":\\n #OMSSA csv doesnot contain start and last residue of the peptide, instead contains position. So start and last residue need to fetch from protein sequence\\n for i,row in enumerate(self.dicts):\\n giO = row[self.engine[self.eng][6]]\\n massO= row[self.engine[self.eng][5]]\\n chargeO=row[self.engine[self.eng][8]]\\n preAmO = row[self.engine[self.eng][1]]#position in protein\\n pepO = row[self.engine[self.eng][2]]\\n nextAmO = row[self.engine[self.eng][3]] #position in protein\\n scoreO= row[self.engine[self.eng][4]]\\n modO=row[self.engine[self.eng][7]]\\n if modO !='':\\n #parsedData=giO+'#'+massO+'#'+chargeO+'#'+preAmO+'.'+pepO+'.'+nextAmO+'#'+modO+'#'+scoreO\\n modPepInHupaFormat=self.modTermDic.omssa(preAmO,pepO,nextAmO,modO,self.eng)\\n parsedData=giO+'\\\\t'+massO+'\\\\t'+chargeO+'\\\\t'+modPepInHupaFormat+'\\\\t'+scoreO+'\\\\n'\\n self.mapCaller(parsedData,self.eng)\\n else:\\n parsedData=giO+'\\\\t'+massO+'\\\\t'+chargeO+'\\\\t'+preAmO+'.'+pepO+'.'+nextAmO+'\\\\t'+'-'+'\\\\t'+scoreO+'\\\\n'\\n self.mapCaller(parsedData,self.eng)\",\n \"def prepareData(self, *data):\\n arguments = 8\\n (self.X, self.X_name, self.Y, self.Y_name, self.alignment,\\n self.model, self.annotations, self.args) = tuple(data[:arguments])\\n \\n self.width = self.args.beam_width\\n self.mathType = self.args.mathType\\n self.io_files = {\\n 'input': self.args.intermediate_input_files,\\n 'output': self.args.intermediate_output_files\\n }\\n self.repeat_width = self.args.repeat_width\\n self.cons_count = self.args.cons_count\\n self.posterior_processors = self.args.posterior_processors \\n\\n self.positionGenerator = \\\\\\n list(AlignmentBeamGenerator(self.alignment, self.width))\\n \\n for i in range(len(self.model.states)):\\n self.model.states[i].computeHints(self)\\n\\n return data[arguments:]\",\n \"def loadPreviewData(self):\\n # parameters for data load from GUI\\n self.loadDataModel.pathToDataSet = self.entryPath.get()\\n self.loadDataModel.firstRowIsTitle = bool(self.checkVarRow.get())\\n self.loadDataModel.firstColIsRowNbr = bool(self.checkVarCol.get())\\n # if entry field is empty, set nbrOfCategories to 0\\n if len(self.entrytrainRowNbr.get()) == 0: # Code for this line from: https://stackoverflow.com/questions/15455113/tkinter-check-if-entry-box-is-empty\\n self.loadDataModel.trainRowNumber = 0\\n else:\\n self.loadDataModel.trainRowNumber = int(self.entrytrainRowNbr.get())\\n # if entry field is empty, set nbrOfCategories to 0\\n if len(\\n self.entryNbrCategories.get()) == 0: # Code for this line from: https://stackoverflow.com/questions/15455113/tkinter-check-if-entry-box-is-empty\\n self.loadDataModel.nbrOfCategories = 0\\n else:\\n self.loadDataModel.nbrOfCategories = int(self.entryNbrCategories.get())\\n self.loadDataModel.dataIsForTraining = True\\n\\n # Load data\\n try:\\n self.loadDataModel.loadData()\\n print(\\\"LoadDataView: self.loadDataModel.data: \\\", self.loadDataModel.data)\\n except FileNotFoundError:\\n tk.messagebox.showerror(\\\"Error\\\", \\\" File not found.\\\")\\n except ValueError:\\n tk.messagebox.showerror(\\\"Error\\\", \\\"The number of categories entered is incorrect. Enter number > 0 and smaller\\\"\\n \\\" the number of columns in the dataset.\\\")\\n except:\\n print(\\\"Load data failed because of something different than nbrOfCategories entered or file not found.\\\")\\n else: # if data load worked do the following\\n self.loadDataInformation.config(text=\\\"Data has been successfully loaded and stored.\\\", fg=\\\"green\\\")\\n self.previewData()\",\n \"def main():\\n df_data = import_clean_process()\\n plot_data_matplotlib(df_data)\\n return\",\n \"def run(self):\\r\\n self.collect_data()\",\n \"def processData(self,data_file,directory,comment = '',way='mpcc',opt=[1024]):\\n self.dirs = [name for name in os.listdir(directory)\\n if os.path.isdir(os.path.join(directory, name))]\\n\\n # directory names are names of instruments\\n #self.dirs =\\n # ['cel', 'cla', 'flu', 'gac', 'gel', 'org', 'pia', 'sax', 'tru', 'vio', 'voi']\\n self.dirs = [name for name in os.listdir(directory)\\n if os.path.isdir(os.path.join(directory, name))]\\n \\n # example: self.files['sax'] =\\n # IRMAS-TrainingData\\\\sax\\\\006__[sax][nod][cla]1686__1.wav\\n self.files = {}\\n for d in self.dirs:\\n self.files[d] = [] \\n sub_dir = os.path.join(directory, d)\\n for filename in glob.glob(os.path.join(sub_dir, '*.wav')):\\n self.files[d].append(filename)\\n\\n # Ex) self.output['cel']: np.array([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\\n i = 0\\n for name in self.dirs:\\n temp = []\\n for j in range(len(self.dirs)):\\n if i == j:\\n temp.append(1)\\n else:\\n temp.append(0)\\n self.output[name] = np.array(temp)\\n i +=1\\n\\n #self.X = [] # list of input vectors\\n #self.Y = [] # list of output vectors\\n t0 = time.time()\\n for name in self.dirs:\\n t1 = time.time()\\n for file in self.files[name]:\\n #input_vector = processFile(file,length=length1,q=q1,fs_in=fs_in1,divide=divide1,plot = False)\\n if way == 'mpcc':\\n input_vector = processMPCC(file,*opt)\\n elif way == 'fft':\\n input_vector = processFFT(file,*opt)\\n else:\\n raise ValueError('Invalid Way, valid types include: \\\\'mpcc\\\\' or \\\\'fft\\\\'')\\n if input_vector != 'failed':\\n self.X.append(input_vector)\\n self.Y.append(self.output[name])\\n print('Time take to process '+str(name)+ ': ' + str((time.time()-t1)/60)[0:4] + ' min.')\\n print('Total Processing Time: ' + str((time.time()-t0)/60)[0:4] + ' min.')\\n\\n # Now we can store all of the data in a json\\n # Need to store self.X, self.Y, self.dirs,self.output,self.files,self.data\\n # self.dirs is a list of strings -> fine\\n # self.files is a dict() with string:string -> fine\\n # self.output is a dict() with string:np.array\\n output = {}\\n for d in self.output:\\n out_list = []\\n for value in self.output[d]:\\n out_list.append(int(value))\\n output[d] = out_list # -> fine\\n #self.X is a list of np.arrays\\n X = []\\n for i in range(len(self.X)):\\n x = []\\n for ele in self.X[i]:\\n x.append(float(ele))\\n X.append(x) # -> fine\\n #self.Y is a list of np.arrays\\n Y = []\\n for i in range(len(self.Y)):\\n y = []\\n for ele in self.Y[i]:\\n y.append(float(ele))\\n Y.append(y) # -> fine\\n \\n store = {}\\n store['dirs'] = self.dirs # good\\n store['output'] = output # good\\n store['files'] = self.files # good\\n store['X'] = X # good\\n store['Y'] = Y # good\\n store['comment'] = comment\\n with open(data_file, 'w') as outfile:\\n json.dump(store, outfile)\\n print('Preprocessed data stored in ' + str(data_file))\\n return\",\n \"def read(self, handler_name, rawdata):\\r\\n\\r\\n if handler_name in self.__events:\\r\\n data = self.__events[handler_name].handle(rawdata)\\r\\n if data.toflow() is not None:\\r\\n self.__to_flow.send(data.toflow())\\r\\n if data.todata() is not None:\\r\\n self.__to_data.send(data.todata())\\r\\n if data.toui() is not None:\\r\\n self.__to_ui.send(data.toui())\\r\\n else:\\r\\n raise MGPError('InputArea.read(): Tried to read for non-existing name \\\"{}\\\".'\\r\\n .format(handler_name))\",\n \"def process(\\n self,\\n makeGlyphs=True,\\n makeKerning=True,\\n makeInfo=True,\\n bendLocations=False,\\n ):\\n if self.logger:\\n self.logger.info(\\\"Reading %s\\\", self.path)\\n self.readInstances(\\n makeGlyphs=makeGlyphs,\\n makeKerning=makeKerning,\\n makeInfo=makeInfo,\\n bendLocations=bendLocations,\\n )\\n self.reportProgress(\\\"done\\\", 'stop')\",\n \"def process(self):\\n # check already processed\\n proc_dir = os.path.join(self.root, self.processed_dir)\\n train_path = os.path.join(proc_dir, self.train_fn)\\n test_path = os.path.join(proc_dir, self.test_fn)\\n if os.path.exists(train_path) and os.path.exists(test_path):\\n # already exists => load process file\\n print(\\\"processed dataset already exists; load it\\\")\\n self.train_data = torch.load(train_path)\\n self.test_data = torch.load(test_path)\\n return\\n\\n # read and process raw data\\n print(\\\"read and process raw dataset ...\\\")\\n label_path = os.path.join(self.root, self.raw_dir, \\\"labels.txt\\\")\\n image_path_format = os.path.join(self.root, self.raw_dir, \\\"img_{}.png\\\")\\n \\n with open(label_path) as f:\\n for line in f:\\n if not line.strip():\\n break\\n \\n idx, label = map(int, line.strip().split('\\\\t'))\\n image_path = image_path_format.format(idx)\\n image = load_image(image_path)\\n \\n if idx <= self.split:\\n self.train_data.append((image, label))\\n elif idx > self.split:\\n self.test_data.append((image, label))\\n\\n # write processed file\\n if not os.path.exists(proc_dir):\\n os.mkdir(proc_dir)\\n\\n with open(train_path, 'wb') as f:\\n torch.save(self.train_data, f)\\n with open(test_path, 'wb') as f:\\n torch.save(self.test_data, f)\\n\\n print(\\\"Done!\\\")\",\n \"def main():\\n Tkinter.Tk().withdraw()\\n try:\\n #Ask user for the file and open the file in read mode\\n file=tkFileDialog.askopenfile()\\n\\n try:\\n #Read the file, split contents by lines, then split lines into words using \\\",\\\" as separator and\\n # use the words to create carEvaluation object\\n carevaluation_list=[CarEvaluation(*lines.split(\\\",\\\")) for lines in file.read().splitlines()]\\n process_records(carevaluation_list)\\n except Exception, e:\\n print \\\"Error: Parsing file. Terminating the program! \\\" + str(e)\\n sys.exit(e)\\n finally:\\n file.close()\\n except Exception, e:\\n print \\\"Error: Could not open the file to read. Terminating the program! \\\" + str(e)\\n sys.exit(e)\",\n \"def process_input(data):\\n if data == \\\"NAME\\\":\\n return get_name()\\n \\n elif data == \\\"SHIP PLACEMENT\\\":\\n return get_ship_placements()\\n \\n elif data == \\\"SHOT LOCATION\\\":\\n return get_shot_location()\\n \\n elif data == \\\"MISS\\\":\\n MY_SHOTS[LAST_SHOT[0]][LAST_SHOT[1]] = data\\n \\n elif data == \\\"HIT\\\":\\n MY_SHOTS[LAST_SHOT[0]][LAST_SHOT[1]] = data\\n \\n elif data[:4] == \\\"SUNK\\\":\\n MY_SHOTS[LAST_SHOT[0]][LAST_SHOT[1]] = data\\n \\n elif data[:13] == \\\"OPPONENT SHOT\\\":\\n tokens = data[14:].split(\\\",\\\")\\n OPPONENT_SHOTS.append((int(tokens[0]), int(tokens[1]), tokens[2]))\\n \\n elif data == \\\"WIN\\\":\\n return False\\n \\n elif data == \\\"LOSE\\\":\\n return False\\n \\n elif data == \\\"ERROR\\\":\\n return False\\n \\n return None\",\n \"def prepare_data(self):\",\n \"def load_data(self):\",\n \"def processData(self, rawData, queryMeta=None):\\n\\t\\treturn self.service.run(self, rawData, queryMeta)\",\n \"def __init__(self,gui:bool=True):\\n\\t\\t#TODO CHANGES.TXT, study standard format\\n #TODO add INSTALLING\\n self.LOG_FORMAT=\\\"%(levelname)s %(asctime)s %(pathname)s at %(lineno)s - %(message)s\\\"\\n logging.basicConfig(filename='readTobiiGlasses.log',\\n level=logging.DEBUG,\\n format=self.LOG_FORMAT)\\n self.logger=logging.getLogger()\\n\\n\\n self.logger.debug('creating tk root..')\\n self.root = Tk()\\n self.root.geometry('640x400')\\n self.root.title('Read Tobii Glasses')\\n\\n self.rootMenu = Menu(self.root)\\n self.root.config(menu=self.rootMenu)\\n\\n\\n self.logger.debug('creating report and status widgets...')\\n self.status = Label(self.root, bd=1, relief=RIDGE, anchor=W)\\n self.status.config(text='Please select settings or batch file.')\\n self.status.pack(side=BOTTOM,fill=X)\\n\\n self.report=Text(self.root, bg='lightgray', relief=SUNKEN, wrap=WORD)\\n self.report.insert('0.0',datetime.now().strftime('%Y-%m-%d') + '\\\\n')\\n self.appendReport('ReadTobiiGlasses started.')\\n self.report.pack(side=LEFT,anchor=NW,fill=BOTH)\\n\\n\\n #setup other classes\\n self.logger.debug('instantiating classes...')\\n self.settingsReader = SettingsReader(self)\\n self.multiData = MultiData(self)\\n self.pivotData = PivotData(self)\\n self.dataReader = DataReader(self)\\n self.dataExporter = DataExporter(self)\\n\\n self.stats = Stats(self)\\n self.stubPlot = StubPlot(self)\\n self.tempoPlot = TempoPlot(self)\\n self.spatialPlot = SpatialPlot(self)\\n self.combiPlot = CombiPlot(self)\\n\\n self.logger.debug('populating menus...')\\n #populate menu\\n settingsMenu = Menu(self.rootMenu, tearoff=0)\\n settingsMenu.add_command(label=\\\"Select...\\\", command=self.settingsReader.select)\\n settingsMenu.add_command(label=\\\"Modify in external editor\\\", command=self.settingsReader.open)\\n settingsMenu.add_command(label=\\\"Run batch and pivot tables...\\\", command=lambda: self.settingsReader.selectBatch(self.pivotData,self.stats))\\n self.rootMenu.add_cascade(label=\\\"Settings\\\", menu=settingsMenu)\\n\\n dataMenu = Menu(self.rootMenu, tearoff=0)\\n dataMenu.add_command(label=\\\"Parse settings and read data\\\", command=lambda: self.dataReader.read(self.settingsReader,self.multiData))\\n dataMenu.add_command(label=\\\"Summary and validation\\\", command=self.multiData.validate)\\n dataMenu.add_command(label=\\\"Standartization\\\", command=lambda: self.setStatus('Not implemented.'))\\n exportMenu = Menu(dataMenu, tearoff=0)\\n exportMenu.add_command(label=\\\"Fixations/saccades to Excel\\\", command=lambda: self.dataExporter.exportFixations(self.multiData,'xls'))\\n exportMenu.add_command(label=\\\"Fixations/saccades to CSV\\\", command=lambda: self.dataExporter.exportFixations(self.multiData,'csv'))\\n exportMenu.add_command(label=\\\"Gyroscope data\\\", command=lambda: self.dataExporter.exportGyro(self.multiData))\\n exportMenu.add_command(label=\\\"Voc/ocul combined\\\", command=lambda: self.setStatus('Not implemented.'))\\n dataMenu.add_cascade(label=\\\"Export\\\", menu=exportMenu)\\n self.rootMenu.add_cascade(label=\\\"Data\\\", menu=dataMenu)\\n\\n statsMenu = Menu(self.rootMenu, tearoff=0)\\n statsMenu.add_command(label=\\\"Descriptive\\\", command=lambda: self.stats.descriptive(self.multiData))\\n statsMenu.add_command(label=\\\"Difference\\\", command=lambda: self.stats.difference(self.pivotData))\\n statsMenu.add_command(label=\\\"Variance\\\", command=lambda: self.setStatus('Not implemented.'))\\n # экспортируем и сразу открываем\\n # statsMenu.add_command(label=\\\"Save report to Excel\\\", command=self.stats.save)\\n self.rootMenu.add_cascade(label=\\\"Statistics\\\", menu=statsMenu)\\n\\n vizMenu = Menu(self.rootMenu, tearoff=0)\\n plotMenu = Menu(vizMenu, tearoff=0)\\n plotMenu.add_command(label=\\\"Temporal\\\", command=lambda: self.tempoPlot.draw(self.multiData))\\n plotMenu.add_command(label=\\\"Spatial\\\", command=lambda: self.spatialPlot.draw(self.multiData))\\n plotMenu.add_command(label=\\\"Combined\\\", command=lambda: self.combiPlot.draw(self.multiData))\\n vizMenu.add_cascade(label=\\\"Plots\\\", menu=plotMenu)\\n distrMenu = Menu(vizMenu, tearoff=0)\\n distrMenu.add_command(label=\\\"Histogram\\\", command=self.stubPlot.draw)\\n distrMenu.add_command(label=\\\"Density\\\", command=self.stubPlot.draw)\\n distrMenu.add_command(label=\\\"Cumulative\\\", command=self.stubPlot.draw)\\n distrMenu.add_command(label=\\\"Spectrogram\\\", command=self.stubPlot.draw)\\n vizMenu.add_cascade(label=\\\"Distribution\\\", menu=distrMenu)\\n vizMenu.add_command(label=\\\"Gaze overlay animation\\\", command=self.stubPlot.draw)\\n vizMenu.add_command(label=\\\"3D gaze vectors\\\", command=self.stubPlot.draw)\\n vizMenu.add_command(label=\\\"Heatmap\\\", command=self.stubPlot.draw)\\n vizMenu.add_command(label=\\\"Distance matrix\\\", command=self.stubPlot.draw)\\n self.rootMenu.add_cascade(label=\\\"Visualizations\\\", menu=vizMenu)\\n\\n helpMenu = Menu(self.rootMenu, tearoff=0)\\n manualsMenu = Menu(helpMenu, tearoff=0)\\n manualsMenu.add_command(label=\\\"Tobii gyroscope data format\\\", command=lambda: self.gotoWeb('glasses2API'))\\n manualsMenu.add_command(label=\\\"Tobii coordinate systems\\\", command=lambda: self.gotoWeb('coordSys'))\\n helpMenu.add_cascade(label=\\\"Manuals\\\", menu=manualsMenu)\\n helpMenu.add_command(label=\\\"Repository\\\", command=lambda: self.gotoWeb('repo'))\\n helpMenu.add_command(label=\\\"Wiki\\\", command=lambda: self.gotoWeb('wiki'))\\n self.rootMenu.add_cascade(label=\\\"Help\\\", menu=helpMenu)\\n\\n self.logger.debug('starting tk main loop...')\\n if gui:\\n self.root.mainloop()\",\n \"def main():\\r\\n conn = psycopg2.connect(\\\"host=127.0.0.1 dbname=sparkifydb2 user=postgres password=261998\\\")\\r\\n cur = conn.cursor()\\r\\n\\r\\n process_data(cur, conn, filepath='C:/Users/AG/Downloads/Data-engineering-nanodegree-master/Data-engineering-nanodegree-master/1_dend_data_modeling/P1_Postgres_Data_Modeling_and_ETL/data/song_data', func=process_song_file)\\r\\n process_data(cur, conn, filepath='C:/Users/AG/Downloads/Data-engineering-nanodegree-master/Data-engineering-nanodegree-master/1_dend_data_modeling/P1_Postgres_Data_Modeling_and_ETL/data/log_data', func=process_log_file)\\r\\n\\r\\n conn.close()\",\n \"def execute_event(self):\\n try:\\n with open(self._import_path_input.get(), 'r') as \\\\\\n raw_data_file, \\\\\\n open(self._export_path_input.get(),\\n 'w', newline='') as processed_data_file:\\n\\n # all situation counter\\n count_true = 0\\n count_false = 0\\n count_tag = 0\\n count_not_found = 0\\n\\n # get the user input api(url)\\n original_url = self._url_input.get()\\n\\n # true/false and tag/NotFound flags\\n flag_true_false = False\\n flag_tag_notfound = False\\n\\n # set the flag\\n temp_line = raw_data_file.readline().strip().strip('\\\\r\\\\n')\\n temp_clean_url = original_url[:-8] + temp_line\\n temp_response = self.api_dealer(temp_clean_url)\\n if temp_response == 't' or temp_response == 'f':\\n flag_true_false = True\\n else:\\n flag_tag_notfound = True\\n\\n # process the file\\n for line in raw_data_file:\\n clean_line = line.strip().strip('\\\\r\\\\n')\\n if clean_line == '':\\n tk.messagebox.showinfo('info', 'end of file or '\\n 'unexpected newline in '\\n 'the end')\\n break\\n # get rid of the '<target>' ending of the original url\\n # and combine with the real target\\n clean_url = original_url[:-8] + clean_line\\n response = self.api_dealer(clean_url)\\n\\n # deal with different kinds of output and update the counter\\n if response == 't':\\n count_true += 1\\n elif response == 'f':\\n count_false += 1\\n elif response == 'Not Found':\\n count_not_found += 1\\n else:\\n count_tag += 1\\n\\n # create the output row and write to file\\n output_row = clean_line + ' ' + response + '\\\\r\\\\n'\\n processed_data_file.write(output_row)\\n\\n # now output the ratio\\n if flag_true_false:\\n self._ratio_var.set(str(count_true) + '/' + str(\\n count_true + count_false))\\n elif flag_tag_notfound:\\n self._ratio_var.set(str(count_tag) + '/' + str(count_tag\\n + count_not_found))\\n\\n tk.messagebox.showinfo('message', 'job done! have a nice day!')\\n\\n except Exception as e:\\n tk.messagebox.showerror('error', e)\",\n \"def process(self):\\n\\n # validate processing\\n if self.is_acceptable():\\n # handle data and write log\\n self.handle()\",\n \"def handle_mouse_data(data):\\n pass\",\n \"def execute_event(self):\\n # step1: process the tag file and produce the tag dictionary\\n try:\\n tag_dict = self.tag_file_process(self._tag_file_input.get())\\n except Exception as e:\\n tk.messagebox.showerror('error', e)\\n\\n # step2: load the result csv file and the writing file\\n try:\\n with open(self._import_path_input.get(), 'r', encoding='utf-8') as raw_data_file, \\\\\\n open(self._export_path_input.get(), 'w', encoding='utf-8-sig', newline='') as \\\\\\n processed_data_file:\\n # to solved the chinese character output but it does not work\\n # as expected\\n #processed_data_file.write(codecs.BOM_UTF8)\\n reader = csv.reader(raw_data_file)\\n writer = csv.writer(processed_data_file, dialect='excel')\\n rows = []\\n for row in reader:\\n row[0] = row[0].encode('utf-8').decode('utf-8-sig')\\n rows.append(row)\\n\\n # now transform the row list to column list\\n columns = self.row_to_column_helper(len(rows[0]), rows)\\n\\n # now process all the columns and translate all tags\\n # do modifications directly on the columns list\\n self.tag_translator(tag_dict, columns)\\n\\n # now transfer the columns back to rows\\n output_rows = self.column_to_row_helper(columns)\\n\\n # write each row back to the csv file\\n writer.writerows(output_rows)\\n\\n tk.messagebox.showinfo('Good News', 'Job Done!')\\n\\n except Exception as e:\\n tk.messagebox.showerror('error', e)\",\n \"def run(self):\\n\\n argsdict = self.collect_users_input()\\n cmd = 'python3 ./widgets/tools/polygonize.py ' + argsdict['rasterpath']+ argsdict['labels']+ argsdict['shapefile_path']+ argsdict['layer_name'] + argsdict['class_name'] + argsdict['idfield'] +argsdict['lstcostumelabels']\\n self.process.cmd = cmd\\n self.process.start_process2()\\n newlayer= argsdict['layerfullpath']\\n #self.process.process.finished.connect(lambda: self.legendwidget.add_to_canvas([newlayer]))\\n self.process.process.finished.connect(lambda: self.load_results(newlayer))\",\n \"def _load_general_data_page(self):\\r\\n\\r\\n # Load the editable gtk.Widgets().\\r\\n self.txtCode.handler_block(self._lst_handler_id[0])\\r\\n self.txtCode.set_text(str(self._function_model.function_code))\\r\\n self.txtCode.handler_unblock(self._lst_handler_id[0])\\r\\n\\r\\n _textview = self.txtName.get_child().get_child()\\r\\n _textview.handler_block(self._lst_handler_id[1])\\r\\n _textbuffer = _textview.get_buffer()\\r\\n _textbuffer.set_text(self._function_model.name)\\r\\n _textview.handler_unblock(self._lst_handler_id[1])\\r\\n\\r\\n _textview = self.txtRemarks.get_child().get_child()\\r\\n _textview.handler_block(self._lst_handler_id[2])\\r\\n _textbuffer = _textview.get_buffer()\\r\\n _textbuffer.set_text(self._function_model.remarks)\\r\\n _textview.handler_unblock(self._lst_handler_id[2])\\r\\n\\r\\n # Load the non-editable gtk.Widgets().\\r\\n self.txtTotalCost.set_text(\\r\\n str(locale.currency(self._function_model.cost)))\\r\\n self.txtModeCount.set_text(\\r\\n str('{0:d}'.format(self._function_model.n_modes)))\\r\\n self.txtPartCount.set_text(\\r\\n str('{0:d}'.format(self._function_model.n_parts)))\\r\\n\\r\\n return False\",\n \"def _process(self):\\n self.output[\\\"data\\\"] = get_form_data(self.kwargs[\\\"collect\\\"].ona_scan_form_pk)\",\n \"def handle_data(self, data):\\n if len(data.strip()) > 0:\\n self.table += data\\n # print(data, end=\\\" \\\")\",\n \"def preProcess(self, datum):\\n pass\",\n \"def callback_dat(fd_):\\n # receive data\\n data = os.read(fd_, 8)\\n if data == '':\\n return\\n data, = struct.unpack('<Q', data)\\n # TODO: Interpret data\",\n \"def parse_data(fp):\\n pass\",\n \"def __call__(self,data):\\n\\n log.debug('got data: %s' % (len(data)))\\n\\n # if we don't have args yet, these must be them\\n if not self.args:\\n self.parse_args(data)\\n\\n else:\\n # we've already got args, must\\n # be a message\\n self.handle_send(data)\",\n \"def recive_data(self):\\n # read all available data\\n while self.ser.inWaiting() > self.INPUT_DATA_SIZE+1:\\n data = array.array('c')\\n # search the header\\n data.append(self.ser.read(1))\\n while data[0] != chr(1):\\n data[0] = self.ser.read(1)\\n \\n # wait for all available data\\n while self.ser.inWaiting() < (self.INPUT_DATA_SIZE-1):\\n time.sleep(0.03);\\n \\n # recives data\\n data = self.ser.read(self.INPUT_DATA_SIZE-1)\\n \\n # prove if you want graphical data\\n if self.pushButton_monitor.isChecked():\\n # decodes the data\\n t = struct.unpack('I', data[3]+data[2]+data[1]+data[0])\\n r = struct.unpack('f', data[4]+data[5]+data[6]+data[7])\\n x0 = struct.unpack('f', data[8]+data[9]+data[10]+data[11])\\n x1 = struct.unpack('f', data[12]+data[13]+data[14]+data[15])\\n u = struct.unpack('f', data[16]+data[17]+data[18]+data[19])\\n \\n self.time = t[0]*25e-9\\n \\n # prepare the string output\\n aux_str = \\\" t = \\\"+str(self.time)+\\\"\\\\t\\\"\\n aux_str += \\\" r = \\\"+str(r[0])+\\\"\\\\t\\\"\\n aux_str += \\\" u = \\\"+str(u[0])+\\\"\\\\t\\\"\\n aux_str += \\\" x1 = \\\"+str(x1[0])+\\\"\\\\t\\\"\\n aux_str += \\\" x0 = \\\"+str(x0[0])+\\\"\\\\n\\\"\\n # print string output\\n self.textBrowser.insertPlainText(aux_str)\\n \\n # append data to the arrays\\n self.graf_t.append(self.time)\\n self.graf_r.append(r[0])\\n self.graf_x0.append(x0[0])\\n self.graf_x1.append(x1[0])\\n self.graf_u.append(u[0])\\n \\n # remove one value if the arrays have maximum length\\n if self.graf_t.buffer_info()[1] >= NUM_SAMPLES:\\n self.graf_t.pop(0)\\n self.graf_r.pop(0)\\n self.graf_x0.pop(0)\\n self.graf_x1.pop(0)\\n self.graf_u.pop(0)\\n \\n # reload number of samples lavel\\n self.label_samples_value.setText(str(self.graf_t.buffer_info()[1]))\\n # reload number of waiting chars in serial rx buffer\\n self.label_rx_buff_value.setText(str(self.ser.inWaiting()))\\n\\n # reload mutex area\\n self.updated_data = 1\\n \\n # prove if there are available id's\\n if (self.actionPC_Monitor.isChecked() and data[20] == chr(2)):\\n # if it is true, looks how much id's\\n i = struct.unpack('B', data[21])\\n\\n if i[0] < STACK_SIZE:\\n for z in range(i[0]):\\n new_device = struct.unpack('B', data[z+22])\\n new_string = str(new_device[0])\\n \\n llista = self.listWidget_link.findItems(new_string, QtCore.Qt.MatchExactly)\\n if len(llista) == 0:\\n self.listWidget_link.addItem(new_string)\",\n \"def processData(args):\\n inputfile=args.inputfile\\n threshold=args.threshold\\n mask_file=args.maskfile\\n crop=args.crop\\n voxelsize=args.voxelsize\\n binaryClosing=args.binaryclosing\\n binaryOpening=args.binaryopening\\n vtfile=args.vtfile\\n vt2esofspy=args.vt2esofspy\\n output_report_csv_file=args.output_report_csv_file\\n \\n # Reading/Generating data\\n if inputfile is None: # # Using generated sample data\\n logger.info('Generating sample data...')\\n metadata = {'voxelsize_mm': [1, 1, 1]}\\n data3d = generate_sample_data(1, 0, 0)\\n else: # Normal runtime\\n dr = datareader.DataReader()\\n data3d, metadata = dr.Get3DData(inputfile)\\n\\n # Custom voxel size\\n if voxelsize is not None:\\n metadata['voxelsize_mm'] = voxelsize\\n\\n # Crop data\\n if crop is not None:\\n logger.debug('Croping data: %s', str(crop))\\n data3d = data3d[crop[0]:crop[1], crop[2]:crop[3], crop[4]:crop[5]].copy()\\n\\n # Init HistologyAnalyser object\\n logger.debug('Init HistologyAnalyser object')\\n ha = HistologyAnalyser(data3d, metadata, threshold, \\n binaryClosing=binaryClosing, binaryOpening=binaryOpening, \\n nogui=True, aggregate_near_nodes_distance=args.aggregatenearnodes,\\n hist_length_range=args.hist_length_range,\\n hist_radius_range=args.hist_radius_range\\n )\\n\\n # Remove Area = Load mask from file\\n if mask_file is not None:\\n logger.debug('Loading mask from file...')\\n mask = misc.obj_from_file(filename=mask_file, filetype='pickle')\\n if ha.data3d.shape == mask.shape:\\n ha.data3d_masked = mask\\n ha.data3d[mask == 0] = np.min(ha.data3d)\\n else:\\n raise ValueError('Mask file has wrong dimensions '+str(mask.shape))\\n \\n # Segmentation\\n logger.debug('Segmentation')\\n ha.data_to_skeleton()\\n\\n # Computing statistics\\n logger.info(\\\"# ## ## ## ## statistics\\\")\\n ha.data_to_statistics()\\n\\n # Saving files\\n logger.info(\\\"# ## ## write stats to file\\\")\\n ha.writeStatsToCSV()\\n if vtfile is not None:\\n ha.writeStatsToYAML(vtfile)\\n if vt2esofspy is not None:\\n ha.exportVT2esofspy(vt2esofspy)\\n\\n # ## Histology report\\n logger.info(\\\"# ## ## Histology report\\\")\\n hr = HistologyReport(ha.hr_hist_length_range, ha.hr_hist_radius_range)\\n hr.data = ha.stats\\n\\n # Add results Record\\n if crop is not None:\\n label = str(crop[0])+\\\"-\\\"+str(crop[1])\\n else:\\n label = \\\"0-end\\\"\\n # pass label into addResultRecord with stats\\n hr.data['general']['label'] = label\\n\\n hr.generateStats()\\n # TODO Rename functions\\n hr.writeReportToCSV()\\n hr.writeReportToYAML()\\n\\n \\n if inputfile is None:\\n hr.addResultsRecord(label=label, recordfilename=output_report_csv_file)\\n else:\\n hr.addResultsRecord(label=label, datapath=inputfile, recordfilename=output_report_csv_file)\\n\\n # ## End\\n logger.info('Finished')\",\n \"def justhandle(self, rawdata):\\r\\n\\r\\n return self.__handler(rawdata)\",\n \"def process(self):\\n # Opening and preprocessing of the input file\\n if self.options.mbtiles_fromdisk or self.options.mbtiles_todisk:\\n if self.options.mbtiles_fromdisk:\\n i_parm=10\\n if self.options.mbtiles_todisk:\\n i_parm=11\\n if self.options.verbose:\\n print \\\"GDAL2MbTiles :mbtiles from/to disk [\\\",i_parm,\\\"] mbtiles_fromdisk[\\\",self.options.mbtiles_fromdisk,\\\"] mbtiles_todisk[\\\",self.options.mbtiles_todisk,\\\"]\\\"\\n self.mbtiles_setup(i_parm)\\n return\\n else:\\n if self.options.verbose:\\n print \\\"GDAL2MbTiles :tile creation mbtiles[\\\",self.options.mbtiles,\\\"]\\\"\\n self.open_input()\\n # Generation of main metadata files and HTML viewers\\n self.generate_metadata()\\n # Generation of the lowest tiles\\n self.generate_base_tiles()\\n # Generation of the overview tiles (higher in the pyramid)\\n self.generate_overview_tiles()\\n # Generating of KML\\n self.generate_kml()\",\n \"def input(self, data, output = None):\\n\\t\\tif (self.isLoaded()):\\n\\t\\t\\tif output != None:\\n\\t\\t\\t\\tself.loader.input(data, output)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.loader.input(data)\",\n \"def generate_gui():\\n layout = [\\n [sg.Text(\\\"Load from file: \\\", size=(40, 1),\\n font=(38,), key=\\\"-LOAD_STATUS-\\\")],\\n [sg.InputText(\\\"\\\"), sg.FileBrowse(\\\"Browse\\\")],\\n [sg.Button(\\\"Load\\\")],\\n [sg.Text(\\\"Query:\\\"), sg.Text(\\\"\\\", size=(40, 1), key=\\\"-OUTPUT-\\\")],\\n [sg.Input(key=\\\"-QUERY-\\\")],\\n [sg.Button(\\\"Output - CSV\\\"), sg.Button(\\\"Output - Images\\\"), sg.Exit()],\\n ]\\n\\n window = sg.Window(\\\"MTG SQL Interface\\\", layout)\\n\\n while True:\\n event, values = window.Read()\\n if event in (None, \\\"Exit\\\"):\\n break\\n\\n if event == \\\"Load\\\":\\n # load file into Deck object & database\\n if values[\\\"Browse\\\"] != \\\"\\\":\\n p = Path(values[\\\"Browse\\\"])\\n _, db = file_to_db(p, window)\\n window[\\\"-QUERY-\\\"].Update(f\\\"\\\"\\\"SELECT * FROM {p.stem} WHERE\\\"\\\"\\\")\\n\\n if event == \\\"Output - CSV\\\":\\n # query database, store output as csv\\n p = Path(values[\\\"Browse\\\"]).stem + \\\".db\\\"\\n d = query_db(p, values[\\\"-QUERY-\\\"], output=\\\"text\\\")\\n window[\\\"-OUTPUT-\\\"].Update(\\\"written to CSV\\\")\\n\\n if event == \\\"Output - Images\\\":\\n # query database, download corresponding images\\n p = Path(values[\\\"Browse\\\"]).stem + \\\".db\\\"\\n d = query_db(p, values[\\\"-QUERY-\\\"], output=\\\"images\\\")\\n window[\\\"-OUTPUT-\\\"].Update(\\\"images saved\\\")\\n\\n window.Close()\",\n \"def pass_data(self, data):\\n self.data = data\\n self.load_input_fields()\",\n \"def __process_element(data):\\n print('prosessing {}'.format(data))\\n x_i = data[0]\\n y_i = data[1]\\n\\n file_name = FeatureExtractor.get_file_name(x_i, feature_name)\\n try:\\n # try to load if file already exist\\n np.load(out_path / file_name, allow_pickle=True)\\n print('info: {} loaded from .npy !'.format(file_name))\\n new_labels.append([file_name, y_i])\\n except FileNotFoundError or OSError or EOFError:\\n # OSError and EOFError are raised if file are inconsistent\\n voice_activation = np.load(source_path / x_i, allow_pickle=True)\\n mean_voice_activation = FeatureExtractor.get_mean_voice_activation(voice_activation[0])\\n # this is kind-of standard\\n FeatureExtractor.save_feature([voice_activation[0], mean_voice_activation], feature_name, out_path, x_i,\\n y_i, new_labels)\",\n \"def process(self):\\n pass\",\n \"def collect_incoming_data(self, data):\\n self.__input.append(data)\",\n \"def addLoadPaths(self):\\n #create a static boxsizer\\n load_box = wx.StaticBox(self, label=\\\"Step 1: Input Data\\\")\\n box_sizer = wx.StaticBoxSizer(load_box, wx.VERTICAL)\\n fgs = wx.FlexGridSizer(rows=2, cols=2, vgap=10, hgap=10)\\n box_sizer.Add(fgs, proportion=1, flag=wx.EXPAND)\\n\\n #actual data handled by a FGS\\n self.data_btn = wx.Button(self, label=\\\"Load Data\\\")\\n self.data_btn.Bind(wx.EVT_BUTTON, self.onLoadData)\\n\\n self.assign_btn = wx.Button(self, label=\\\"Add Assignments\\\")\\n self.assign_btn.Bind(wx.EVT_BUTTON, self.onAddAssignment)\\n self.assign_btn.Disable()\\n\\n pub.subscribe(self.dataLoaded, \\\"data_loaded\\\")\\n \\n fgs.Add(self.data_btn, proportion=1, flag = wx.EXPAND)\\n fgs.Add(wx.StaticText(self), proportion=1, flag = wx.EXPAND)\\n\\n fgs.Add(self.assign_btn)\\n btn_label = wx.StaticText(self, label=\\\"(optional)\\\")\\n new_font = btn_label.GetFont()\\n new_font.SetStyle(wx.FONTSTYLE_ITALIC)\\n btn_label.SetFont(new_font)\\n fgs.Add(btn_label)\\n \\n \\n fgs.Add(wx.StaticText(self), proportion=1, flag = wx.EXPAND)\\n\\n self.SetSizerAndFit(box_sizer)\",\n \"def populate_data(self):\\r\\n # Importing StationData with the standard imports causes a redundancy\\r\\n # problem, so it is imported here only when it is needed.\\r\\n from stationData import StationData\\r\\n # Find data requirements from all plumes.\\r\\n requirements = describe.PLUMES\\r\\n # Loop over plumes and define parameters to be used for pulling data.\\r\\n grib_file = pygrib.open(self.grib_file_path)\\r\\n for req in requirements:\\r\\n (plume,data_types,grid_level_type,grid_level,unused) = req\\r\\n selected = grib_file.select(shortName=data_types,\\r\\n typeOfLevel=grid_level_type,\\r\\n level=grid_level)\\r\\n for i, message in enumerate(selected):\\r\\n if i % 20 == 0:\\r\\n print '%s %s/%s Grib messages processed for %s' %\\\\\\r\\n (PRETEXT, i + 1, len(selected), req[0])\\r\\n for sdo in StationData.instances:\\r\\n if sdo.grib_i is None:\\r\\n StationData.populate_grid_information(message,\\r\\n self.config)\\r\\n sdo.add_data(plume,self.member_name,message)\\r\\n grib_file.close()\\r\\n return\",\n \"def got_data(self, data):\\n if self.get_current_state() == SBE37ProtocolState.DIRECT_ACCESS:\\n # direct access mode\\n if len(data) > 0:\\n mi_logger.debug(\\\"SBE37Protocol._got_data(): <\\\" + data + \\\">\\\") \\n if self._driver_event:\\n self._driver_event(DriverAsyncEvent.DIRECT_ACCESS, data)\\n # TODO: what about logging this as an event?\\n return\\n \\n if len(data)>0:\\n # Call the superclass to update line and prompt buffers.\\n CommandResponseInstrumentProtocol.got_data(self, data)\\n \\n # If in streaming mode, process the buffer for samples to publish.\\n cur_state = self.get_current_state()\\n if cur_state == SBE37ProtocolState.AUTOSAMPLE:\\n if SBE37_NEWLINE in self._linebuf:\\n lines = self._linebuf.split(SBE37_NEWLINE)\\n self._linebuf = lines[-1]\\n for line in lines:\\n self._extract_sample(line)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6277665","0.6056177","0.59779894","0.59718275","0.5932694","0.59140706","0.58592844","0.5857117","0.5857117","0.5828108","0.58244014","0.5787937","0.5766094","0.5746301","0.5732957","0.571916","0.57150483","0.57103926","0.57093644","0.5667955","0.5667955","0.5667955","0.5667955","0.5667955","0.5660357","0.5625001","0.56140864","0.56030387","0.5593909","0.55805933","0.55666083","0.55443436","0.55374205","0.5536508","0.55192304","0.551619","0.5487095","0.54613495","0.5453674","0.54518527","0.5436906","0.5436906","0.5436906","0.5434043","0.54277885","0.54156774","0.5397135","0.5397135","0.5397135","0.5397135","0.5397135","0.5397135","0.53941053","0.5383942","0.5375126","0.5363465","0.53573203","0.5355005","0.53546107","0.5344795","0.53328127","0.5329808","0.5327367","0.53268653","0.5321214","0.53209007","0.5315373","0.5313636","0.530976","0.53035766","0.5301492","0.52842253","0.5282817","0.5279564","0.52780163","0.52699125","0.52578044","0.52511454","0.5248947","0.5248556","0.5245217","0.5244353","0.5243679","0.5241953","0.5241686","0.5240357","0.52379274","0.5234413","0.5228651","0.522515","0.5221412","0.52200586","0.52174735","0.5217137","0.52157015","0.52144474","0.5209068","0.52082133","0.52065116","0.5205329","0.5204376"],"string":"[\n \"0.6277665\",\n \"0.6056177\",\n \"0.59779894\",\n \"0.59718275\",\n \"0.5932694\",\n \"0.59140706\",\n \"0.58592844\",\n \"0.5857117\",\n \"0.5857117\",\n \"0.5828108\",\n \"0.58244014\",\n \"0.5787937\",\n \"0.5766094\",\n \"0.5746301\",\n \"0.5732957\",\n \"0.571916\",\n \"0.57150483\",\n \"0.57103926\",\n \"0.57093644\",\n \"0.5667955\",\n \"0.5667955\",\n \"0.5667955\",\n \"0.5667955\",\n \"0.5667955\",\n \"0.5660357\",\n \"0.5625001\",\n \"0.56140864\",\n \"0.56030387\",\n \"0.5593909\",\n \"0.55805933\",\n \"0.55666083\",\n \"0.55443436\",\n \"0.55374205\",\n \"0.5536508\",\n \"0.55192304\",\n \"0.551619\",\n \"0.5487095\",\n \"0.54613495\",\n \"0.5453674\",\n \"0.54518527\",\n \"0.5436906\",\n \"0.5436906\",\n \"0.5436906\",\n \"0.5434043\",\n \"0.54277885\",\n \"0.54156774\",\n \"0.5397135\",\n \"0.5397135\",\n \"0.5397135\",\n \"0.5397135\",\n \"0.5397135\",\n \"0.5397135\",\n \"0.53941053\",\n \"0.5383942\",\n \"0.5375126\",\n \"0.5363465\",\n \"0.53573203\",\n \"0.5355005\",\n \"0.53546107\",\n \"0.5344795\",\n \"0.53328127\",\n \"0.5329808\",\n \"0.5327367\",\n \"0.53268653\",\n \"0.5321214\",\n \"0.53209007\",\n \"0.5315373\",\n \"0.5313636\",\n \"0.530976\",\n \"0.53035766\",\n \"0.5301492\",\n \"0.52842253\",\n \"0.5282817\",\n \"0.5279564\",\n \"0.52780163\",\n \"0.52699125\",\n \"0.52578044\",\n \"0.52511454\",\n \"0.5248947\",\n \"0.5248556\",\n \"0.5245217\",\n \"0.5244353\",\n \"0.5243679\",\n \"0.5241953\",\n \"0.5241686\",\n \"0.5240357\",\n \"0.52379274\",\n \"0.5234413\",\n \"0.5228651\",\n \"0.522515\",\n \"0.5221412\",\n \"0.52200586\",\n \"0.52174735\",\n \"0.5217137\",\n \"0.52157015\",\n \"0.52144474\",\n \"0.5209068\",\n \"0.52082133\",\n \"0.52065116\",\n \"0.5205329\",\n \"0.5204376\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83179,"cells":{"query":{"kind":"string","value":"Parse a readme file."},"document":{"kind":"string","value":"def read_readme(readme: str) -> Tuple[dict, list]:\n metadata = {\n \"name\": \"na\",\n \"provider\": \"na\",\n \"original name\": \"na\",\n \"original filename\": \"na\",\n \"assembly_accession\": \"na\",\n \"tax_id\": \"na\",\n \"mask\": \"na\",\n \"genome url\": \"na\",\n \"annotation url\": \"na\",\n \"sanitized annotation\": \"na\",\n \"genomepy version\": \"na\",\n \"date\": \"na\",\n }\n lines = []\n\n if not os.path.exists(readme):\n return metadata, lines\n\n # if the readme exists, overwrite all metadata fields found\n with open(readme) as f:\n for line in f.readlines():\n if \": \" in line:\n vals = line.strip().split(\": \")\n metadata[vals[0].strip()] = (\": \".join(vals[1:])).strip()\n else:\n line = line.strip(\"\\n\").strip(\" \")\n # blank lines are allowed, but only one in a row\n if not (\n line == \"\"\n and len(lines) > 0\n and lines[len(lines) - 1].strip() == \"\"\n ):\n lines.append(line)\n\n return metadata, lines"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def parse_readme():\n # Get the long description from the relevant file\n readme_path = path.join(here, 'README.md')\n with codecs.open(readme_path, encoding='utf-8') as handle:\n desc = handle.read()\n\n return desc","def test_readme():\n readme = Path(README_PATH).read_text()\n Actions.read_from_md(readme)","def readme():\n with open('README.md') as readme_file:\n return readme_file.read()","def readme():\n with open('README.md') as _file:\n return _file.read()","def readme():\n\n with open('README.rst') as readme_file:\n return readme_file.read()","def readme():\n with open('README.rst') as f:\n return f.read()","def readme(fname='README'):\n with open(os.path.join(os.path.dirname(__file__), fname)) as file:\n return file.read()","def readme_md(cls):\n\n template = Helpers.File(Settings.readme_me_template).read()\n\n template = Helpers.Regex(\n template, r\"%%version%%\", replace_with=Settings.version\n ).replace()\n template = Helpers.Regex(\n template, r\"%%lenHosts%%\", replace_with=format(len(Settings.domains), \",d\")\n ).replace()\n template = Helpers.Regex(\n template, r\"%%lenIPs%%\", replace_with=format(len(Settings.ips), \",d\")\n ).replace()\n template = Helpers.Regex(\n template,\n r\"%%lenHostsIPs%%\",\n replace_with=format(len(Settings.ips) + len(Settings.domains), \",d\"),\n ).replace()\n\n print(\"Generation of %s\" % Settings.readme_md_file, end=\" \")\n Helpers.File(Settings.readme_md_file).write(template, overwrite=True)\n print(Settings.done)","def test_readme_contents():\n readme = open(\"README.md\", \"r\", encoding=\"utf-8\")\n readme_words = readme.read().split()\n readme.close()\n assert len(readme_words) >= 500, \"Make your README.md file interesting! Add atleast 500 words\"","def _readme_file(self, readme_path=None, proxies=None):\n if proxies is None:\n proxies = self._proxies\n if readme_path is None:\n readme_path = self._README_PATH\n url = \"{}{}\".format(self._url, readme_path)\n response = self._http.request(url=url, method=\"GET\", proxies=proxies)\n if response is None:\n return False\n if \"Stable tag:\" not in response.text:\n return False\n version = response.text.split(\"Stable tag:\")[1].split(\"\\n\")[0] # get the version of the plugin\n return self.is_vulnerable_version(version)","def readme():\n with open(os.path.join(build_root, 'README.rst')) as f:\n return f.read()","def get_readme():\n for name in ('README', 'README.rst', 'README.md'):\n if os.path.exists(name):\n return read_file(name)\n return ''","def get_readme():\n for name in ('README', 'README.txt', 'README.rst', 'README.md'):\n if os.path.exists(name):\n return read_file(name)\n return ''","def read_readme(setup_file, name=\"README.rst\"):\n import os\n TOP_DIR = os.path.abspath(os.path.dirname(setup_file))\n if not os.path.exists(TOP_DIR):\n raise FileNotFoundError(\n f\"Unable to find folder {TOP_DIR!r}.\")\n readme = os.path.join(TOP_DIR, name)\n if not os.path.exists(readme):\n raise FileNotFoundError(\n f\"Unable to find file {TOP_DIR!r}.\")\n with open(readme, \"r\", encoding=\"utf-8\") as f:\n content = f.read()\n return _clean_readme(content)","def test_readme_file_for_formatting():\n f = open(\"README.md\", \"r\", encoding=\"utf-8\")\n content = f.read()\n f.close()\n assert content.count(\"#\") >= 10, \"Readme is not formatted properly\"","def readme(self, ref=None):\r\n params = base.get_params(None, locals())\r\n url = '{0}/readme'.format(self.parent.get_url())\r\n\r\n return http.Request('GET', url, params), parsers.parse_json","def main():\n parse_file(sys.argv[1])","def get_fsleyes_readme():\n with open(op.join(basedir, 'README.rst'), 'rt', encoding='utf-8') as f:\n return f.read().strip()","def fix_readme(self):\n import re\n\n readme = os.path.join(os.path.dirname(__file__), \"README.md\")\n with open(readme, \"r\") as f:\n content = f.read()\n\n tag = self.get_tag()\n if not tag:\n raise AssertionError(\n \"Could not get tag! (are you checking out with full tag history?)\"\n )\n\n new_content = re.sub(\n r\"\\(docs/\",\n rf\"(https://github.com/robocorp/robotframework-lsp/tree/{tag}/robocorp-code/docs/\",\n content,\n )\n\n new_content = re.sub(\n r\"\\(images/\",\n rf\"(https://raw.githubusercontent.com/robocorp/robotframework-lsp/{tag}/robocorp-code/images/\",\n content,\n )\n\n new_content = new_content.replace(\n \"Apache 2.0\",\n \"[Robocorp License Agreement (pdf)](https://cdn.robocorp.com/legal/Robocorp-EULA-v1.0.pdf)\",\n )\n\n assert \"apache\" not in new_content.lower()\n with open(readme, \"w\") as f:\n f.write(new_content)","def find_long_description():\n return read_file('../README.md')","def get_readme_text(self):\n if self.readme_file:\n readme_text = self.readme_file.read_text(encoding=\"utf-8\")\n else:\n readme_text = \"# foxBMS 2 GUI\"\n return readme_text","def _get_bids_readme(self):\n readme = []\n # Grab all readme files, loop through\n for README_fname in [\n file for file in Path(self.dataset.path).glob(\"[Rr][Ee][Aa][Dd][Mm][Ee]*\")\n ]:\n # datalad get content if annexed\n self.dataset.get(README_fname)\n # read text from file\n try:\n file_text = ensure_unicode(README_fname.read_text()).strip()\n except:\n file_text = \"\"\n # Append dict with file text + extension to list\n readme.append({\"extension\": README_fname.suffix, \"text\": file_text})\n return readme if readme else None","def test_readme_proper_description():\n READMELOOKSGOOD = True\n f = open(\"README.md\", \"r\", encoding=\"utf-8\")\n content = f.read()\n f.close()\n for c in README_CONTENT_CHECK_FOR:\n if c not in content:\n print(c)\n READMELOOKSGOOD = False\n break\n\n assert READMELOOKSGOOD is True, \"You have not described all the functions/class well in your README.md file\"","def get_description():\n with open(\"README.rst\", \"rb\") as readme:\n long_description = readme.read().decode(\"utf-8\")\n return long_description","def readme_tests(readme=None):\n if readme is None:\n readme = Path('..', 'readme.md')\n with open(readme) as target:\n for line in target:\n if line.startswith(' ') and 'test_utils' not in line:\n print()\n print(line)\n input('Press Enter to execute')\n sb.run(line, shell=True, check=True)","def test_session10_readme_proper_description():\n READMELOOKSGOOD = True\n f = open(\"README.md\", \"r\", encoding=\"utf-8\")\n content = f.read()\n f.close()\n for c in README_CONTENT_CHECK_FOR:\n if c not in content:\n print(c)\n READMELOOKSGOOD = False\n pass\n assert READMELOOKSGOOD == True, \"You have not described all the functions/class well in your README.md file\"","def readme(self):\n if \"README.md\" not in self:\n ex_msg = \"This Package is missing a README file. A Quilt recognized README file is a file named \" \\\n \"'README.md' (case-insensitive)\"\n raise QuiltException(ex_msg)\n\n return self[\"README.md\"]","def parse(self, infile):\r\n raise NotImplementedError()","def index():\n\n # open the README file\n with open(os.path.dirname(app.root_path) + '/README.md',\n 'r', encoding=\"utf-8\") as markdown_file:\n\n # Read the content of the file\n content = markdown_file.read()\n\n # convert to html\n return markdown.markdown(content)","def get_long_description():\n with open(\"README.md\", \"r\") as fh:\n return fh.read()","def read(self, filename):\r\n with pelican_open(filename) as content:\r\n parser = self._HTMLParser(self.settings, filename)\r\n parser.feed(content)\r\n parser.close()\r\n\r\n metadata = {}\r\n for k in parser.metadata:\r\n metadata[k] = self.process_metadata(k, parser.metadata[k])\r\n return parser.body, metadata","def parse(self, htmlFile):\n htmlToMdParser = HtmlToMarkdown()\n htmlToMdParser.readFile(htmlFile)\n self.__setMarkdownOutput(htmlToMdParser.getMarkdown())","def OpenReadMe():\n location = os.path.join(os.path.dirname(__file__), \"README.txt\")\n os.startfile(location)","def read_file(file_name):\r\n\r\n if file_name.find('.md') == -1:\r\n file_name += '.md'\r\n\r\n with open(file_name, 'r', encoding='utf-8') as file:\r\n file_data = file.read()\r\n\r\n return file_data","def read(self, filename):\n\n # TODO: use markdown reader to parse the reveal.js markdown\n # github.com/danielfrg/pelican-ipynb/blob/master/markup.py#L62\n reader = MarkdownReader(self.settings)\n md_content, metadata = reader.read(filename)\n\n # TODO: using the markdown reader converts the file contents to HTML,\n # but we just want plain text because pandoc should be converting it\n # instead. The trouble is, we also want to get the metadata\n\n extracmd = \"\"\n\n if \"theme\" in metadata:\n extracmd = extracmd + \" \" + \"--variable theme=%s\" % metadata[\"theme\"]\n\n if \"revealoptions\" in metadata:\n if \"transition\" in metadata[\"revealoptions\"]:\n extracmd = (\n extracmd\n + \" \"\n + \"--variable transition=%s\"\n % metadata[\"revealoptions\"][\"transition\"]\n )\n\n command = f\"pandoc --to revealjs -f markdown {extracmd} {filename}\"\n\n # Define template for Pelican\n metadata[\"template\"] = \"revealmd\"\n\n p = subprocess.Popen(\n command.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE\n )\n\n try:\n stdout, stderr = p.communicate(str.encode(\"utf8\"))\n except OSError:\n raise RuntimeError(\n 'Pandoc died with exitcode \"%s\" during conversion.' % p.returncode\n )\n\n revealjs_content = stdout.decode(\"utf8\")\n\n # Patch revealjs_content to convert 'back' \"{\" and \"}\"\n returntext = revealjs_content.replace(\"%7B\", \"{\").replace(\"%7D\", \"}\")\n\n return returntext, metadata","def test_readme_commands(self, client):\n with open(REPO_ROOT / \"README.md\") as f:\n readme = f.read()\n\n documented = set(re.findall(\"^- `!([a-z]+)`: .*$\", readme, re.MULTILINE))\n implemented = set(client.commands)\n\n assert documented == implemented","def read(self, source_path):\r\n\r\n self._md = Markdown(extensions=self.extensions)\r\n with pelican_open(source_path) as text:\r\n content = self._md.convert(text)\r\n\r\n metadata = self._parse_metadata(self._md.Meta)\r\n return content, metadata","def get_long_description():\n with open(path.join(root_path, \"README.md\"), encoding=\"utf-8\") as f:\n long_description = f.read()\n return long_description","def _parse(self, infile):\n raise NotImplementedError()","def parse_file(self, file_name: str):\n if not os.path.exists(file_name):\n log.error('File {} does not exist'.format(file_name))\n return None\n try:\n with open(file_name) as file:\n file_content = file.readlines()\n except Exception as ex:\n log.error('Failed to read file {}: {}'.format(file_name, str(ex)))\n return None\n return self.parse_from_string(''.join(file_content))","def _(fname: str) -> str:\n with open(os.path.join(os.getcwd(), fname)) as readme:\n content = readme.read() or '' # prevent ``content = None``\n return content","def load_description(path_dir=PATH_ROOT, filename=\"DOCS.md\"):\n with open(os.path.join(path_dir, filename)) as f:\n long_description = f.read()\n return long_description","def OpenReadMe():\n location = os.path.join(os.path.dirname(__file__), \"README.txt\")\n os.startfile(location)\n return","def ler_markdown(nome_do_arquivo):\n return open(\"teste.md\").read()","def read_markdown_text_file(file_name):\n \n with open (file_name, 'r', encoding='utf-16') as fp:\n htmlmarkdown = markdown.markdown(fp.read())\n return htmlmarkdown","def test_session10_readme_500_words():\n readme = open(\"README.md\", \"r\")\n readme_words = readme.read().split()\n readme.close()\n assert len(readme_words) >= 500, \"Make your README.md file interesting! Add atleast 500 words\"","def test_readme_text_directly(readme_path):\n code = []\n code_block = False\n\n with open(readme_path, 'r') as f:\n for line in f:\n if line.endswith(\"```\\n\"):\n code_block = False\n\n # Add all code lines except for the viz function.\n if code_block and not line.startswith('viz_neighbors_imgs'):\n code.append(line)\n\n if line.startswith(\"```python\"):\n code_block = True\n\n exec(('\\n').join(code))","def _analyze_file(self) -> None:\n\n md_reader = MarkdownReader.from_file(self.path)\n for md_line in md_reader.lines:\n if len(md_line.current_section) == 1:\n if self.title and self.title != md_line.current_section[0]:\n logger.warning(f\"{self.path} Warning: Multiple titles. \")\n self.title = md_line.current_section[0]\n if (\n not md_line.is_code_block\n and md_line.text.lower().strip().startswith(\"tags: \")\n ):\n if self.tags:\n logger.warning(\n f\"{self.path} Warning: Tags were already set.\"\n )\n self.tags = self._read_tags(md_line.text)\n if (\n len(md_line.current_section) >= 2\n and md_line.current_section[1].lower().strip() == \"backlinks\"\n ):\n pass\n else:\n self.links.extend(self.id_link_regex.findall(md_line.text))","def html_reader(input_dir):\r\n #read data from the html file\r\n with open(input_dir,'r') as html_file:\r\n content = html_file.read()\r\n content = (content.split('\\n'))[4:-4]\r\n num = re.compile(\"(.*\\t\\d.*)|(\\d*\\d\\.\\d*)\")\r\n information = []\r\n for i in range(len(content)):\r\n if num.match(content[i])==None:\r\n information.append(content[i])\r\n information = information[:-1]\r\n #data parsing\r\n Date = re.compile('( ?CACM|June)')\r\n Meta = re.compile(\"(CA\\d\\d\\d\\d\\d\\d|June)\")\r\n #get date and meta index\r\n for i in range(len(information)):\r\n if Date.match(information[i])!=None:\r\n index_date = i\r\n if Meta.match(information[i])!=None:\r\n index_meta =i\r\n content = information[:index_date]\r\n others = information[index_date+2:index_meta]\r\n for i in range(len(content)):\r\n if content[i]==\"\":\r\n title = content[:i]\r\n abstract = content[i+1:]\r\n break\r\n #get author and other\r\n author = []\r\n other = []\r\n for i in range(len(others)):\r\n if others[i]==\"\":\r\n if re.match(\"[A-Z].*, ?[A-Z].*\\..*\",others[0]) != None:\r\n author = others[:i]\r\n other = others[i+1:]\r\n else:\r\n other = others\r\n break\r\n for i in range(len(author)):\r\n if re.match(\"[A-Z].*, ?[A-Z].*\\..*\",author[i]) != None:\r\n name = author[i].split(\",\")\r\n author[i] = (name[1]+name[0])\r\n author[i] = author[i].replace(\" \",\"\")\r\n author[i] = author[i].replace(\"\\t\",\"\")\r\n author[i] = author[i].lower()\r\n\r\n #parse date\r\n date = []\r\n date.append(re.search(\"19\\d\\d\", information[index_date]).group())\r\n date.append(re.search(\"(January|February|March|April|May|June|JUly|July|August|September|October|November|December)\",information[index_date]).group().lower())\r\n\r\n #parse meta data\r\n meta = []\r\n meta.append(re.search(\"CA\\d\\d\\d\\d\\d\\d\\w?\",information[index_meta]).group().lower())#0\r\n meta.append(re.search(\"[a-z0-9] [A-Z]{2}[A-Z]?\",information[index_meta]).group()[2:].lower())#1\r\n meta.append(re.search(\"(January|February|March|April|May|June|JUly|July|August|September|October|November|December)\",information[index_meta]).group().lower())#2\r\n meta.append(re.search(\"\\w \\d\\d?\",information[index_meta]).group()[2:])#3\r\n meta.append(re.search(\"\\d?\\d:\\d\\d\",information[index_meta]).group())#4\r\n meta.append(re.search(\"(AM|PM)\",information[index_meta]).group().lower())#5\r\n meta.append(re.search(\"19\\d\\d\",information[index_meta]).group())#6\r\n\r\n #build corpus\r\n corpus = set()\r\n lemmatizer = WordNetLemmatizer()\r\n for i in range(len(title)):\r\n title[i] = re.sub(\"\\(|\\)|-|\\d\\d?\\d?|:|/|\\.|`|\\?\",\" \",title[i])\r\n words = word_tokenize(title[i])\r\n for word in words:\r\n normal_word = word.lower()\r\n if normal_word not in stopwords.words(\"english\"):\r\n corpus.add(lemmatizer.lemmatize(normal_word))\r\n\r\n for i in range(len(abstract)):\r\n abstract[i] = re.sub(\"\\(|\\)|-|\\d\\d?\\d?|:|/|\\.|`|\\?|,\",\" \",abstract[i])\r\n words = word_tokenize(abstract[i])\r\n for word in words:\r\n normal_word = word.lower()\r\n if normal_word not in stopwords.words(\"english\"):\r\n corpus.add(lemmatizer.lemmatize(normal_word))\r\n\r\n for i in range(len(other)):\r\n other[i] = re.sub(\"\\(|\\)|-|\\d\\d?\\d?|:|/|\\.|`|\\?|,\",\" \",other[i])\r\n words = word_tokenize(other[i])\r\n for word in words:\r\n normal_word = word.lower()\r\n if normal_word not in stopwords.words(\"english\"):\r\n corpus.add(lemmatizer.lemmatize(normal_word))\r\n\r\n corpus = list(corpus)\r\n\r\n return paper(author= author, other= other, metadata= meta,date = date,title = title,abstract = abstract,id=int(input_dir[-9:-5]),corpus = corpus)","def parse(self, filehandle):\n l = filehandle.readline()\n if l.split()[0] != '##maf':\n return\n else:\n self.setpar(l.split()[1:])\n\n l=filehandle.readline()\n while l:\n la = l.split()\n## print la\n if(len(la)==0 or la[0]=='#'):\n## print \"skipping\"\n 1\n elif(la[0]=='a'):\n## print \"reading alignment\"\n self.readalign(la[1:], filehandle)\n else:\n## print \"end of records\"\n return\n\n l=filehandle.readline()","def _parse(self):\n with open(_join(self.man_dir, self.man_fn)) as fp:\n lines = fp.readlines()\n \n desc_indxs = []\n for i, L in enumerate(lines):\n if \"#landuse\" in L or \" # landuse\" in L:\n desc_indxs.append(i-1)\n desc_indxs.append(i-2)\n desc_indxs.append(i-3)\n \n lines = [L[:L.find('#')].strip() for L in lines]\n lines = [L for i, L in enumerate(lines) if len(L) > 0 or i in desc_indxs]\n\n del desc_indxs\n \n self.datver = lines.pop(0)\n self.nofe = int(lines.pop(0))\n self.sim_years = int(lines.pop(0))\n \n # Read Plant Growth Section\n self.plants = PlantLoops(lines, self)\n\n # Read Operation Section\n self.ops = OpLoops(lines, self)\n \n # Read Initial Condition Section\n self.inis = IniLoops(lines, self)\n \n # Read Surface Effects Section\n self.surfs = SurfLoops(lines, self)\n \n # Read Contour Section\n self.contours = ContourLoops(lines, self)\n \n # Read Drainage Section\n self.drains = DrainLoops(lines, self)\n \n # Read Yearly Section\n self.years = YearLoops(lines, self)\n \n # Read Management Section \n self.man = ManagementLoop(lines, self)","def update_readme():\n\n temp = \"\"\"<head>\n <title>Unittest Results</title>\n <meta charset=\"utf-8\">\n <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n <link rel=\"stylesheet\" href=\"https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css\" integrity=\"sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7\" crossorigin=\"anonymous\">\n</head>\"\"\"\n\n with open(\"README_proxy.md\", \"r\") as old_readme_file:\n old_readme_txt = old_readme_file.read()\n\n with open(\"reports/test_result.html\", \"r\") as html_file:\n html = html_file.read().splitlines()[0:-21]\n html = \"\\n\".join(html).replace(temp, \"\")\n\n with open(\"README.md\", \"w\") as new_readme_file:\n new_readme_file.write(old_readme_txt + \"\\n\\n\\n\" + html + \"</body></html>\")","def read_file(self):\n try:\n with open(self.file_name, 'r') as ach_file:\n file_contents = ach_file.read().replace('\\n', '').replace('\\r', '')\n\n self._parse_ach_file(file_contents)\n except FileNotFoundError as err:\n print(\"File does not exist -> \" + str(err))","def parse_file(self, file_name, **kwargs):\n with io.open(file_name, 'r', encoding='utf-8') as f:\n content = f.read()\n return self.parse(content, file_name=file_name, **kwargs)","def make_readme_txt(self, args):\n with open(self.readme_txt, 'w') as writer:\n log.info(\"args=%s\\n\", args)\n writer.write(\"# Created by pbtranscript-internal-validation.ValidationRunner.make_readme_txt()\\n\")\n writer.write(\"args=%s\\n\\n\" % args)\n\n files = self.common_files + self.collapse_human_files + self.reseq_human_files + self.sirv_files\n for desc, fn in files:\n if op.exists(fn):\n writer.write(\"%s=%s\\n\" % (desc, fn))","def read(self, input): \n \n # 1. Assume we have the name of a file in the execution dir or a \n # file-like object. \n # Note we need to add parsing of the path to dir/filename \n try: \n with File.as_handle(input, 'rU') as fp: \n file_contents = fp.read() \n self.filename = getattr(fp, 'name', 'Unknown_nexus_file') \n except (TypeError, IOError, AttributeError): \n #2 Assume we have a string from a fh.read() \n if isinstance(input, basestring): \n file_contents = input \n self.filename = 'input_string' \n else: \n print(input.strip()[:50]) \n raise NexusError('Unrecognized input: %s ...' % input[:100]) \n file_contents = file_contents.strip() \n if file_contents.startswith('#NEXUS'): \n file_contents = file_contents[6:] \n commandlines = _get_command_lines(file_contents) \n # get rid of stupid 'NEXUS token - in merged treefiles, this might appear multiple times' \n for i, cl in enumerate(commandlines): \n try: \n if cl[:6].upper() == '#NEXUS': \n commandlines[i] = cl[6:].strip() \n except: \n pass \n # now loop through blocks (we parse only data in known blocks, thus ignoring non-block commands \n nexus_block_gen = self._get_nexus_block(commandlines) \n while True: \n try: \n title, contents = next(nexus_block_gen) \n except StopIteration: \n break \n if title in KNOWN_NEXUS_BLOCKS: \n self._parse_nexus_block(title, contents) \n else: \n self._unknown_nexus_block(title, contents)","def longdescription():\r\n print()\r\n here = path.abspath(path.dirname(__file__))\r\n with open(path.join(here, 'README.rst')) as f:\r\n long_description = f.read()\r\n\r\n print(long_description)","def read(self, source_path):\n\n self._source_path = source_path\n self._md = Markdown(extensions=self.extensions)\n\n # Custom handling of ^include.html^\n self._md.inlinePatterns['include_html'] = IncludeHtmlPattern(self)\n\n with pelican_open(source_path) as text:\n content = self._md.convert(text)\n\n metadata = self._parse_metadata(self._md.Meta)\n return content, metadata","def parse(self, htmlfile):\r\n title_el, summary_el, codesnippet_el = None, None, None\r\n soup = BeautifulSoup(htmlfile)\r\n if self._is_obsolete(soup):\r\n return None\r\n title_el = soup.find('h1', class_='page-title')\r\n article = soup.find(id='wikiArticle')\r\n if article:\r\n summary_el = article.find(\r\n lambda e: e.name=='p' and e.text.strip() != '', recursive=False)\r\n syntax_header = soup.find(id='Syntax')\r\n if syntax_header:\r\n codesnippet_el = syntax_header.find_next(['pre', 'code'])\r\n mdn = MDN()\r\n mdn.title = self._extract_node(title_el)\r\n mdn.summary = self._extract_node(summary_el)\r\n mdn.codesnippet = self._extract_node(codesnippet_el)\r\n return mdn","def build_readme(comic: str, readme: str) -> str:\n img = f\"{START_COMMENT}\\n{comic}\\n{END_COMMENT}\"\n return re.sub(listReg, img, readme)","def blosxom_entry_parser(filename, request):\n config = request.getConfiguration()\n\n entryData = {}\n\n try:\n story = open(filename).readlines()\n except IOError:\n raise IOError\n\n if len(story) > 0:\n entryData['title'] = story.pop(0).strip()\n\n # this handles properties of the entry that are between\n # the title and the body and start with a #\n while len(story) > 0:\n match = re.match(r'^#(\\w+)\\s+(.*)', story[0])\n if match:\n story.pop(0)\n entryData[match.groups()[0]] = match.groups()[1].strip()\n else:\n break\n\n # Call the preformat function\n entryData['body'] = tools.run_callback('preformat',\n {'parser': (entryData.get('parser', '') \n or config.get('parser', 'plain')),\n 'story': story,\n 'request': request},\n donefunc = lambda x:x != None,\n defaultfunc = lambda x: ''.join(x['story']))\n\n # Call the postformat callbacks\n tools.run_callback('postformat',\n {'request': request,\n 'entry_data': entryData})\n \n return entryData","def read(self, filename):\n pass","def read(self, filename):\n pass","def run():\r\n\r\n # Parse options and adjust logging level if necessary\r\n options, logging_level = parse_options()\r\n if not options: sys.exit(2)\r\n logger.setLevel(logging_level)\r\n logger.addHandler(logging.StreamHandler())\r\n\r\n # Run\r\n markdown.markdownFromFile(**options)","def parse(lines):\n if len(lines) == 0:\n return (None, lines)\n title = lines[0]\n if len(title) > 0 and \"*\" == title[0]:\n level = 1\n while title[level] == \"*\":\n level = level + 1\n if title[level] != \" \":\n return (None, lines)\n else:\n heading = title[level+1:]\n todo = heading[:4] == \"TODO\"\n done = heading[:4] == \"DONE\"\n if todo or done:\n heading = heading[4:]\n return (ORGSection(heading.strip(), level=level, TODO=todo, DONE=done), lines[1:])\n else:\n return (None, lines)","def test_readme():\n notebooks_readme = Path(\"notebooks/README.md\").read_text()\n for item in Path(\"notebooks\").iterdir():\n if item.is_dir():\n # item is a notebook directory\n notebook_dir = item.relative_to(\"notebooks\")\n if str(notebook_dir)[0].isdigit():\n assert \"README.md\" in [filename.name for filename in item.iterdir()], \\\n f\"README not found in {item}\"\n assert str(notebook_dir) in notebooks_readme, f\"{item} not found in notebooks README\"","def extract_metadata(file: MarkdownFile) -> MarkdownFile:\n\n config_text: str\n content_text: str\n config: List[str] = []\n content: List[str] = []\n reading_config: bool = False\n start_block, end_block = \"<!--\", \"-->\\n\"\n\n with open(file.fullpath, \"r\") as fp:\n for line in fp.readlines():\n if reading_config and line == end_block:\n reading_config = False\n continue\n if line.startswith(start_block):\n if reading_config:\n raise IOError(f\"problem reading config from file {file}\")\n reading_config = True\n config.append(line.split(start_block)[-1])\n continue\n if reading_config:\n config.append(line)\n continue\n if not reading_config:\n content.append(line)\n\n if config:\n config_text = \"\".join(config)\n file.add_metadata(raw=config_text)\n if content:\n content_text = \"\".join(content)\n file.add_markdown(raw=content_text)\n return file","def parse_file(self, file_name, **kwargs):\n with codecs.open(file_name, 'r', 'utf-8') as f:\n content = f.read()\n return self.parse(content, file_name=file_name, **kwargs)","def _create_readme(self, name, summary, description):\n return \"\"\"\n %(header_bar)s\n %(header)s\n %(header_bar)s\n\n %(content)s\n \"\"\" % {\n 'header': name,\n 'header_bar': '=' * len(name),\n 'content': '\\n\\n'.join(\n content\n for content in (summary, description)\n if content\n ) or 'Describe your extension.',\n }","def update_readme(readme: str, updated_metadata: dict = None, extra_lines: list = None):\n metadata, lines = read_readme(readme)\n if updated_metadata:\n metadata = {**metadata, **updated_metadata}\n if extra_lines:\n lines = lines + extra_lines\n write_readme(readme, metadata, lines)","def read(self, source_path):\r\n from cStringIO import StringIO\r\n with pelican_open(source_path) as source:\r\n text = StringIO(source)\r\n content = StringIO()\r\n ad = AsciiDocAPI()\r\n\r\n options = self.settings['ASCIIDOC_OPTIONS']\r\n if isinstance(options, (str, unicode)):\r\n options = [m.strip() for m in options.split(',')]\r\n options = self.default_options + options\r\n for o in options:\r\n ad.options(*o.split())\r\n\r\n ad.execute(text, content, backend=\"html4\")\r\n content = content.getvalue()\r\n\r\n metadata = {}\r\n for name, value in ad.asciidoc.document.attributes.items():\r\n name = name.lower()\r\n metadata[name] = self.process_metadata(name, value)\r\n if 'doctitle' in metadata:\r\n metadata['title'] = metadata['doctitle']\r\n return content, metadata","def parse_markdown(filename):\n if not os.path.exists(filename):\n error('File not found', filename)\n\n posts = list()\n with open(filename, encoding='utf-8') as f:\n line = next(f)\n if line.startswith('# '):\n title = line[2:].strip()\n record = []\n next(f)\n else:\n title = None\n record = [line]\n for line in f:\n if not line.startswith('___'):\n record.append(line)\n else:\n posts.append(Post.from_markdown(record))\n record = []\n\n # set rank of posts in date\n daterank = defaultdict(int)\n for post in posts:\n daterank[post.date] += 1\n post.daterank = daterank[post.date]\n\n # check post order\n for post1, post2 in zip(posts[:-1], posts[1:]):\n if post1.date > post2.date:\n error('Posts are not ordered', f'{post1.date} > {post2.date}')\n\n return title, posts","def hotkeys_readme():\n\n root = '/'.join(__file__.split('/')[:-4])\n fname = root + '/README.rst'\n with codecs.open(fname, 'r', 'utf-8') as f:\n rst = f.read()\n hotkeys = rst.split('.. hotkeys')[1]\n return docutils.examples.html_body(hotkeys)","def read_content(filename):\n # Read file content.\n text = fread(filename)\n\n # Read metadata and save it in a dictionary.\n date_slug = os.path.basename(filename).split('.')[0]\n match = re.search('^(?:(\\\\d\\\\d\\\\d\\\\d-\\\\d\\\\d-\\\\d\\\\d)-)?(.+)$', date_slug)\n content = {\n 'date': format_date(match.group(1) or '1970-01-01'),\n 'date_ymd': match.group(1) or '1970-01-01',\n 'date_rfc_2822': format_date(match.group(1) or '1970-01-01', date_format_override='%a, %d %b %Y %H:%M:%S +0000'),\n 'slug': match.group(2),\n }\n\n # Convert Markdown content to HTML.\n if filename.endswith(('.md', '.mkd', '.mkdn', '.mdown', '.markdown')):\n # Separate text and template variables\n variables, text = separate_content_and_variables(text)\n\n text = variables + \"{% include 'md_header.html' %}\" + \\\n commonmark.commonmark(text) + \"{% include 'md_footer.html' %}\"\n\n # Optional additional parsing\n if 'add_parser' in sys.modules:\n text = add_parser.parse(text, filename)\n\n # Update the dictionary with content text and summary text.\n content.update({\n 'content': text,\n })\n\n return content","def test_readme():\n notebooks_readme = Path(\"notebooks/README.md\").read_text()\n for item in Path(\"notebooks\").iterdir():\n if item.is_dir():\n # item is a notebook directory\n notebook_dir = item.relative_to(\"notebooks\")\n if str(notebook_dir)[0].isdigit():\n assert \"README.md\" in [\n filename.name for filename in item.iterdir()\n ], f\"README not found in {item}\"\n assert (\n str(notebook_dir) in notebooks_readme\n ), f\"{item} not found in notebooks README\"","def fileparse(filename, node):\n\n fd = open(filename)\n line = fd.readline().strip('\\r\\n')\n\n while line != '':\n node.Add(line, node)\n line = fd.readline().strip('\\r\\n')","def read():\n try:\n #Open and parse input files.\n nodeFile = open(sys.argv[1], 'r')\n edgeFile = open(sys.argv[2], 'r')\n\t\n parse_nodes(nodeFile)\n parse_edges(edgeFile)\n nodeFile.close()\n\tedgeFile.close()\n\treturn \n except:\n print 'problem parsing input'\n #Put here some more information - usage...","def test_valid_file(self):\n settings = get_settings(\n PANDOC_EXTENSIONS=PANDOC_EXTENSIONS, PANDOC_ARGS=PANDOC_ARGS\n )\n\n pandoc_reader = PandocReader(settings)\n source_path = os.path.join(TEST_CONTENT_PATH, \"valid_content.md\")\n output, metadata = pandoc_reader.read(source_path)\n\n self.assertEqual(\n (\n \"<p>This is some valid content that should pass.\"\n \" If it does not pass we\"\n \" will know something is wrong.</p>\\n\"\n ),\n output,\n )\n\n self.assertEqual(\"Valid Content\", str(metadata[\"title\"]))\n self.assertEqual(\"My Author\", str(metadata[\"author\"]))\n self.assertEqual(\"2020-10-16 00:00:00\", str(metadata[\"date\"]))","def read(self, filename):\n\n try:\n text = open(filename).read()\n except IOError:\n pass\n else:\n filep = StringIO.StringIO(\"[%s]\\n\" % MAIN_SECTION + text)\n self.readfp(filep, filename)\n return self","def _readme(datatype, fname, overwrite=False):\n if os.path.isfile(fname) and not overwrite:\n with open(fname, \"r\", encoding=\"utf-8-sig\") as fid:\n orig_data = fid.read()\n mne_bids_ref = REFERENCES[\"mne-bids\"] in orig_data\n datatype_ref = REFERENCES[datatype] in orig_data\n if mne_bids_ref and datatype_ref:\n return\n text = \"{}References\\n----------\\n{}{}\".format(\n orig_data + \"\\n\\n\",\n \"\" if mne_bids_ref else REFERENCES[\"mne-bids\"] + \"\\n\\n\",\n \"\" if datatype_ref else REFERENCES[datatype] + \"\\n\",\n )\n else:\n text = \"References\\n----------\\n{}{}\".format(\n REFERENCES[\"mne-bids\"] + \"\\n\\n\", REFERENCES[datatype] + \"\\n\"\n )\n\n _write_text(fname, text, overwrite=True)","def _parse_markdown(self):\n renderer = MyRenderer()\n md = mistune.Markdown(renderer=renderer)\n md.render(self._markdown_text)\n self._bash_commands = renderer._bash_commands","def make_readme(digest):\n o = 'SHA1 digest: %s\\n\\n'%digest[:10]\n print '...build readme file for GitHub' \n open('README.md','w').write(o + make_readme.__doc__)","def parse_design(self, detailed_design_file):","def collect():\n # catch possible bug with --dashes.md\n os.chdir(pathlib.Path(__file__).resolve().parent / 'test')\n for filename in glob.glob('*.md'):\n stem, _ = os.path.splitext(filename)\n args = ['../readme.py', '--timeout=1', '--', filename]\n result = cmd(args)\n obj = normalize(result['output'])\n tmp = obj['tmp']\n lisp = slurp(tmp) if tmp else None\n yield stem, result['exit_code'], obj['out'], lisp","def churn(old_readme: str, /) -> str | None:\n # getting content\n if not (waka_stats := fetch_stats()):\n logger.error('Unable to fetch data, please rerun workflow\\n')\n sys.exit(1)\n # processing content\n try:\n generated_content = prep_content(waka_stats)\n except AttributeError as err:\n logger.error(f'Unable to read API data | {err}\\n')\n sys.exit(1)\n print(generated_content, '\\n', sep='')\n new_readme = re.sub(\n pattern=wk_i.waka_block_pattern,\n repl=f'{wk_i.start_comment}\\n\\n```text\\n{generated_content}\\n```\\n\\n{wk_i.end_comment}',\n string=old_readme\n )\n if len(sys.argv) == 2 and sys.argv[1] == '--dev':\n logger.debug('Detected run in `dev` mode.')\n # to avoid accidentally writing back to Github\n # when developing and testing WakaReadme\n return None\n\n return None if new_readme == old_readme else new_readme","def readmegen(session, sample):\n session.install('jinja2', 'pyyaml')\n\n if os.path.exists(os.path.join(sample, 'requirements.txt')):\n session.install('-r', os.path.join(sample, 'requirements.txt'))\n\n in_file = os.path.join(sample, 'README.rst.in')\n session.run('python', 'scripts/readme-gen/readme_gen.py', in_file)","def load_description():\n with open('description.txt') as description:\n return [line.strip() for line in description]","def read(self, inputfile):\n infile = open(inputfile, 'r')\n if (inputfile.lower().endswith('.po')):\n self.read_po(infile)\n elif (inputfile.lower().endswith('.json')):\n self.read_json(infile)\n elif (inputfile.lower().endswith('.xml')):\n self.read_properties(infile)\n infile.close()","def long_description():\n try:\n return open(join(dirname(__file__), 'README.rst')).read()\n except IOError:\n return LONG_DESCRIPTION","def long_description():\n try:\n return open(join(dirname(__file__), 'README.rst')).read()\n except IOError:\n return LONG_DESCRIPTION","def long_description():\n try:\n return open(join(dirname(__file__), 'README.rst')).read()\n except IOError:\n return LONG_DESCRIPTION","def parse(self, filename):\n infile = file(filename)\n for line in infile:\n self.parseLine(line)","def prepare_agent_readme(agent):\n readme_path = f'{os.path.join(parlai.agents.__path__[0], agent)}/README.md'\n if not os.path.exists(readme_path):\n raise RuntimeError(f'Agent {agent} must have README.md')\n with open(readme_path) as f:\n readme = f.readlines()\n\n if '# ' not in readme[0]:\n readme[0] = f'# {agent}'\n\n return ''.join(readme)","def parse(text: str) -> Docstring:\n ret = Docstring()\n if not text:\n return ret\n\n text = inspect.cleandoc(text)\n match = re.search(\"^:\", text, flags=re.M)\n if match:\n desc_chunk = text[: match.start()]\n meta_chunk = text[match.start() :]\n else:\n desc_chunk = text\n meta_chunk = \"\"\n\n parts = desc_chunk.split(\"\\n\", 1)\n ret.short_description = parts[0] or None\n if len(parts) > 1:\n long_desc_chunk = parts[1] or \"\"\n ret.blank_after_short_description = long_desc_chunk.startswith(\"\\n\")\n ret.blank_after_long_description = long_desc_chunk.endswith(\"\\n\\n\")\n ret.long_description = long_desc_chunk.strip() or None\n\n for match in re.finditer(\n r\"(^:.*?)(?=^:|\\Z)\", meta_chunk, flags=re.S | re.M\n ):\n chunk = match.group(0)\n if not chunk:\n continue\n try:\n args_chunk, desc_chunk = chunk.lstrip(\":\").split(\":\", 1)\n except ValueError:\n raise ParseError(f'Error parsing meta information near \"{chunk}\".')\n args = args_chunk.split()\n desc = desc_chunk.strip()\n if \"\\n\" in desc:\n first_line, rest = desc.split(\"\\n\", 1)\n desc = first_line + \"\\n\" + inspect.cleandoc(rest)\n\n ret.meta.append(_build_meta(args, desc))\n\n return ret","def get_long_description():\n descr = []\n for fname in ('README.rst',):\n with io.open(fname, encoding='utf-8') as f:\n descr.append(f.read())\n return '\\n\\n'.join(descr)","def read_from_file(self, filename: str) -> None:","def make_doc(description=False, sentinel=COMMENT):\n for readme_path in [os.path.abspath(x) for x in glob(\"*/README.md\")]:\n with open(readme_path, \"r+\") as readme_file:\n readme = readme_file.read()\n if sentinel in readme:\n root = os.path.dirname(readme_path)\n tree = make_tree_doc(root)\n pattern = r\"{}.*?\\n(\\w+)?\\n\".format(sentinel)\n text = re.sub(pattern, format_tree(tree), readme, flags=re.DOTALL)\n readme_file.seek(0)\n readme_file.truncate()\n readme_file.write(text)","def _check_missing_readme(self):\n self.msg_args = (self.config.readme_template_url,)\n for readme in DFTL_README_FILES:\n if os.path.isfile(os.path.join(self.module_path, readme)):\n return True\n return False","def get_readme_line(self, test_name, line_match):\n return self.get_output_line(test_name, line_match, \"README\")","def parse_contents(self):\n self.parsed_contents = tokenize(self.contents)[0]"],"string":"[\n \"def parse_readme():\\n # Get the long description from the relevant file\\n readme_path = path.join(here, 'README.md')\\n with codecs.open(readme_path, encoding='utf-8') as handle:\\n desc = handle.read()\\n\\n return desc\",\n \"def test_readme():\\n readme = Path(README_PATH).read_text()\\n Actions.read_from_md(readme)\",\n \"def readme():\\n with open('README.md') as readme_file:\\n return readme_file.read()\",\n \"def readme():\\n with open('README.md') as _file:\\n return _file.read()\",\n \"def readme():\\n\\n with open('README.rst') as readme_file:\\n return readme_file.read()\",\n \"def readme():\\n with open('README.rst') as f:\\n return f.read()\",\n \"def readme(fname='README'):\\n with open(os.path.join(os.path.dirname(__file__), fname)) as file:\\n return file.read()\",\n \"def readme_md(cls):\\n\\n template = Helpers.File(Settings.readme_me_template).read()\\n\\n template = Helpers.Regex(\\n template, r\\\"%%version%%\\\", replace_with=Settings.version\\n ).replace()\\n template = Helpers.Regex(\\n template, r\\\"%%lenHosts%%\\\", replace_with=format(len(Settings.domains), \\\",d\\\")\\n ).replace()\\n template = Helpers.Regex(\\n template, r\\\"%%lenIPs%%\\\", replace_with=format(len(Settings.ips), \\\",d\\\")\\n ).replace()\\n template = Helpers.Regex(\\n template,\\n r\\\"%%lenHostsIPs%%\\\",\\n replace_with=format(len(Settings.ips) + len(Settings.domains), \\\",d\\\"),\\n ).replace()\\n\\n print(\\\"Generation of %s\\\" % Settings.readme_md_file, end=\\\" \\\")\\n Helpers.File(Settings.readme_md_file).write(template, overwrite=True)\\n print(Settings.done)\",\n \"def test_readme_contents():\\n readme = open(\\\"README.md\\\", \\\"r\\\", encoding=\\\"utf-8\\\")\\n readme_words = readme.read().split()\\n readme.close()\\n assert len(readme_words) >= 500, \\\"Make your README.md file interesting! Add atleast 500 words\\\"\",\n \"def _readme_file(self, readme_path=None, proxies=None):\\n if proxies is None:\\n proxies = self._proxies\\n if readme_path is None:\\n readme_path = self._README_PATH\\n url = \\\"{}{}\\\".format(self._url, readme_path)\\n response = self._http.request(url=url, method=\\\"GET\\\", proxies=proxies)\\n if response is None:\\n return False\\n if \\\"Stable tag:\\\" not in response.text:\\n return False\\n version = response.text.split(\\\"Stable tag:\\\")[1].split(\\\"\\\\n\\\")[0] # get the version of the plugin\\n return self.is_vulnerable_version(version)\",\n \"def readme():\\n with open(os.path.join(build_root, 'README.rst')) as f:\\n return f.read()\",\n \"def get_readme():\\n for name in ('README', 'README.rst', 'README.md'):\\n if os.path.exists(name):\\n return read_file(name)\\n return ''\",\n \"def get_readme():\\n for name in ('README', 'README.txt', 'README.rst', 'README.md'):\\n if os.path.exists(name):\\n return read_file(name)\\n return ''\",\n \"def read_readme(setup_file, name=\\\"README.rst\\\"):\\n import os\\n TOP_DIR = os.path.abspath(os.path.dirname(setup_file))\\n if not os.path.exists(TOP_DIR):\\n raise FileNotFoundError(\\n f\\\"Unable to find folder {TOP_DIR!r}.\\\")\\n readme = os.path.join(TOP_DIR, name)\\n if not os.path.exists(readme):\\n raise FileNotFoundError(\\n f\\\"Unable to find file {TOP_DIR!r}.\\\")\\n with open(readme, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n content = f.read()\\n return _clean_readme(content)\",\n \"def test_readme_file_for_formatting():\\n f = open(\\\"README.md\\\", \\\"r\\\", encoding=\\\"utf-8\\\")\\n content = f.read()\\n f.close()\\n assert content.count(\\\"#\\\") >= 10, \\\"Readme is not formatted properly\\\"\",\n \"def readme(self, ref=None):\\r\\n params = base.get_params(None, locals())\\r\\n url = '{0}/readme'.format(self.parent.get_url())\\r\\n\\r\\n return http.Request('GET', url, params), parsers.parse_json\",\n \"def main():\\n parse_file(sys.argv[1])\",\n \"def get_fsleyes_readme():\\n with open(op.join(basedir, 'README.rst'), 'rt', encoding='utf-8') as f:\\n return f.read().strip()\",\n \"def fix_readme(self):\\n import re\\n\\n readme = os.path.join(os.path.dirname(__file__), \\\"README.md\\\")\\n with open(readme, \\\"r\\\") as f:\\n content = f.read()\\n\\n tag = self.get_tag()\\n if not tag:\\n raise AssertionError(\\n \\\"Could not get tag! (are you checking out with full tag history?)\\\"\\n )\\n\\n new_content = re.sub(\\n r\\\"\\\\(docs/\\\",\\n rf\\\"(https://github.com/robocorp/robotframework-lsp/tree/{tag}/robocorp-code/docs/\\\",\\n content,\\n )\\n\\n new_content = re.sub(\\n r\\\"\\\\(images/\\\",\\n rf\\\"(https://raw.githubusercontent.com/robocorp/robotframework-lsp/{tag}/robocorp-code/images/\\\",\\n content,\\n )\\n\\n new_content = new_content.replace(\\n \\\"Apache 2.0\\\",\\n \\\"[Robocorp License Agreement (pdf)](https://cdn.robocorp.com/legal/Robocorp-EULA-v1.0.pdf)\\\",\\n )\\n\\n assert \\\"apache\\\" not in new_content.lower()\\n with open(readme, \\\"w\\\") as f:\\n f.write(new_content)\",\n \"def find_long_description():\\n return read_file('../README.md')\",\n \"def get_readme_text(self):\\n if self.readme_file:\\n readme_text = self.readme_file.read_text(encoding=\\\"utf-8\\\")\\n else:\\n readme_text = \\\"# foxBMS 2 GUI\\\"\\n return readme_text\",\n \"def _get_bids_readme(self):\\n readme = []\\n # Grab all readme files, loop through\\n for README_fname in [\\n file for file in Path(self.dataset.path).glob(\\\"[Rr][Ee][Aa][Dd][Mm][Ee]*\\\")\\n ]:\\n # datalad get content if annexed\\n self.dataset.get(README_fname)\\n # read text from file\\n try:\\n file_text = ensure_unicode(README_fname.read_text()).strip()\\n except:\\n file_text = \\\"\\\"\\n # Append dict with file text + extension to list\\n readme.append({\\\"extension\\\": README_fname.suffix, \\\"text\\\": file_text})\\n return readme if readme else None\",\n \"def test_readme_proper_description():\\n READMELOOKSGOOD = True\\n f = open(\\\"README.md\\\", \\\"r\\\", encoding=\\\"utf-8\\\")\\n content = f.read()\\n f.close()\\n for c in README_CONTENT_CHECK_FOR:\\n if c not in content:\\n print(c)\\n READMELOOKSGOOD = False\\n break\\n\\n assert READMELOOKSGOOD is True, \\\"You have not described all the functions/class well in your README.md file\\\"\",\n \"def get_description():\\n with open(\\\"README.rst\\\", \\\"rb\\\") as readme:\\n long_description = readme.read().decode(\\\"utf-8\\\")\\n return long_description\",\n \"def readme_tests(readme=None):\\n if readme is None:\\n readme = Path('..', 'readme.md')\\n with open(readme) as target:\\n for line in target:\\n if line.startswith(' ') and 'test_utils' not in line:\\n print()\\n print(line)\\n input('Press Enter to execute')\\n sb.run(line, shell=True, check=True)\",\n \"def test_session10_readme_proper_description():\\n READMELOOKSGOOD = True\\n f = open(\\\"README.md\\\", \\\"r\\\", encoding=\\\"utf-8\\\")\\n content = f.read()\\n f.close()\\n for c in README_CONTENT_CHECK_FOR:\\n if c not in content:\\n print(c)\\n READMELOOKSGOOD = False\\n pass\\n assert READMELOOKSGOOD == True, \\\"You have not described all the functions/class well in your README.md file\\\"\",\n \"def readme(self):\\n if \\\"README.md\\\" not in self:\\n ex_msg = \\\"This Package is missing a README file. A Quilt recognized README file is a file named \\\" \\\\\\n \\\"'README.md' (case-insensitive)\\\"\\n raise QuiltException(ex_msg)\\n\\n return self[\\\"README.md\\\"]\",\n \"def parse(self, infile):\\r\\n raise NotImplementedError()\",\n \"def index():\\n\\n # open the README file\\n with open(os.path.dirname(app.root_path) + '/README.md',\\n 'r', encoding=\\\"utf-8\\\") as markdown_file:\\n\\n # Read the content of the file\\n content = markdown_file.read()\\n\\n # convert to html\\n return markdown.markdown(content)\",\n \"def get_long_description():\\n with open(\\\"README.md\\\", \\\"r\\\") as fh:\\n return fh.read()\",\n \"def read(self, filename):\\r\\n with pelican_open(filename) as content:\\r\\n parser = self._HTMLParser(self.settings, filename)\\r\\n parser.feed(content)\\r\\n parser.close()\\r\\n\\r\\n metadata = {}\\r\\n for k in parser.metadata:\\r\\n metadata[k] = self.process_metadata(k, parser.metadata[k])\\r\\n return parser.body, metadata\",\n \"def parse(self, htmlFile):\\n htmlToMdParser = HtmlToMarkdown()\\n htmlToMdParser.readFile(htmlFile)\\n self.__setMarkdownOutput(htmlToMdParser.getMarkdown())\",\n \"def OpenReadMe():\\n location = os.path.join(os.path.dirname(__file__), \\\"README.txt\\\")\\n os.startfile(location)\",\n \"def read_file(file_name):\\r\\n\\r\\n if file_name.find('.md') == -1:\\r\\n file_name += '.md'\\r\\n\\r\\n with open(file_name, 'r', encoding='utf-8') as file:\\r\\n file_data = file.read()\\r\\n\\r\\n return file_data\",\n \"def read(self, filename):\\n\\n # TODO: use markdown reader to parse the reveal.js markdown\\n # github.com/danielfrg/pelican-ipynb/blob/master/markup.py#L62\\n reader = MarkdownReader(self.settings)\\n md_content, metadata = reader.read(filename)\\n\\n # TODO: using the markdown reader converts the file contents to HTML,\\n # but we just want plain text because pandoc should be converting it\\n # instead. The trouble is, we also want to get the metadata\\n\\n extracmd = \\\"\\\"\\n\\n if \\\"theme\\\" in metadata:\\n extracmd = extracmd + \\\" \\\" + \\\"--variable theme=%s\\\" % metadata[\\\"theme\\\"]\\n\\n if \\\"revealoptions\\\" in metadata:\\n if \\\"transition\\\" in metadata[\\\"revealoptions\\\"]:\\n extracmd = (\\n extracmd\\n + \\\" \\\"\\n + \\\"--variable transition=%s\\\"\\n % metadata[\\\"revealoptions\\\"][\\\"transition\\\"]\\n )\\n\\n command = f\\\"pandoc --to revealjs -f markdown {extracmd} {filename}\\\"\\n\\n # Define template for Pelican\\n metadata[\\\"template\\\"] = \\\"revealmd\\\"\\n\\n p = subprocess.Popen(\\n command.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE\\n )\\n\\n try:\\n stdout, stderr = p.communicate(str.encode(\\\"utf8\\\"))\\n except OSError:\\n raise RuntimeError(\\n 'Pandoc died with exitcode \\\"%s\\\" during conversion.' % p.returncode\\n )\\n\\n revealjs_content = stdout.decode(\\\"utf8\\\")\\n\\n # Patch revealjs_content to convert 'back' \\\"{\\\" and \\\"}\\\"\\n returntext = revealjs_content.replace(\\\"%7B\\\", \\\"{\\\").replace(\\\"%7D\\\", \\\"}\\\")\\n\\n return returntext, metadata\",\n \"def test_readme_commands(self, client):\\n with open(REPO_ROOT / \\\"README.md\\\") as f:\\n readme = f.read()\\n\\n documented = set(re.findall(\\\"^- `!([a-z]+)`: .*$\\\", readme, re.MULTILINE))\\n implemented = set(client.commands)\\n\\n assert documented == implemented\",\n \"def read(self, source_path):\\r\\n\\r\\n self._md = Markdown(extensions=self.extensions)\\r\\n with pelican_open(source_path) as text:\\r\\n content = self._md.convert(text)\\r\\n\\r\\n metadata = self._parse_metadata(self._md.Meta)\\r\\n return content, metadata\",\n \"def get_long_description():\\n with open(path.join(root_path, \\\"README.md\\\"), encoding=\\\"utf-8\\\") as f:\\n long_description = f.read()\\n return long_description\",\n \"def _parse(self, infile):\\n raise NotImplementedError()\",\n \"def parse_file(self, file_name: str):\\n if not os.path.exists(file_name):\\n log.error('File {} does not exist'.format(file_name))\\n return None\\n try:\\n with open(file_name) as file:\\n file_content = file.readlines()\\n except Exception as ex:\\n log.error('Failed to read file {}: {}'.format(file_name, str(ex)))\\n return None\\n return self.parse_from_string(''.join(file_content))\",\n \"def _(fname: str) -> str:\\n with open(os.path.join(os.getcwd(), fname)) as readme:\\n content = readme.read() or '' # prevent ``content = None``\\n return content\",\n \"def load_description(path_dir=PATH_ROOT, filename=\\\"DOCS.md\\\"):\\n with open(os.path.join(path_dir, filename)) as f:\\n long_description = f.read()\\n return long_description\",\n \"def OpenReadMe():\\n location = os.path.join(os.path.dirname(__file__), \\\"README.txt\\\")\\n os.startfile(location)\\n return\",\n \"def ler_markdown(nome_do_arquivo):\\n return open(\\\"teste.md\\\").read()\",\n \"def read_markdown_text_file(file_name):\\n \\n with open (file_name, 'r', encoding='utf-16') as fp:\\n htmlmarkdown = markdown.markdown(fp.read())\\n return htmlmarkdown\",\n \"def test_session10_readme_500_words():\\n readme = open(\\\"README.md\\\", \\\"r\\\")\\n readme_words = readme.read().split()\\n readme.close()\\n assert len(readme_words) >= 500, \\\"Make your README.md file interesting! Add atleast 500 words\\\"\",\n \"def test_readme_text_directly(readme_path):\\n code = []\\n code_block = False\\n\\n with open(readme_path, 'r') as f:\\n for line in f:\\n if line.endswith(\\\"```\\\\n\\\"):\\n code_block = False\\n\\n # Add all code lines except for the viz function.\\n if code_block and not line.startswith('viz_neighbors_imgs'):\\n code.append(line)\\n\\n if line.startswith(\\\"```python\\\"):\\n code_block = True\\n\\n exec(('\\\\n').join(code))\",\n \"def _analyze_file(self) -> None:\\n\\n md_reader = MarkdownReader.from_file(self.path)\\n for md_line in md_reader.lines:\\n if len(md_line.current_section) == 1:\\n if self.title and self.title != md_line.current_section[0]:\\n logger.warning(f\\\"{self.path} Warning: Multiple titles. \\\")\\n self.title = md_line.current_section[0]\\n if (\\n not md_line.is_code_block\\n and md_line.text.lower().strip().startswith(\\\"tags: \\\")\\n ):\\n if self.tags:\\n logger.warning(\\n f\\\"{self.path} Warning: Tags were already set.\\\"\\n )\\n self.tags = self._read_tags(md_line.text)\\n if (\\n len(md_line.current_section) >= 2\\n and md_line.current_section[1].lower().strip() == \\\"backlinks\\\"\\n ):\\n pass\\n else:\\n self.links.extend(self.id_link_regex.findall(md_line.text))\",\n \"def html_reader(input_dir):\\r\\n #read data from the html file\\r\\n with open(input_dir,'r') as html_file:\\r\\n content = html_file.read()\\r\\n content = (content.split('\\\\n'))[4:-4]\\r\\n num = re.compile(\\\"(.*\\\\t\\\\d.*)|(\\\\d*\\\\d\\\\.\\\\d*)\\\")\\r\\n information = []\\r\\n for i in range(len(content)):\\r\\n if num.match(content[i])==None:\\r\\n information.append(content[i])\\r\\n information = information[:-1]\\r\\n #data parsing\\r\\n Date = re.compile('( ?CACM|June)')\\r\\n Meta = re.compile(\\\"(CA\\\\d\\\\d\\\\d\\\\d\\\\d\\\\d|June)\\\")\\r\\n #get date and meta index\\r\\n for i in range(len(information)):\\r\\n if Date.match(information[i])!=None:\\r\\n index_date = i\\r\\n if Meta.match(information[i])!=None:\\r\\n index_meta =i\\r\\n content = information[:index_date]\\r\\n others = information[index_date+2:index_meta]\\r\\n for i in range(len(content)):\\r\\n if content[i]==\\\"\\\":\\r\\n title = content[:i]\\r\\n abstract = content[i+1:]\\r\\n break\\r\\n #get author and other\\r\\n author = []\\r\\n other = []\\r\\n for i in range(len(others)):\\r\\n if others[i]==\\\"\\\":\\r\\n if re.match(\\\"[A-Z].*, ?[A-Z].*\\\\..*\\\",others[0]) != None:\\r\\n author = others[:i]\\r\\n other = others[i+1:]\\r\\n else:\\r\\n other = others\\r\\n break\\r\\n for i in range(len(author)):\\r\\n if re.match(\\\"[A-Z].*, ?[A-Z].*\\\\..*\\\",author[i]) != None:\\r\\n name = author[i].split(\\\",\\\")\\r\\n author[i] = (name[1]+name[0])\\r\\n author[i] = author[i].replace(\\\" \\\",\\\"\\\")\\r\\n author[i] = author[i].replace(\\\"\\\\t\\\",\\\"\\\")\\r\\n author[i] = author[i].lower()\\r\\n\\r\\n #parse date\\r\\n date = []\\r\\n date.append(re.search(\\\"19\\\\d\\\\d\\\", information[index_date]).group())\\r\\n date.append(re.search(\\\"(January|February|March|April|May|June|JUly|July|August|September|October|November|December)\\\",information[index_date]).group().lower())\\r\\n\\r\\n #parse meta data\\r\\n meta = []\\r\\n meta.append(re.search(\\\"CA\\\\d\\\\d\\\\d\\\\d\\\\d\\\\d\\\\w?\\\",information[index_meta]).group().lower())#0\\r\\n meta.append(re.search(\\\"[a-z0-9] [A-Z]{2}[A-Z]?\\\",information[index_meta]).group()[2:].lower())#1\\r\\n meta.append(re.search(\\\"(January|February|March|April|May|June|JUly|July|August|September|October|November|December)\\\",information[index_meta]).group().lower())#2\\r\\n meta.append(re.search(\\\"\\\\w \\\\d\\\\d?\\\",information[index_meta]).group()[2:])#3\\r\\n meta.append(re.search(\\\"\\\\d?\\\\d:\\\\d\\\\d\\\",information[index_meta]).group())#4\\r\\n meta.append(re.search(\\\"(AM|PM)\\\",information[index_meta]).group().lower())#5\\r\\n meta.append(re.search(\\\"19\\\\d\\\\d\\\",information[index_meta]).group())#6\\r\\n\\r\\n #build corpus\\r\\n corpus = set()\\r\\n lemmatizer = WordNetLemmatizer()\\r\\n for i in range(len(title)):\\r\\n title[i] = re.sub(\\\"\\\\(|\\\\)|-|\\\\d\\\\d?\\\\d?|:|/|\\\\.|`|\\\\?\\\",\\\" \\\",title[i])\\r\\n words = word_tokenize(title[i])\\r\\n for word in words:\\r\\n normal_word = word.lower()\\r\\n if normal_word not in stopwords.words(\\\"english\\\"):\\r\\n corpus.add(lemmatizer.lemmatize(normal_word))\\r\\n\\r\\n for i in range(len(abstract)):\\r\\n abstract[i] = re.sub(\\\"\\\\(|\\\\)|-|\\\\d\\\\d?\\\\d?|:|/|\\\\.|`|\\\\?|,\\\",\\\" \\\",abstract[i])\\r\\n words = word_tokenize(abstract[i])\\r\\n for word in words:\\r\\n normal_word = word.lower()\\r\\n if normal_word not in stopwords.words(\\\"english\\\"):\\r\\n corpus.add(lemmatizer.lemmatize(normal_word))\\r\\n\\r\\n for i in range(len(other)):\\r\\n other[i] = re.sub(\\\"\\\\(|\\\\)|-|\\\\d\\\\d?\\\\d?|:|/|\\\\.|`|\\\\?|,\\\",\\\" \\\",other[i])\\r\\n words = word_tokenize(other[i])\\r\\n for word in words:\\r\\n normal_word = word.lower()\\r\\n if normal_word not in stopwords.words(\\\"english\\\"):\\r\\n corpus.add(lemmatizer.lemmatize(normal_word))\\r\\n\\r\\n corpus = list(corpus)\\r\\n\\r\\n return paper(author= author, other= other, metadata= meta,date = date,title = title,abstract = abstract,id=int(input_dir[-9:-5]),corpus = corpus)\",\n \"def parse(self, filehandle):\\n l = filehandle.readline()\\n if l.split()[0] != '##maf':\\n return\\n else:\\n self.setpar(l.split()[1:])\\n\\n l=filehandle.readline()\\n while l:\\n la = l.split()\\n## print la\\n if(len(la)==0 or la[0]=='#'):\\n## print \\\"skipping\\\"\\n 1\\n elif(la[0]=='a'):\\n## print \\\"reading alignment\\\"\\n self.readalign(la[1:], filehandle)\\n else:\\n## print \\\"end of records\\\"\\n return\\n\\n l=filehandle.readline()\",\n \"def _parse(self):\\n with open(_join(self.man_dir, self.man_fn)) as fp:\\n lines = fp.readlines()\\n \\n desc_indxs = []\\n for i, L in enumerate(lines):\\n if \\\"#landuse\\\" in L or \\\" # landuse\\\" in L:\\n desc_indxs.append(i-1)\\n desc_indxs.append(i-2)\\n desc_indxs.append(i-3)\\n \\n lines = [L[:L.find('#')].strip() for L in lines]\\n lines = [L for i, L in enumerate(lines) if len(L) > 0 or i in desc_indxs]\\n\\n del desc_indxs\\n \\n self.datver = lines.pop(0)\\n self.nofe = int(lines.pop(0))\\n self.sim_years = int(lines.pop(0))\\n \\n # Read Plant Growth Section\\n self.plants = PlantLoops(lines, self)\\n\\n # Read Operation Section\\n self.ops = OpLoops(lines, self)\\n \\n # Read Initial Condition Section\\n self.inis = IniLoops(lines, self)\\n \\n # Read Surface Effects Section\\n self.surfs = SurfLoops(lines, self)\\n \\n # Read Contour Section\\n self.contours = ContourLoops(lines, self)\\n \\n # Read Drainage Section\\n self.drains = DrainLoops(lines, self)\\n \\n # Read Yearly Section\\n self.years = YearLoops(lines, self)\\n \\n # Read Management Section \\n self.man = ManagementLoop(lines, self)\",\n \"def update_readme():\\n\\n temp = \\\"\\\"\\\"<head>\\n <title>Unittest Results</title>\\n <meta charset=\\\"utf-8\\\">\\n <meta name=\\\"viewport\\\" content=\\\"width=device-width, initial-scale=1.0\\\">\\n <link rel=\\\"stylesheet\\\" href=\\\"https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css\\\" integrity=\\\"sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7\\\" crossorigin=\\\"anonymous\\\">\\n</head>\\\"\\\"\\\"\\n\\n with open(\\\"README_proxy.md\\\", \\\"r\\\") as old_readme_file:\\n old_readme_txt = old_readme_file.read()\\n\\n with open(\\\"reports/test_result.html\\\", \\\"r\\\") as html_file:\\n html = html_file.read().splitlines()[0:-21]\\n html = \\\"\\\\n\\\".join(html).replace(temp, \\\"\\\")\\n\\n with open(\\\"README.md\\\", \\\"w\\\") as new_readme_file:\\n new_readme_file.write(old_readme_txt + \\\"\\\\n\\\\n\\\\n\\\" + html + \\\"</body></html>\\\")\",\n \"def read_file(self):\\n try:\\n with open(self.file_name, 'r') as ach_file:\\n file_contents = ach_file.read().replace('\\\\n', '').replace('\\\\r', '')\\n\\n self._parse_ach_file(file_contents)\\n except FileNotFoundError as err:\\n print(\\\"File does not exist -> \\\" + str(err))\",\n \"def parse_file(self, file_name, **kwargs):\\n with io.open(file_name, 'r', encoding='utf-8') as f:\\n content = f.read()\\n return self.parse(content, file_name=file_name, **kwargs)\",\n \"def make_readme_txt(self, args):\\n with open(self.readme_txt, 'w') as writer:\\n log.info(\\\"args=%s\\\\n\\\", args)\\n writer.write(\\\"# Created by pbtranscript-internal-validation.ValidationRunner.make_readme_txt()\\\\n\\\")\\n writer.write(\\\"args=%s\\\\n\\\\n\\\" % args)\\n\\n files = self.common_files + self.collapse_human_files + self.reseq_human_files + self.sirv_files\\n for desc, fn in files:\\n if op.exists(fn):\\n writer.write(\\\"%s=%s\\\\n\\\" % (desc, fn))\",\n \"def read(self, input): \\n \\n # 1. Assume we have the name of a file in the execution dir or a \\n # file-like object. \\n # Note we need to add parsing of the path to dir/filename \\n try: \\n with File.as_handle(input, 'rU') as fp: \\n file_contents = fp.read() \\n self.filename = getattr(fp, 'name', 'Unknown_nexus_file') \\n except (TypeError, IOError, AttributeError): \\n #2 Assume we have a string from a fh.read() \\n if isinstance(input, basestring): \\n file_contents = input \\n self.filename = 'input_string' \\n else: \\n print(input.strip()[:50]) \\n raise NexusError('Unrecognized input: %s ...' % input[:100]) \\n file_contents = file_contents.strip() \\n if file_contents.startswith('#NEXUS'): \\n file_contents = file_contents[6:] \\n commandlines = _get_command_lines(file_contents) \\n # get rid of stupid 'NEXUS token - in merged treefiles, this might appear multiple times' \\n for i, cl in enumerate(commandlines): \\n try: \\n if cl[:6].upper() == '#NEXUS': \\n commandlines[i] = cl[6:].strip() \\n except: \\n pass \\n # now loop through blocks (we parse only data in known blocks, thus ignoring non-block commands \\n nexus_block_gen = self._get_nexus_block(commandlines) \\n while True: \\n try: \\n title, contents = next(nexus_block_gen) \\n except StopIteration: \\n break \\n if title in KNOWN_NEXUS_BLOCKS: \\n self._parse_nexus_block(title, contents) \\n else: \\n self._unknown_nexus_block(title, contents)\",\n \"def longdescription():\\r\\n print()\\r\\n here = path.abspath(path.dirname(__file__))\\r\\n with open(path.join(here, 'README.rst')) as f:\\r\\n long_description = f.read()\\r\\n\\r\\n print(long_description)\",\n \"def read(self, source_path):\\n\\n self._source_path = source_path\\n self._md = Markdown(extensions=self.extensions)\\n\\n # Custom handling of ^include.html^\\n self._md.inlinePatterns['include_html'] = IncludeHtmlPattern(self)\\n\\n with pelican_open(source_path) as text:\\n content = self._md.convert(text)\\n\\n metadata = self._parse_metadata(self._md.Meta)\\n return content, metadata\",\n \"def parse(self, htmlfile):\\r\\n title_el, summary_el, codesnippet_el = None, None, None\\r\\n soup = BeautifulSoup(htmlfile)\\r\\n if self._is_obsolete(soup):\\r\\n return None\\r\\n title_el = soup.find('h1', class_='page-title')\\r\\n article = soup.find(id='wikiArticle')\\r\\n if article:\\r\\n summary_el = article.find(\\r\\n lambda e: e.name=='p' and e.text.strip() != '', recursive=False)\\r\\n syntax_header = soup.find(id='Syntax')\\r\\n if syntax_header:\\r\\n codesnippet_el = syntax_header.find_next(['pre', 'code'])\\r\\n mdn = MDN()\\r\\n mdn.title = self._extract_node(title_el)\\r\\n mdn.summary = self._extract_node(summary_el)\\r\\n mdn.codesnippet = self._extract_node(codesnippet_el)\\r\\n return mdn\",\n \"def build_readme(comic: str, readme: str) -> str:\\n img = f\\\"{START_COMMENT}\\\\n{comic}\\\\n{END_COMMENT}\\\"\\n return re.sub(listReg, img, readme)\",\n \"def blosxom_entry_parser(filename, request):\\n config = request.getConfiguration()\\n\\n entryData = {}\\n\\n try:\\n story = open(filename).readlines()\\n except IOError:\\n raise IOError\\n\\n if len(story) > 0:\\n entryData['title'] = story.pop(0).strip()\\n\\n # this handles properties of the entry that are between\\n # the title and the body and start with a #\\n while len(story) > 0:\\n match = re.match(r'^#(\\\\w+)\\\\s+(.*)', story[0])\\n if match:\\n story.pop(0)\\n entryData[match.groups()[0]] = match.groups()[1].strip()\\n else:\\n break\\n\\n # Call the preformat function\\n entryData['body'] = tools.run_callback('preformat',\\n {'parser': (entryData.get('parser', '') \\n or config.get('parser', 'plain')),\\n 'story': story,\\n 'request': request},\\n donefunc = lambda x:x != None,\\n defaultfunc = lambda x: ''.join(x['story']))\\n\\n # Call the postformat callbacks\\n tools.run_callback('postformat',\\n {'request': request,\\n 'entry_data': entryData})\\n \\n return entryData\",\n \"def read(self, filename):\\n pass\",\n \"def read(self, filename):\\n pass\",\n \"def run():\\r\\n\\r\\n # Parse options and adjust logging level if necessary\\r\\n options, logging_level = parse_options()\\r\\n if not options: sys.exit(2)\\r\\n logger.setLevel(logging_level)\\r\\n logger.addHandler(logging.StreamHandler())\\r\\n\\r\\n # Run\\r\\n markdown.markdownFromFile(**options)\",\n \"def parse(lines):\\n if len(lines) == 0:\\n return (None, lines)\\n title = lines[0]\\n if len(title) > 0 and \\\"*\\\" == title[0]:\\n level = 1\\n while title[level] == \\\"*\\\":\\n level = level + 1\\n if title[level] != \\\" \\\":\\n return (None, lines)\\n else:\\n heading = title[level+1:]\\n todo = heading[:4] == \\\"TODO\\\"\\n done = heading[:4] == \\\"DONE\\\"\\n if todo or done:\\n heading = heading[4:]\\n return (ORGSection(heading.strip(), level=level, TODO=todo, DONE=done), lines[1:])\\n else:\\n return (None, lines)\",\n \"def test_readme():\\n notebooks_readme = Path(\\\"notebooks/README.md\\\").read_text()\\n for item in Path(\\\"notebooks\\\").iterdir():\\n if item.is_dir():\\n # item is a notebook directory\\n notebook_dir = item.relative_to(\\\"notebooks\\\")\\n if str(notebook_dir)[0].isdigit():\\n assert \\\"README.md\\\" in [filename.name for filename in item.iterdir()], \\\\\\n f\\\"README not found in {item}\\\"\\n assert str(notebook_dir) in notebooks_readme, f\\\"{item} not found in notebooks README\\\"\",\n \"def extract_metadata(file: MarkdownFile) -> MarkdownFile:\\n\\n config_text: str\\n content_text: str\\n config: List[str] = []\\n content: List[str] = []\\n reading_config: bool = False\\n start_block, end_block = \\\"<!--\\\", \\\"-->\\\\n\\\"\\n\\n with open(file.fullpath, \\\"r\\\") as fp:\\n for line in fp.readlines():\\n if reading_config and line == end_block:\\n reading_config = False\\n continue\\n if line.startswith(start_block):\\n if reading_config:\\n raise IOError(f\\\"problem reading config from file {file}\\\")\\n reading_config = True\\n config.append(line.split(start_block)[-1])\\n continue\\n if reading_config:\\n config.append(line)\\n continue\\n if not reading_config:\\n content.append(line)\\n\\n if config:\\n config_text = \\\"\\\".join(config)\\n file.add_metadata(raw=config_text)\\n if content:\\n content_text = \\\"\\\".join(content)\\n file.add_markdown(raw=content_text)\\n return file\",\n \"def parse_file(self, file_name, **kwargs):\\n with codecs.open(file_name, 'r', 'utf-8') as f:\\n content = f.read()\\n return self.parse(content, file_name=file_name, **kwargs)\",\n \"def _create_readme(self, name, summary, description):\\n return \\\"\\\"\\\"\\n %(header_bar)s\\n %(header)s\\n %(header_bar)s\\n\\n %(content)s\\n \\\"\\\"\\\" % {\\n 'header': name,\\n 'header_bar': '=' * len(name),\\n 'content': '\\\\n\\\\n'.join(\\n content\\n for content in (summary, description)\\n if content\\n ) or 'Describe your extension.',\\n }\",\n \"def update_readme(readme: str, updated_metadata: dict = None, extra_lines: list = None):\\n metadata, lines = read_readme(readme)\\n if updated_metadata:\\n metadata = {**metadata, **updated_metadata}\\n if extra_lines:\\n lines = lines + extra_lines\\n write_readme(readme, metadata, lines)\",\n \"def read(self, source_path):\\r\\n from cStringIO import StringIO\\r\\n with pelican_open(source_path) as source:\\r\\n text = StringIO(source)\\r\\n content = StringIO()\\r\\n ad = AsciiDocAPI()\\r\\n\\r\\n options = self.settings['ASCIIDOC_OPTIONS']\\r\\n if isinstance(options, (str, unicode)):\\r\\n options = [m.strip() for m in options.split(',')]\\r\\n options = self.default_options + options\\r\\n for o in options:\\r\\n ad.options(*o.split())\\r\\n\\r\\n ad.execute(text, content, backend=\\\"html4\\\")\\r\\n content = content.getvalue()\\r\\n\\r\\n metadata = {}\\r\\n for name, value in ad.asciidoc.document.attributes.items():\\r\\n name = name.lower()\\r\\n metadata[name] = self.process_metadata(name, value)\\r\\n if 'doctitle' in metadata:\\r\\n metadata['title'] = metadata['doctitle']\\r\\n return content, metadata\",\n \"def parse_markdown(filename):\\n if not os.path.exists(filename):\\n error('File not found', filename)\\n\\n posts = list()\\n with open(filename, encoding='utf-8') as f:\\n line = next(f)\\n if line.startswith('# '):\\n title = line[2:].strip()\\n record = []\\n next(f)\\n else:\\n title = None\\n record = [line]\\n for line in f:\\n if not line.startswith('___'):\\n record.append(line)\\n else:\\n posts.append(Post.from_markdown(record))\\n record = []\\n\\n # set rank of posts in date\\n daterank = defaultdict(int)\\n for post in posts:\\n daterank[post.date] += 1\\n post.daterank = daterank[post.date]\\n\\n # check post order\\n for post1, post2 in zip(posts[:-1], posts[1:]):\\n if post1.date > post2.date:\\n error('Posts are not ordered', f'{post1.date} > {post2.date}')\\n\\n return title, posts\",\n \"def hotkeys_readme():\\n\\n root = '/'.join(__file__.split('/')[:-4])\\n fname = root + '/README.rst'\\n with codecs.open(fname, 'r', 'utf-8') as f:\\n rst = f.read()\\n hotkeys = rst.split('.. hotkeys')[1]\\n return docutils.examples.html_body(hotkeys)\",\n \"def read_content(filename):\\n # Read file content.\\n text = fread(filename)\\n\\n # Read metadata and save it in a dictionary.\\n date_slug = os.path.basename(filename).split('.')[0]\\n match = re.search('^(?:(\\\\\\\\d\\\\\\\\d\\\\\\\\d\\\\\\\\d-\\\\\\\\d\\\\\\\\d-\\\\\\\\d\\\\\\\\d)-)?(.+)$', date_slug)\\n content = {\\n 'date': format_date(match.group(1) or '1970-01-01'),\\n 'date_ymd': match.group(1) or '1970-01-01',\\n 'date_rfc_2822': format_date(match.group(1) or '1970-01-01', date_format_override='%a, %d %b %Y %H:%M:%S +0000'),\\n 'slug': match.group(2),\\n }\\n\\n # Convert Markdown content to HTML.\\n if filename.endswith(('.md', '.mkd', '.mkdn', '.mdown', '.markdown')):\\n # Separate text and template variables\\n variables, text = separate_content_and_variables(text)\\n\\n text = variables + \\\"{% include 'md_header.html' %}\\\" + \\\\\\n commonmark.commonmark(text) + \\\"{% include 'md_footer.html' %}\\\"\\n\\n # Optional additional parsing\\n if 'add_parser' in sys.modules:\\n text = add_parser.parse(text, filename)\\n\\n # Update the dictionary with content text and summary text.\\n content.update({\\n 'content': text,\\n })\\n\\n return content\",\n \"def test_readme():\\n notebooks_readme = Path(\\\"notebooks/README.md\\\").read_text()\\n for item in Path(\\\"notebooks\\\").iterdir():\\n if item.is_dir():\\n # item is a notebook directory\\n notebook_dir = item.relative_to(\\\"notebooks\\\")\\n if str(notebook_dir)[0].isdigit():\\n assert \\\"README.md\\\" in [\\n filename.name for filename in item.iterdir()\\n ], f\\\"README not found in {item}\\\"\\n assert (\\n str(notebook_dir) in notebooks_readme\\n ), f\\\"{item} not found in notebooks README\\\"\",\n \"def fileparse(filename, node):\\n\\n fd = open(filename)\\n line = fd.readline().strip('\\\\r\\\\n')\\n\\n while line != '':\\n node.Add(line, node)\\n line = fd.readline().strip('\\\\r\\\\n')\",\n \"def read():\\n try:\\n #Open and parse input files.\\n nodeFile = open(sys.argv[1], 'r')\\n edgeFile = open(sys.argv[2], 'r')\\n\\t\\n parse_nodes(nodeFile)\\n parse_edges(edgeFile)\\n nodeFile.close()\\n\\tedgeFile.close()\\n\\treturn \\n except:\\n print 'problem parsing input'\\n #Put here some more information - usage...\",\n \"def test_valid_file(self):\\n settings = get_settings(\\n PANDOC_EXTENSIONS=PANDOC_EXTENSIONS, PANDOC_ARGS=PANDOC_ARGS\\n )\\n\\n pandoc_reader = PandocReader(settings)\\n source_path = os.path.join(TEST_CONTENT_PATH, \\\"valid_content.md\\\")\\n output, metadata = pandoc_reader.read(source_path)\\n\\n self.assertEqual(\\n (\\n \\\"<p>This is some valid content that should pass.\\\"\\n \\\" If it does not pass we\\\"\\n \\\" will know something is wrong.</p>\\\\n\\\"\\n ),\\n output,\\n )\\n\\n self.assertEqual(\\\"Valid Content\\\", str(metadata[\\\"title\\\"]))\\n self.assertEqual(\\\"My Author\\\", str(metadata[\\\"author\\\"]))\\n self.assertEqual(\\\"2020-10-16 00:00:00\\\", str(metadata[\\\"date\\\"]))\",\n \"def read(self, filename):\\n\\n try:\\n text = open(filename).read()\\n except IOError:\\n pass\\n else:\\n filep = StringIO.StringIO(\\\"[%s]\\\\n\\\" % MAIN_SECTION + text)\\n self.readfp(filep, filename)\\n return self\",\n \"def _readme(datatype, fname, overwrite=False):\\n if os.path.isfile(fname) and not overwrite:\\n with open(fname, \\\"r\\\", encoding=\\\"utf-8-sig\\\") as fid:\\n orig_data = fid.read()\\n mne_bids_ref = REFERENCES[\\\"mne-bids\\\"] in orig_data\\n datatype_ref = REFERENCES[datatype] in orig_data\\n if mne_bids_ref and datatype_ref:\\n return\\n text = \\\"{}References\\\\n----------\\\\n{}{}\\\".format(\\n orig_data + \\\"\\\\n\\\\n\\\",\\n \\\"\\\" if mne_bids_ref else REFERENCES[\\\"mne-bids\\\"] + \\\"\\\\n\\\\n\\\",\\n \\\"\\\" if datatype_ref else REFERENCES[datatype] + \\\"\\\\n\\\",\\n )\\n else:\\n text = \\\"References\\\\n----------\\\\n{}{}\\\".format(\\n REFERENCES[\\\"mne-bids\\\"] + \\\"\\\\n\\\\n\\\", REFERENCES[datatype] + \\\"\\\\n\\\"\\n )\\n\\n _write_text(fname, text, overwrite=True)\",\n \"def _parse_markdown(self):\\n renderer = MyRenderer()\\n md = mistune.Markdown(renderer=renderer)\\n md.render(self._markdown_text)\\n self._bash_commands = renderer._bash_commands\",\n \"def make_readme(digest):\\n o = 'SHA1 digest: %s\\\\n\\\\n'%digest[:10]\\n print '...build readme file for GitHub' \\n open('README.md','w').write(o + make_readme.__doc__)\",\n \"def parse_design(self, detailed_design_file):\",\n \"def collect():\\n # catch possible bug with --dashes.md\\n os.chdir(pathlib.Path(__file__).resolve().parent / 'test')\\n for filename in glob.glob('*.md'):\\n stem, _ = os.path.splitext(filename)\\n args = ['../readme.py', '--timeout=1', '--', filename]\\n result = cmd(args)\\n obj = normalize(result['output'])\\n tmp = obj['tmp']\\n lisp = slurp(tmp) if tmp else None\\n yield stem, result['exit_code'], obj['out'], lisp\",\n \"def churn(old_readme: str, /) -> str | None:\\n # getting content\\n if not (waka_stats := fetch_stats()):\\n logger.error('Unable to fetch data, please rerun workflow\\\\n')\\n sys.exit(1)\\n # processing content\\n try:\\n generated_content = prep_content(waka_stats)\\n except AttributeError as err:\\n logger.error(f'Unable to read API data | {err}\\\\n')\\n sys.exit(1)\\n print(generated_content, '\\\\n', sep='')\\n new_readme = re.sub(\\n pattern=wk_i.waka_block_pattern,\\n repl=f'{wk_i.start_comment}\\\\n\\\\n```text\\\\n{generated_content}\\\\n```\\\\n\\\\n{wk_i.end_comment}',\\n string=old_readme\\n )\\n if len(sys.argv) == 2 and sys.argv[1] == '--dev':\\n logger.debug('Detected run in `dev` mode.')\\n # to avoid accidentally writing back to Github\\n # when developing and testing WakaReadme\\n return None\\n\\n return None if new_readme == old_readme else new_readme\",\n \"def readmegen(session, sample):\\n session.install('jinja2', 'pyyaml')\\n\\n if os.path.exists(os.path.join(sample, 'requirements.txt')):\\n session.install('-r', os.path.join(sample, 'requirements.txt'))\\n\\n in_file = os.path.join(sample, 'README.rst.in')\\n session.run('python', 'scripts/readme-gen/readme_gen.py', in_file)\",\n \"def load_description():\\n with open('description.txt') as description:\\n return [line.strip() for line in description]\",\n \"def read(self, inputfile):\\n infile = open(inputfile, 'r')\\n if (inputfile.lower().endswith('.po')):\\n self.read_po(infile)\\n elif (inputfile.lower().endswith('.json')):\\n self.read_json(infile)\\n elif (inputfile.lower().endswith('.xml')):\\n self.read_properties(infile)\\n infile.close()\",\n \"def long_description():\\n try:\\n return open(join(dirname(__file__), 'README.rst')).read()\\n except IOError:\\n return LONG_DESCRIPTION\",\n \"def long_description():\\n try:\\n return open(join(dirname(__file__), 'README.rst')).read()\\n except IOError:\\n return LONG_DESCRIPTION\",\n \"def long_description():\\n try:\\n return open(join(dirname(__file__), 'README.rst')).read()\\n except IOError:\\n return LONG_DESCRIPTION\",\n \"def parse(self, filename):\\n infile = file(filename)\\n for line in infile:\\n self.parseLine(line)\",\n \"def prepare_agent_readme(agent):\\n readme_path = f'{os.path.join(parlai.agents.__path__[0], agent)}/README.md'\\n if not os.path.exists(readme_path):\\n raise RuntimeError(f'Agent {agent} must have README.md')\\n with open(readme_path) as f:\\n readme = f.readlines()\\n\\n if '# ' not in readme[0]:\\n readme[0] = f'# {agent}'\\n\\n return ''.join(readme)\",\n \"def parse(text: str) -> Docstring:\\n ret = Docstring()\\n if not text:\\n return ret\\n\\n text = inspect.cleandoc(text)\\n match = re.search(\\\"^:\\\", text, flags=re.M)\\n if match:\\n desc_chunk = text[: match.start()]\\n meta_chunk = text[match.start() :]\\n else:\\n desc_chunk = text\\n meta_chunk = \\\"\\\"\\n\\n parts = desc_chunk.split(\\\"\\\\n\\\", 1)\\n ret.short_description = parts[0] or None\\n if len(parts) > 1:\\n long_desc_chunk = parts[1] or \\\"\\\"\\n ret.blank_after_short_description = long_desc_chunk.startswith(\\\"\\\\n\\\")\\n ret.blank_after_long_description = long_desc_chunk.endswith(\\\"\\\\n\\\\n\\\")\\n ret.long_description = long_desc_chunk.strip() or None\\n\\n for match in re.finditer(\\n r\\\"(^:.*?)(?=^:|\\\\Z)\\\", meta_chunk, flags=re.S | re.M\\n ):\\n chunk = match.group(0)\\n if not chunk:\\n continue\\n try:\\n args_chunk, desc_chunk = chunk.lstrip(\\\":\\\").split(\\\":\\\", 1)\\n except ValueError:\\n raise ParseError(f'Error parsing meta information near \\\"{chunk}\\\".')\\n args = args_chunk.split()\\n desc = desc_chunk.strip()\\n if \\\"\\\\n\\\" in desc:\\n first_line, rest = desc.split(\\\"\\\\n\\\", 1)\\n desc = first_line + \\\"\\\\n\\\" + inspect.cleandoc(rest)\\n\\n ret.meta.append(_build_meta(args, desc))\\n\\n return ret\",\n \"def get_long_description():\\n descr = []\\n for fname in ('README.rst',):\\n with io.open(fname, encoding='utf-8') as f:\\n descr.append(f.read())\\n return '\\\\n\\\\n'.join(descr)\",\n \"def read_from_file(self, filename: str) -> None:\",\n \"def make_doc(description=False, sentinel=COMMENT):\\n for readme_path in [os.path.abspath(x) for x in glob(\\\"*/README.md\\\")]:\\n with open(readme_path, \\\"r+\\\") as readme_file:\\n readme = readme_file.read()\\n if sentinel in readme:\\n root = os.path.dirname(readme_path)\\n tree = make_tree_doc(root)\\n pattern = r\\\"{}.*?\\\\n(\\\\w+)?\\\\n\\\".format(sentinel)\\n text = re.sub(pattern, format_tree(tree), readme, flags=re.DOTALL)\\n readme_file.seek(0)\\n readme_file.truncate()\\n readme_file.write(text)\",\n \"def _check_missing_readme(self):\\n self.msg_args = (self.config.readme_template_url,)\\n for readme in DFTL_README_FILES:\\n if os.path.isfile(os.path.join(self.module_path, readme)):\\n return True\\n return False\",\n \"def get_readme_line(self, test_name, line_match):\\n return self.get_output_line(test_name, line_match, \\\"README\\\")\",\n \"def parse_contents(self):\\n self.parsed_contents = tokenize(self.contents)[0]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7862639","0.69449455","0.6925098","0.6874095","0.6678023","0.6647286","0.65171206","0.64888984","0.6395882","0.6373797","0.6318565","0.6261154","0.62290794","0.6200871","0.61734515","0.61639285","0.6114276","0.60170484","0.5915927","0.5900081","0.5895074","0.58933544","0.58639205","0.5854984","0.58304167","0.5813274","0.5789471","0.5748582","0.5697627","0.5688108","0.5680357","0.56617385","0.5596978","0.5590882","0.5582958","0.55764204","0.55719954","0.5570454","0.5570268","0.5568405","0.5558198","0.55465525","0.553071","0.5487316","0.54719055","0.54718494","0.5462843","0.544492","0.54228395","0.54219866","0.53803307","0.53781956","0.5360787","0.5352107","0.5350142","0.5344142","0.5343379","0.53369504","0.53298503","0.53245544","0.5311899","0.53118646","0.53118646","0.53104603","0.5306638","0.53060174","0.53018504","0.5300596","0.52941597","0.52935195","0.5279914","0.52634734","0.52592206","0.5256865","0.5244998","0.52427816","0.5237194","0.52145725","0.5207284","0.52034575","0.52006936","0.5200354","0.5185514","0.5182306","0.51791793","0.5177571","0.5176721","0.51706976","0.5146298","0.5146298","0.5146298","0.51413745","0.5122478","0.51147723","0.51130086","0.50953394","0.50928795","0.50890195","0.5084762","0.5077284"],"string":"[\n \"0.7862639\",\n \"0.69449455\",\n \"0.6925098\",\n \"0.6874095\",\n \"0.6678023\",\n \"0.6647286\",\n \"0.65171206\",\n \"0.64888984\",\n \"0.6395882\",\n \"0.6373797\",\n \"0.6318565\",\n \"0.6261154\",\n \"0.62290794\",\n \"0.6200871\",\n \"0.61734515\",\n \"0.61639285\",\n \"0.6114276\",\n \"0.60170484\",\n \"0.5915927\",\n \"0.5900081\",\n \"0.5895074\",\n \"0.58933544\",\n \"0.58639205\",\n \"0.5854984\",\n \"0.58304167\",\n \"0.5813274\",\n \"0.5789471\",\n \"0.5748582\",\n \"0.5697627\",\n \"0.5688108\",\n \"0.5680357\",\n \"0.56617385\",\n \"0.5596978\",\n \"0.5590882\",\n \"0.5582958\",\n \"0.55764204\",\n \"0.55719954\",\n \"0.5570454\",\n \"0.5570268\",\n \"0.5568405\",\n \"0.5558198\",\n \"0.55465525\",\n \"0.553071\",\n \"0.5487316\",\n \"0.54719055\",\n \"0.54718494\",\n \"0.5462843\",\n \"0.544492\",\n \"0.54228395\",\n \"0.54219866\",\n \"0.53803307\",\n \"0.53781956\",\n \"0.5360787\",\n \"0.5352107\",\n \"0.5350142\",\n \"0.5344142\",\n \"0.5343379\",\n \"0.53369504\",\n \"0.53298503\",\n \"0.53245544\",\n \"0.5311899\",\n \"0.53118646\",\n \"0.53118646\",\n \"0.53104603\",\n \"0.5306638\",\n \"0.53060174\",\n \"0.53018504\",\n \"0.5300596\",\n \"0.52941597\",\n \"0.52935195\",\n \"0.5279914\",\n \"0.52634734\",\n \"0.52592206\",\n \"0.5256865\",\n \"0.5244998\",\n \"0.52427816\",\n \"0.5237194\",\n \"0.52145725\",\n \"0.5207284\",\n \"0.52034575\",\n \"0.52006936\",\n \"0.5200354\",\n \"0.5185514\",\n \"0.5182306\",\n \"0.51791793\",\n \"0.5177571\",\n \"0.5176721\",\n \"0.51706976\",\n \"0.5146298\",\n \"0.5146298\",\n \"0.5146298\",\n \"0.51413745\",\n \"0.5122478\",\n \"0.51147723\",\n \"0.51130086\",\n \"0.50953394\",\n \"0.50928795\",\n \"0.50890195\",\n \"0.5084762\",\n \"0.5077284\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66518"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":83180,"cells":{"query":{"kind":"string","value":"Create a new readme file with supplied information."},"document":{"kind":"string","value":"def write_readme(readme: str, metadata: dict, lines: list = None):\n with open(readme, \"w\") as f:\n for k, v in metadata.items():\n print(f\"{k}: {v}\", file=f)\n if lines:\n for line in lines:\n print(line, file=f)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def make_readme_txt(self, args):\n with open(self.readme_txt, 'w') as writer:\n log.info(\"args=%s\\n\", args)\n writer.write(\"# Created by pbtranscript-internal-validation.ValidationRunner.make_readme_txt()\\n\")\n writer.write(\"args=%s\\n\\n\" % args)\n\n files = self.common_files + self.collapse_human_files + self.reseq_human_files + self.sirv_files\n for desc, fn in files:\n if op.exists(fn):\n writer.write(\"%s=%s\\n\" % (desc, fn))","def create_readme(case_dict):\n # ---------------------------------------------------------------------\n logger.debug(\"create_readme\")\n os.chdir(case_dict[\"archive_temp_dir\"])\n\n fname = open(\"README.archive\", \"w\")\n fname.write(\"Archived metadata is available for this case at URL:\\n\")\n fname.write(case_dict[\"base_expdb_url\"])\n fname.close()","def make_readme(digest):\n o = 'SHA1 digest: %s\\n\\n'%digest[:10]\n print '...build readme file for GitHub' \n open('README.md','w').write(o + make_readme.__doc__)","def readme_md(cls):\n\n template = Helpers.File(Settings.readme_me_template).read()\n\n template = Helpers.Regex(\n template, r\"%%version%%\", replace_with=Settings.version\n ).replace()\n template = Helpers.Regex(\n template, r\"%%lenHosts%%\", replace_with=format(len(Settings.domains), \",d\")\n ).replace()\n template = Helpers.Regex(\n template, r\"%%lenIPs%%\", replace_with=format(len(Settings.ips), \",d\")\n ).replace()\n template = Helpers.Regex(\n template,\n r\"%%lenHostsIPs%%\",\n replace_with=format(len(Settings.ips) + len(Settings.domains), \",d\"),\n ).replace()\n\n print(\"Generation of %s\" % Settings.readme_md_file, end=\" \")\n Helpers.File(Settings.readme_md_file).write(template, overwrite=True)\n print(Settings.done)","def create_readme(histfile, vb):\n\tme = \"Utils.create_readme: \"\n\treadmefile = os.path.dirname(histfile)+\"/README.txt\"\n\ttry:\n\t\tassert os.path.isfile(readmefile)\n\texcept AssertionError:\n\t\tnow = str(datetime.now().strftime(\"%Y-%m-%d %H.%M\"))\n\t\tcommit = subprocess.check_output(['git', 'rev-parse', 'HEAD'])\n\t\theader = \"Time:\\t\"+now+\"\\nCommit hash:\\t\"+commit+\"\\n\\n\"\n\t\twith open(readmefile,\"w\") as f:\n\t\t\tf.write(header)\n\t\tif vb: print me+\"Created readme file \"+readmefile\n\treturn","def _write_readme(variables):\n with open(locations.readme_template) as source:\n with open(locations.readme, \"w\") as destination:\n contents = source.read()\n contents = contents.format(**variables)\n destination.write(contents)","def create_readme(self) -> None:\n # read the readme file and update the version and description\n with open(CONFIG.template_path / \"README.md\", \"r\") as f:\n TEMPLATE_README = f.read()\n\n # add a readme with the names of the stub-folders\n\n # read informations from firmware_stubs.json\n firmware_stubs = {}\n doc_stubs = {}\n core_stubs = {}\n try:\n with open(self.package_path / \"firmware_stubs.json\", \"r\") as f:\n firmware_stubs = json.load(f)\n with open(self.package_path / \"doc_stubs.json\", \"r\") as f:\n doc_stubs = json.load(f)\n with open(self.package_path / \"modules.json\", \"r\") as f:\n core_stubs = json.load(f)\n except FileNotFoundError:\n pass\n\n # Prettify this by merging with template text\n with open(self.package_path / \"README.md\", \"w\") as f:\n f.write(f\"# {self.package_name}\\n\\n\")\n f.write(TEMPLATE_README)\n f.write(f\"Included stubs:\\n\")\n for name, folder in self.stub_sources:\n f.write(f\"* {name} from `stubs/{Path(folder).as_posix()}`\\n\")\n\n f.write(f\"\\n\\n\")\n f.write(f\"origin | Family | Port | Board | Version\\n\")\n f.write(f\"-------|--------|------|-------|--------\\n\")\n try:\n f.write(\n f\"Firmware | {firmware_stubs['firmware']['family']} | {firmware_stubs['firmware']['port']} | {firmware_stubs['firmware']['machine']} | {clean_version(firmware_stubs['firmware']['version'])} \\n\"\n )\n except Exception:\n pass\n try:\n f.write(\n f\"Documentation | {doc_stubs['firmware']['family']} | {doc_stubs['firmware']['port']} | - | {clean_version(doc_stubs['firmware']['version'])} \\n\"\n )\n except Exception:\n pass\n try:\n f.write(\n f\"Core | {core_stubs['firmware']['family']} | {core_stubs['firmware']['port']} | - | {clean_version(core_stubs['firmware']['version'])} \\n\"\n )\n except Exception:\n pass","def _create_readme(self, name, summary, description):\n return \"\"\"\n %(header_bar)s\n %(header)s\n %(header_bar)s\n\n %(content)s\n \"\"\" % {\n 'header': name,\n 'header_bar': '=' * len(name),\n 'content': '\\n\\n'.join(\n content\n for content in (summary, description)\n if content\n ) or 'Describe your extension.',\n }","def with_readme(request, new_package):\n\n new_module, pkg_root = new_package\n pkg_name = os.path.basename(pkg_root)\n\n with open(os.path.join(new_module, \"README\"), \"w\") as openreadme:\n openreadme.write(\"{n}\\n{d}\\n\\n{n}'s readme... with content!\".format(\n n=pkg_name,\n d=\"=\" * len(pkg_name),\n ))\n\n with open(os.path.join(new_module, META_NAME), \"w\") as openmeta:\n openmeta.write(\n '{\"packages\": [\"find_packages()\"], \"long_description\": \"README\"}'\n )\n\n request.addfinalizer(module_cleanup)\n return new_module, pkg_root","def readme():\n with open('README.md') as readme_file:\n return readme_file.read()","def readmegen(session, sample):\n session.install('jinja2', 'pyyaml')\n\n if os.path.exists(os.path.join(sample, 'requirements.txt')):\n session.install('-r', os.path.join(sample, 'requirements.txt'))\n\n in_file = os.path.join(sample, 'README.rst.in')\n session.run('python', 'scripts/readme-gen/readme_gen.py', in_file)","def readme():\n with open('README.md') as _file:\n return _file.read()","def readme():\n\n with open('README.rst') as readme_file:\n return readme_file.read()","def test_readme():\n readme = Path(README_PATH).read_text()\n Actions.read_from_md(readme)","def update_readme():\n\n temp = \"\"\"<head>\n <title>Unittest Results</title>\n <meta charset=\"utf-8\">\n <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n <link rel=\"stylesheet\" href=\"https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css\" integrity=\"sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7\" crossorigin=\"anonymous\">\n</head>\"\"\"\n\n with open(\"README_proxy.md\", \"r\") as old_readme_file:\n old_readme_txt = old_readme_file.read()\n\n with open(\"reports/test_result.html\", \"r\") as html_file:\n html = html_file.read().splitlines()[0:-21]\n html = \"\\n\".join(html).replace(temp, \"\")\n\n with open(\"README.md\", \"w\") as new_readme_file:\n new_readme_file.write(old_readme_txt + \"\\n\\n\\n\" + html + \"</body></html>\")","def readme():\n with open(os.path.join(build_root, 'README.rst')) as f:\n return f.read()","def update_readme(readme: str, updated_metadata: dict = None, extra_lines: list = None):\n metadata, lines = read_readme(readme)\n if updated_metadata:\n metadata = {**metadata, **updated_metadata}\n if extra_lines:\n lines = lines + extra_lines\n write_readme(readme, metadata, lines)","def readme():\n with open('README.rst') as f:\n return f.read()","def fix_readme(self):\n import re\n\n readme = os.path.join(os.path.dirname(__file__), \"README.md\")\n with open(readme, \"r\") as f:\n content = f.read()\n\n tag = self.get_tag()\n if not tag:\n raise AssertionError(\n \"Could not get tag! (are you checking out with full tag history?)\"\n )\n\n new_content = re.sub(\n r\"\\(docs/\",\n rf\"(https://github.com/robocorp/robotframework-lsp/tree/{tag}/robocorp-code/docs/\",\n content,\n )\n\n new_content = re.sub(\n r\"\\(images/\",\n rf\"(https://raw.githubusercontent.com/robocorp/robotframework-lsp/{tag}/robocorp-code/images/\",\n content,\n )\n\n new_content = new_content.replace(\n \"Apache 2.0\",\n \"[Robocorp License Agreement (pdf)](https://cdn.robocorp.com/legal/Robocorp-EULA-v1.0.pdf)\",\n )\n\n assert \"apache\" not in new_content.lower()\n with open(readme, \"w\") as f:\n f.write(new_content)","def make_doc(description=False, sentinel=COMMENT):\n for readme_path in [os.path.abspath(x) for x in glob(\"*/README.md\")]:\n with open(readme_path, \"r+\") as readme_file:\n readme = readme_file.read()\n if sentinel in readme:\n root = os.path.dirname(readme_path)\n tree = make_tree_doc(root)\n pattern = r\"{}.*?\\n(\\w+)?\\n\".format(sentinel)\n text = re.sub(pattern, format_tree(tree), readme, flags=re.DOTALL)\n readme_file.seek(0)\n readme_file.truncate()\n readme_file.write(text)","def create_about():\n meta_desc = (\n 'Expected values and probability per lap of step-up banners'\n ' in Final Fantasy Brave Exvius (FFBE)')\n template_vars = {\n 'title' : 'About - ' + sitesettings.SITE_NAME,\n 'siteurl' : sitesettings.SITE_URL,\n 'sitename' : sitesettings.SITE_NAME,\n 'meta_desc' : meta_desc,\n 'last_four_banners' : nav.get_last_four_banners('all'),\n }\n\n about_path = os.path.join(sitesettings.LOCAL_FILE_PATH, 'about')\n\n if not os.path.exists(about_path):\n os.makedirs(about_path)\n\n template_file = 'about.html'\n html_file_loc = os.path.join(about_path, 'index.html')\n generatehtml.generate_html(\n html_file_loc, template_file, template_vars, os.path.join(os.getcwd(), 'templates'))","def readme(fname='README'):\n with open(os.path.join(os.path.dirname(__file__), fname)) as file:\n return file.read()","def _readme(datatype, fname, overwrite=False):\n if os.path.isfile(fname) and not overwrite:\n with open(fname, \"r\", encoding=\"utf-8-sig\") as fid:\n orig_data = fid.read()\n mne_bids_ref = REFERENCES[\"mne-bids\"] in orig_data\n datatype_ref = REFERENCES[datatype] in orig_data\n if mne_bids_ref and datatype_ref:\n return\n text = \"{}References\\n----------\\n{}{}\".format(\n orig_data + \"\\n\\n\",\n \"\" if mne_bids_ref else REFERENCES[\"mne-bids\"] + \"\\n\\n\",\n \"\" if datatype_ref else REFERENCES[datatype] + \"\\n\",\n )\n else:\n text = \"References\\n----------\\n{}{}\".format(\n REFERENCES[\"mne-bids\"] + \"\\n\\n\", REFERENCES[datatype] + \"\\n\"\n )\n\n _write_text(fname, text, overwrite=True)","def OpenReadMe():\n location = os.path.join(os.path.dirname(__file__), \"README.txt\")\n os.startfile(location)","def create(contents, title, path=\"\"):\n filename = secure_filename(title)\n data_dir = get_data_dir()\n max_filename_length = 255\n if len(filename + \".md\") > max_filename_length:\n filename = filename[0 : max_filename_length - 3]\n if not is_relative_to(data_dir / path, data_dir):\n path = \"\"\n path_to_md_file = data_dir / path / f\"{filename}.md\"\n with open(path_to_md_file, \"w\", encoding=\"utf-8\") as file:\n file.write(contents)\n\n return path_to_md_file","def build_readme(comic: str, readme: str) -> str:\n img = f\"{START_COMMENT}\\n{comic}\\n{END_COMMENT}\"\n return re.sub(listReg, img, readme)","def OpenReadMe():\n location = os.path.join(os.path.dirname(__file__), \"README.txt\")\n os.startfile(location)\n return","def new(cli):\n __check_in_autonotes_dir()\n\n # Filename\n filename = cli.config.new.filename\n file_date = datetime.now().strftime(\"%Y%m%d\")\n today = datetime.now().strftime(\"%b %d\")\n if not cli.config.new.no_date:\n filename += f'-{file_date}'\n filename += '.tex'\n if os.path.exists(filename):\n cli.log.error(f'File {emph(filename)} already exists.')\n exit(1)\n\n # Note title\n title = cli.config.new.title\n if title == '':\n title = f'Untitled {cli.config.new.filename}'\n\n # Open file for writing\n file = open(filename, 'w')\n cli.log.info(f'Created {emph(filename)}')\n new_note_str = f'% {filename}\\n\\n' \\\n '\\\\section{' \\\n f'{title.replace(\"_\", \" \")}' \\\n '}\\n' \\\n '\\\\marginnote{' \\\n f'{today}' \\\n '\\\\index{' \\\n f'{today}' \\\n '}}[.2cm]\\n'\n file.write(new_note_str)\n file.close()\n\n # Add the new file to master.tex\n __add([filename])","def prepare_agent_readme(agent):\n readme_path = f'{os.path.join(parlai.agents.__path__[0], agent)}/README.md'\n if not os.path.exists(readme_path):\n raise RuntimeError(f'Agent {agent} must have README.md')\n with open(readme_path) as f:\n readme = f.readlines()\n\n if '# ' not in readme[0]:\n readme[0] = f'# {agent}'\n\n return ''.join(readme)","def get_readme():\n for name in ('README', 'README.rst', 'README.md'):\n if os.path.exists(name):\n return read_file(name)\n return ''","def get_readme():\n for name in ('README', 'README.txt', 'README.rst', 'README.md'):\n if os.path.exists(name):\n return read_file(name)\n return ''","def create_new(self, name):\n validate_name(name, self.__class__.__name__)\n self.data = {\n \"author_name\": \"\",\n \"author_email\": \"\",\n \"git_profile_url\": \"\",\n \"starting_version\": \"0.1.0\",\n \"default_description\": \"My project, created using nusex\",\n \"preferred_license\": \"unlicense\",\n }","def get_fsleyes_readme():\n with open(op.join(basedir, 'README.rst'), 'rt', encoding='utf-8') as f:\n return f.read().strip()","def deploy(version):\n toolkit.readmegen(version)","def churn(old_readme: str, /) -> str | None:\n # getting content\n if not (waka_stats := fetch_stats()):\n logger.error('Unable to fetch data, please rerun workflow\\n')\n sys.exit(1)\n # processing content\n try:\n generated_content = prep_content(waka_stats)\n except AttributeError as err:\n logger.error(f'Unable to read API data | {err}\\n')\n sys.exit(1)\n print(generated_content, '\\n', sep='')\n new_readme = re.sub(\n pattern=wk_i.waka_block_pattern,\n repl=f'{wk_i.start_comment}\\n\\n```text\\n{generated_content}\\n```\\n\\n{wk_i.end_comment}',\n string=old_readme\n )\n if len(sys.argv) == 2 and sys.argv[1] == '--dev':\n logger.debug('Detected run in `dev` mode.')\n # to avoid accidentally writing back to Github\n # when developing and testing WakaReadme\n return None\n\n return None if new_readme == old_readme else new_readme","def argparser_to_readme(\n argparser: Callable[[], ArgumentParser],\n template: str = \"README-template.md\",\n destination: str = \"README.md\",\n indentation: int = 0,\n placeholder: str = \"{{ argparse }}\",\n) -> None:\n help_string = argparser().format_help()\n\n if indentation > 0:\n indent_lines: List[str] = []\n lines = help_string.split(\"\\n\")\n for line in lines:\n indent_lines.append(\" \" * indentation + line)\n\n help_string = \"\\n\".join(indent_lines)\n\n with open(template, \"r\", encoding=\"utf-8\") as template_file:\n template_string = template_file.read()\n readme = template_string.replace(placeholder, help_string)\n\n readme_file = open(destination, \"w\")\n readme_file.write(readme)\n readme_file.close()","def get_readme_text(self):\n if self.readme_file:\n readme_text = self.readme_file.read_text(encoding=\"utf-8\")\n else:\n readme_text = \"# foxBMS 2 GUI\"\n return readme_text","def main(src_file=\"README.md\", dst_file=\"docs/documentation.json\"):\n with open(src_file, \"r\") as readme:\n markdown = readme.read()\n\n data = {\n \"info\": {\n \"termsOfService\": \"https://github.com/bombsimon/redoc-theme\",\n \"description\": markdown,\n \"license\": {\n \"url\": \"https://opensource.org/licenses/MIT\",\n \"name\": \"MIT\",\n },\n \"title\": \"ReDoc Theme\",\n \"version\": \"1.0\",\n \"contact\": {\"email\": \"simon@sawert.se\"},\n \"x-logo\": {\"url\": \"assets/logo.png\"},\n },\n \"swagger\": \"2.0\",\n }\n\n with open(dst_file, \"w\") as doc_json:\n json.dump(data, doc_json, indent=2)","def read_readme(setup_file, name=\"README.rst\"):\n import os\n TOP_DIR = os.path.abspath(os.path.dirname(setup_file))\n if not os.path.exists(TOP_DIR):\n raise FileNotFoundError(\n f\"Unable to find folder {TOP_DIR!r}.\")\n readme = os.path.join(TOP_DIR, name)\n if not os.path.exists(readme):\n raise FileNotFoundError(\n f\"Unable to find file {TOP_DIR!r}.\")\n with open(readme, \"r\", encoding=\"utf-8\") as f:\n content = f.read()\n return _clean_readme(content)","def readme(self, ref=None):\r\n params = base.get_params(None, locals())\r\n url = '{0}/readme'.format(self.parent.get_url())\r\n\r\n return http.Request('GET', url, params), parsers.parse_json","def parse_readme():\n # Get the long description from the relevant file\n readme_path = path.join(here, 'README.md')\n with codecs.open(readme_path, encoding='utf-8') as handle:\n desc = handle.read()\n\n return desc","def __init__(self, name=''):\r\n if name:\r\n self.file_name = name + '.md'\r\n self.file = open(self.file_name, 'w+', encoding='UTF-8')\r\n self.file.close()","def create_new_python_project():\n\t# Create the different variables\n\tfolder_name = str(sys.argv[1])\n\tdir_name = my_project_folder + folder_name\n\tpy_file = dir_name + '/' + folder_name + '.py'\n\treadme_file = dir_name + '/' + 'README.md'\n\ttodo_file = dir_name + '/' + 'TODO.txt'\n\n\t# Create directory if it does not exist yet\n\tif not os.path.exists(dir_name):\n\t\tos.mkdir(dir_name)\n\t\tprint(\"Directory \" , dir_name , \" Created \")\n\n\t\t# Create Python file\n\t\tdata = ''\n\t\twith open(template_py, 'r') as file:\n\t\t\tdata += file.read()\n\n\t\twith open(py_file, 'w') as f:\n\t\t\tf.write(data)\n\t\t\tprint(\"Python file created\")\n\n\t\t# Create README file\n\t\tdata = ''\n\t\twith open(template_readme, 'r') as file:\n\t\t\tdata += file.read()\n\n\t\twith open(readme_file, 'w') as f:\n\t\t\tf.write(data)\n\t\t\tprint(\"Readme file created\")\n\n\t\t# Create Todo file\n\t\twith open(todo_file, 'w') as f:\n\t\t\tprint(\"TODO file created\")\n\n\t\t# Create Github repo\n\t\twith open(\".env\", \"r\") as f:\n\t\t\tdata = f.read()\n\n\t\tindex_1 = data.find('TOKEN=\"') + len('TOKEN=\"')\n\t\ttoken = data[index_1:-1]\n\t\tg = Github(token)\n\t\tuser = g.get_user()\n\t\trepo = user.create_repo(folder_name)\n\t\tprint(\"Succesfully created repository {}\".format(folder_name))\n\n\n\telse: \n\t\tprint(\"Directory \" , dir_name , \" already exists\")","def read_readme(readme: str) -> Tuple[dict, list]:\n metadata = {\n \"name\": \"na\",\n \"provider\": \"na\",\n \"original name\": \"na\",\n \"original filename\": \"na\",\n \"assembly_accession\": \"na\",\n \"tax_id\": \"na\",\n \"mask\": \"na\",\n \"genome url\": \"na\",\n \"annotation url\": \"na\",\n \"sanitized annotation\": \"na\",\n \"genomepy version\": \"na\",\n \"date\": \"na\",\n }\n lines = []\n\n if not os.path.exists(readme):\n return metadata, lines\n\n # if the readme exists, overwrite all metadata fields found\n with open(readme) as f:\n for line in f.readlines():\n if \": \" in line:\n vals = line.strip().split(\": \")\n metadata[vals[0].strip()] = (\": \".join(vals[1:])).strip()\n else:\n line = line.strip(\"\\n\").strip(\" \")\n # blank lines are allowed, but only one in a row\n if not (\n line == \"\"\n and len(lines) > 0\n and lines[len(lines) - 1].strip() == \"\"\n ):\n lines.append(line)\n\n return metadata, lines","def test_readme_contents():\n readme = open(\"README.md\", \"r\", encoding=\"utf-8\")\n readme_words = readme.read().split()\n readme.close()\n assert len(readme_words) >= 500, \"Make your README.md file interesting! Add atleast 500 words\"","def hotkeys_readme():\n\n root = '/'.join(__file__.split('/')[:-4])\n fname = root + '/README.rst'\n with codecs.open(fname, 'r', 'utf-8') as f:\n rst = f.read()\n hotkeys = rst.split('.. hotkeys')[1]\n return docutils.examples.html_body(hotkeys)","def test_readmeExamplesAreExecutable(self) -> None:\n temporary_code = extract_code_from_readme()\n globals_for_exec = {\"__name__\": \"README.md\"}\n\n try:\n exec(temporary_code, globals_for_exec)\n except Exception:\n print(\">>> Found error in generated readme code file\",\n file=sys.stderr)\n print(temporary_code, file=sys.stderr)\n raise","def create_file(date, title, text, n):\r\n \"\"\"with date as file name and text as content\"\"\"\r\n filename = \"%s_%s.txt\" % (date, n)\r\n with io.open(filename, \"w+\", encoding=\"UTF8\") as newfile:\r\n text = text.replace(\" \", \"\") #remove all spaces\r\n sentences= re.sub(\"，|。\", \"\\n\", text) #one sentence per line\r\n newfile.write(title+\"\\n\")\r\n newfile.write(date+\"\\n\")\r\n newfile.write(sentences)\r\n print(filename)","def readme(self):\n if \"README.md\" not in self:\n ex_msg = \"This Package is missing a README file. A Quilt recognized README file is a file named \" \\\n \"'README.md' (case-insensitive)\"\n raise QuiltException(ex_msg)\n\n return self[\"README.md\"]","def test_readme_file_for_formatting():\n f = open(\"README.md\", \"r\", encoding=\"utf-8\")\n content = f.read()\n f.close()\n assert content.count(\"#\") >= 10, \"Readme is not formatted properly\"","def make_file():\n get_content = input(\"Paste the content for your html file, include your doctype, html tags and header, body etc.\\n\")\n get_name = input(\"what do you want to call your file?\\n\")\n \n new_html_file = open(str(get_name) + '.html', 'w')\n page_content = \"\" + str(get_content) + \"\"\n \n new_html_file.write(page_content)\n new_html_file.close()","def main():\n # Get the date and time in a formatted string.\n today = datetime.datetime.today()\n date_formatted = today.strftime(\"%Y-%m-%d\")\n time_formatted = today.strftime(\"%H:%M:%S\")\n\n # Form the file name and path.\n file_name = date_formatted+\"-post.md\"\n file_path = os.path.join(POSTS_DIR, file_name)\n\n # Make the new header.\n header = HEADER_TEMPLATE.format(date_formatted, time_formatted)\n\n with open(file_path, 'w') as f:\n f.write(header)\n \n os.system(EDITOR+\" \"+file_path)","def write_message(f, readme_txt, outdir):\n name = f.split(\".gz\")[0].split('/')[-1]\n rf = open(outdir + \"/\" + str(name) + \"_README.txt\", \"a\")\n to_write = \" \" + str(readme_txt.pandascheck) + \" \" + str(readme_txt.samplesize) + \" \" + str(readme_txt.namecol)\n rf.write(str(f) + to_write + \"\\n\")\n rf.close()\n\n # Remove file if there is FAILED in error message\n if 'FAILED' in to_write:\n name = f.split(\".gz\")[0].split('/')[-1]\n if os.path.exists(outdir + \"/\" + name + \"_cols_edit.gz\"):\n os.remove(outdir + \"/\" + name + \"_cols_edit.gz\")","def _create_releaseinfo_file(projname, relinfo_str):\n dirs = projname.split('.')\n os.chdir(os.path.join(*dirs))\n print 'updating releaseinfo.py for %s' % projname\n with open('releaseinfo.py', 'w') as f:\n f.write(relinfo_str)","def create_file(name, text=None):\n\n if os.path.exists(config_tools.full_dest+name):\n print(f\"{name} уже существует, для записи текста введите его ниже, для завершения команды введите 'no': \")\n answer = input()\n if answer != \"no\":\n with open(config_tools.full_dest + name, 'a', encoding='utf-8') as fi:\n fi.write(answer)\n print(f\"В {name} успешно записан текст\")\n elif answer == \"no\":\n quit()\n else:\n with open(config_tools.full_dest + name, 'w', encoding='utf-8') as fi:\n print(f\"{name} успешно создан\")\n if text:\n fi.write(text)\n print(f\"В {name} успешно записан текст\")","def new(notebook, note):\n nb = select_notebook(notebook)\n if nb is None:\n echo('The notebook `{0}` doesn\\'t exist.'.format(notebook))\n return\n\n # Assume Markdown if no ext specified.\n _, ext = os.path.splitext(note)\n if not ext: note += '.md'\n\n path = os.path.join(nb.path.abs, note)\n click.edit(filename=path)","def start(self) -> \"UpdaterBase\":\n\n if self.administration.raw_link:\n with importlib.resources.path(\n \"ultimate_hosts_blacklist.test_launcher.data.docs\",\n \"about_repository.md\",\n ) as file_path:\n content = FileHelper(str(file_path)).read()\n else:\n with importlib.resources.path(\n \"ultimate_hosts_blacklist.test_launcher.data.docs\",\n \"about_repository_self.md\",\n ) as file_path:\n content = FileHelper(str(file_path)).read()\n\n content += \"\\n\\n\"\n\n with importlib.resources.path(\n \"ultimate_hosts_blacklist.test_launcher.data.docs\", \"about_ultimate.md\"\n ) as file_path:\n content += FileHelper(str(file_path)).read()\n\n content += \"\\n\\n\"\n\n with importlib.resources.path(\n \"ultimate_hosts_blacklist.test_launcher.data.docs\", \"about_pyfunceble.md\"\n ) as file_path:\n content += FileHelper(str(file_path)).read()\n\n content += \"\\n\"\n\n readme_file = FileHelper(\n os.path.join(outputs.CURRENT_DIRECTORY, outputs.README_FILENAME)\n )\n readme_file.write(content, overwrite=True)\n\n logging.info(\"Updated: %r\", readme_file.path)","def index():\n\n # open the README file\n with open(os.path.dirname(app.root_path) + '/README.md',\n 'r', encoding=\"utf-8\") as markdown_file:\n\n # Read the content of the file\n content = markdown_file.read()\n\n # convert to html\n return markdown.markdown(content)","def create(self):\n self.create_file()","def longdescription():\r\n print()\r\n here = path.abspath(path.dirname(__file__))\r\n with open(path.join(here, 'README.rst')) as f:\r\n long_description = f.read()\r\n\r\n print(long_description)","def action(self, args):\n create_new_scratch_file(args.file, self.settings, py_template_func)","def _readme_file(self, readme_path=None, proxies=None):\n if proxies is None:\n proxies = self._proxies\n if readme_path is None:\n readme_path = self._README_PATH\n url = \"{}{}\".format(self._url, readme_path)\n response = self._http.request(url=url, method=\"GET\", proxies=proxies)\n if response is None:\n return False\n if \"Stable tag:\" not in response.text:\n return False\n version = response.text.split(\"Stable tag:\")[1].split(\"\\n\")[0] # get the version of the plugin\n return self.is_vulnerable_version(version)","def get_long_description():\n with open(\"README.md\", \"r\") as fh:\n return fh.read()","def test_readme_exists():\n assert os.path.isfile(\"README.md\"), \"README.md file missing!\"","def test_session10_readme_proper_description():\n READMELOOKSGOOD = True\n f = open(\"README.md\", \"r\", encoding=\"utf-8\")\n content = f.read()\n f.close()\n for c in README_CONTENT_CHECK_FOR:\n if c not in content:\n print(c)\n READMELOOKSGOOD = False\n pass\n assert READMELOOKSGOOD == True, \"You have not described all the functions/class well in your README.md file\"","def create_file(file_name: str, startup_text: str) -> None:\n with open(file_name, 'w') as f:\n f.write(startup_text)","def test_readme_proper_description():\n READMELOOKSGOOD = True\n f = open(\"README.md\", \"r\", encoding=\"utf-8\")\n content = f.read()\n f.close()\n for c in README_CONTENT_CHECK_FOR:\n if c not in content:\n print(c)\n READMELOOKSGOOD = False\n break\n\n assert READMELOOKSGOOD is True, \"You have not described all the functions/class well in your README.md file\"","def test_session10_readme_exists():\n assert os.path.isfile(\"README.md\"), \"README.md file missing!\"","def get_description():\n with open(\"README.rst\", \"rb\") as readme:\n long_description = readme.read().decode(\"utf-8\")\n return long_description","def create_new_project():\n readline.parse_and_bind('tab: complete')\n\n print \\\n\"\"\"\n xbmcswift2 - A micro-framework for creating XBMC plugins.\n xbmc@jonathanbeluch.com\n --\n\"\"\"\n print 'I\\'m going to ask you a few questions to get this project' \\\n ' started.'\n\n # noinspection PyDictCreation\n opts = {}\n\n # Plugin Name\n opts['plugin_name'] = get_valid_value(\n 'What is your plugin name?',\n validate_nonblank\n )\n\n # Plugin ID\n opts['plugin_id'] = get_valid_value(\n 'Enter your plugin id.',\n validate_pluginid,\n 'plugin.video.%s' % (opts['plugin_name'].lower().replace(' ', ''))\n )\n\n # Parent Directory\n opts['parent_dir'] = get_valid_value(\n 'Enter parent folder (where to create project)',\n validate_isfolder,\n getcwd()\n )\n opts['plugin_dir'] = os.path.join(opts['parent_dir'], opts['plugin_id'])\n assert not os.path.isdir(opts['plugin_dir']), \\\n 'A folder named %s already exists in %s.' % (opts['plugin_id'],\n opts['parent_dir'])\n\n # Provider\n opts['provider_name'] = get_valid_value(\n 'Enter provider name',\n validate_nonblank,\n )\n\n # Create the project folder by copying over skel\n copytree(SKEL, opts['plugin_dir'], ignore=ignore_patterns('*.pyc'))\n\n # Walk through all the new files and fill in with out options\n for root, dirs, files in os.walk(opts['plugin_dir']):\n for filename in files:\n update_file(os.path.join(root, filename), opts)\n\n print 'Projects successfully created in %s.' % opts['plugin_dir']\n print 'Done.'","def createTXT(self):\n now = dt.datetime.now().strftime(\"%m-%d %H-%M\")\n self.filename = \"bwcca_tags \" + now\n try:\n if \"/\" in self.dir_lbl[\"text\"]:\n desired_list = self.phraseMaker()\n with open(f\"{self.folder}/{self.filename}.txt\", \"w\") as f:\n for i in desired_list:\n f.write(f\"{i}\\n\")\n self.stat_lbl[\"text\"] = f\"/{self.filename} created!\"\n else:\n self.dir_lbl[\"text\"] = \"Select a folder!\"\n self.dir_btn.focus()\n except Exception as e:\n self.dir_lbl[\"text\"] = e","def readme_path(request):\n # README path needs to be relative to the test.\n test_path = os.path.dirname(os.path.realpath(request.module.__file__))\n return os.path.join(test_path, '..', '..', 'README.md')","def readme_tests(readme=None):\n if readme is None:\n readme = Path('..', 'readme.md')\n with open(readme) as target:\n for line in target:\n if line.startswith(' ') and 'test_utils' not in line:\n print()\n print(line)\n input('Press Enter to execute')\n sb.run(line, shell=True, check=True)","def create_file():\n with open(\"example.txt\", \"w\") as file:\n file.write(\"\")","def help_create(self):\n print(CREATE)","def create_license(self) -> None:\n # copy the license file from the template to the package folder\n # option : append other license files\n shutil.copy(CONFIG.template_path / \"LICENSE.md\", self.package_path)","def test_init_with_description(isolated_runner, template):\n result = isolated_runner.invoke(\n cli, [\"init\", \"--description\", \"my project description\", \"new project\", \"--template-id\", template[\"id\"]]\n )\n\n assert 0 == result.exit_code, format_result_exception(result)\n\n database = Database.from_path(Path(\"new project\") / \".renku\" / \"metadata\")\n project = database.get(\"project\")\n\n assert \"new project\" == project.name\n assert project.id.endswith(\"new-project\") # make sure id uses slug version of name without space\n assert \"my project description\" in project.template_metadata\n assert \"my project description\" == project.description\n\n readme_content = (Path(\"new project\") / \"README.md\").read_text()\n assert \"my project description\" in readme_content","def find_long_description():\n return read_file('../README.md')","def _get_bids_readme(self):\n readme = []\n # Grab all readme files, loop through\n for README_fname in [\n file for file in Path(self.dataset.path).glob(\"[Rr][Ee][Aa][Dd][Mm][Ee]*\")\n ]:\n # datalad get content if annexed\n self.dataset.get(README_fname)\n # read text from file\n try:\n file_text = ensure_unicode(README_fname.read_text()).strip()\n except:\n file_text = \"\"\n # Append dict with file text + extension to list\n readme.append({\"extension\": README_fname.suffix, \"text\": file_text})\n return readme if readme else None","def WriteDiary():\r\n from datetime import datetime\r\n\r\n diaryname = _getPOSCAR()\r\n diary = open(diaryname, \"w\")\r\n diary.write('***' + str(datetime.now()) + '***' + '\\n')\r\n diary.write('## ' + diaryname + '\\n')\r\n diary.close()\r\n _CopyWriteDiary('Readme', diaryname)\r\n _CopyWriteDiary('INCAR', diaryname)\r\n _CopyWriteDiary('KPOINTS', diaryname)\r\n _CopyWriteDiary('POSCAR', diaryname)\r\n _CopyWriteDiary('POTCAR', diaryname)\r\n os.rename(diaryname, diaryname + '.md')","def get_long_description():\n with open(path.join(root_path, \"README.md\"), encoding=\"utf-8\") as f:\n long_description = f.read()\n return long_description","def make_document_metadata(name: str,\n version: Optional[str] = None,\n contact: Optional[str] = None,\n description: Optional[str] = None,\n authors: Optional[str] = None,\n copyright: Optional[str] = None,\n licenses: Optional[str] = None,\n disclaimer: Optional[str] = None,\n ) -> Iterable[str]:\n yield '#' * 80\n yield '#| Metadata'\n yield '#' * 80 + '\\n'\n\n yield 'SET DOCUMENT Name = \"{}\"'.format(name)\n yield 'SET DOCUMENT Version = \"{}\"'.format(version or time.strftime('%Y%m%d'))\n\n if description:\n yield 'SET DOCUMENT Description = \"{}\"'.format(description.replace('\\n', ''))\n\n if authors:\n yield 'SET DOCUMENT Authors = \"{}\"'.format(authors)\n\n if contact:\n yield 'SET DOCUMENT ContactInfo = \"{}\"'.format(contact)\n\n if licenses:\n yield 'SET DOCUMENT Licenses = \"{}\"'.format(licenses)\n\n if copyright:\n yield 'SET DOCUMENT Copyright = \"{}\"'.format(copyright)\n\n if disclaimer:\n yield 'SET DOCUMENT Disclaimer = \"{}\"'.format(disclaimer)\n\n yield ''","def new(self, article_name):\n name = article_name.strip(\" \")\n\n file_path = os.path.join('article', name + '.md')\n io.write(file_path, '')\n\n io.write('.last_article', file_path)\n\n self.write()","def new_entry(title, content):\n\n title.strip # Remove the spaces from both sides.\n filename = f\"entries/{title}.md\"\n if default_storage.exists(filename):\n return False\n default_storage.save(filename, ContentFile(content))\n return True","def mnote(tmp_path) -> Path:\n path = tmp_path/\"test.md\"\n path.write_text(\"# 0 Test\\n\\nTest note.\\n\")\n yield path","def update_readme_data(readme_file, **readme_updates):\n\n extensions_key = \"base\"\n extensions = readme_updates[\"extensions\"]\n\n if extensions:\n extensions_key = \"-\".join(extensions)\n\n output_folder = readme_updates[\"outputsubfolder\"]\n generation_data = {\n \"location\": path_join_robust(output_folder, \"\"),\n \"entries\": readme_updates[\"numberofrules\"],\n \"sourcesdata\": readme_updates[\"sourcesdata\"],\n }\n\n with open(readme_file, \"r\") as f:\n readme_data = json.load(f)\n readme_data[extensions_key] = generation_data\n\n for denomination, data in readme_data.copy().items():\n if \"location\" in data and data[\"location\"] and \"\\\\\" in data[\"location\"]:\n # Windows compatibility: #1166\n readme_data[denomination][\"location\"] = data[\"location\"].replace(\"\\\\\", \"/\")\n\n with open(readme_file, \"w\") as f:\n json.dump(readme_data, f)","def init():\n if not os.path.exists(BASE_PATH):\n os.makedirs(BASE_PATH)\n\n title = click.prompt(\"Title\")\n author = click.prompt(\"Author\")\n\n with click.open_file(os.path.join(BASE_PATH, \".title\"), 'w') as title_file:\n title_file.write(title)\n\n with click.open_file(os.path.join(BASE_PATH, \".author\"), 'w') as author_file:\n author_file.write(author)\n\n else:\n click.echo('Notes repository is initialized already.')","def create_file(self, name: str, content: str) -> None:\n file_path = self.path + os.path.sep + name\n with open(file_path, \"w+\") as file:\n file.write(content)\n file.close()","def render_readme(self):\r\n return self.manifest.get(\"render_readme\", False)","def task_mkdocs():\n return Task(\n file_dep=[MKDOCS],\n actions=[\n (needs, [\"jupyter_book\"]),\n ],\n uptodate=[not MKDOCS.exists()],\n )","def about():\n# return about string\n about = (\"\"\"\nJADM %s\n-------------\ncreator: Nikolay Georgiev Dachev, <nikolay@dachev.info>\nsupport: jadm@dachev.info (only for bugs report and jadm issues)\n\nJadm is FreeBSD jail administration framework with jail.conf, vnet and zfs support.\n\n---------------- JADM is BSD 3-Clause Licensed ---------------------\n\nCopyright (c) <2014>, <Nikolay Georgiev Dachev> <nikolay@dachev.info>\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distr\n\n3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES,\nINCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\nIN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,\nOR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\"\"\") % (jadm_version)\n return about","def about():\n return render_template(\n 'about.jade',\n title='About',\n year=datetime.now().year,\n repository_name=repository.name,\n )","def cmd_mkd(args):","def _(fname: str) -> str:\n with open(os.path.join(os.getcwd(), fname)) as readme:\n content = readme.read() or '' # prevent ``content = None``\n return content","def create_conf_file (self, data, directory=None):\n data.insert(0, \"# this file is automatically created by setup.py\")\n data.insert(0, \"# -*- coding: iso-8859-1 -*-\")\n if directory is None:\n directory = os.getcwd()\n filename = self.get_conf_filename(directory)\n # add metadata\n metanames = (\"name\", \"version\", \"author\", \"author_email\",\n \"maintainer\", \"maintainer_email\", \"url\",\n \"license\", \"description\", \"long_description\",\n \"keywords\", \"platforms\", \"fullname\", \"contact\",\n \"contact_email\")\n for name in metanames:\n method = \"get_\" + name\n val = getattr(self.metadata, method)()\n data.append(\"%s = %r\" % (name, val))\n data.append('release_date = \"%s\"' % get_release_date())\n # write the config file\n util.execute(write_file, (filename, data),\n \"creating %s\" % filename, self.verbose >= 1, self.dry_run)","def create_file(self, value=None):\n if not path.isdir(\"Project\"):\n system(\"mkdir Project\")\n string_to_systemize = \"echo \\\"#!/usr/bin/python\\n\" + \\\n \"# Please use fp = open(\\'Project/yourfile.*\\') \" + \\\n \"when opening YOUR files\\n\" + \\\n \"# to not lose YOUR file in the jumble of OTHER files.\\n\" + \\\n \"# Also, do NOT delete the very first comment line.\\n\" + \\\n \"# \\'logs.txt\\' is your friend for your error logs.\\\"\" + \\\n \"> Project/myfile.py\"\n system(string_to_systemize)\n system(\"chmod +x Project/myfile.py\")\n self.open_file()","def test_readme_commands(self, client):\n with open(REPO_ROOT / \"README.md\") as f:\n readme = f.read()\n\n documented = set(re.findall(\"^- `!([a-z]+)`: .*$\", readme, re.MULTILINE))\n implemented = set(client.commands)\n\n assert documented == implemented","def test_readme():\n notebooks_readme = Path(\"notebooks/README.md\").read_text()\n for item in Path(\"notebooks\").iterdir():\n if item.is_dir():\n # item is a notebook directory\n notebook_dir = item.relative_to(\"notebooks\")\n if str(notebook_dir)[0].isdigit():\n assert \"README.md\" in [filename.name for filename in item.iterdir()], \\\n f\"README not found in {item}\"\n assert str(notebook_dir) in notebooks_readme, f\"{item} not found in notebooks README\"","def makeHTML(header, body, footer):\n f = open(\"crimenews.html\", \"w\")\n f.write(header+body+footer)","def provide_html_template():\n get_content = str(input(\"Paste the content you want to see displayed in the browser here. \\n\"))\n get_name = input(\"I am going to create an html file with your content. What do you want to call your file? \\n\")\n \n new_html_file = open(str(get_name) + '.html', 'w')\n \n page_content = '<html><head></head><body><p>' + get_content + '</p></body></html>'\n \n new_html_file.write(page_content)\n new_html_file.close()"],"string":"[\n \"def make_readme_txt(self, args):\\n with open(self.readme_txt, 'w') as writer:\\n log.info(\\\"args=%s\\\\n\\\", args)\\n writer.write(\\\"# Created by pbtranscript-internal-validation.ValidationRunner.make_readme_txt()\\\\n\\\")\\n writer.write(\\\"args=%s\\\\n\\\\n\\\" % args)\\n\\n files = self.common_files + self.collapse_human_files + self.reseq_human_files + self.sirv_files\\n for desc, fn in files:\\n if op.exists(fn):\\n writer.write(\\\"%s=%s\\\\n\\\" % (desc, fn))\",\n \"def create_readme(case_dict):\\n # ---------------------------------------------------------------------\\n logger.debug(\\\"create_readme\\\")\\n os.chdir(case_dict[\\\"archive_temp_dir\\\"])\\n\\n fname = open(\\\"README.archive\\\", \\\"w\\\")\\n fname.write(\\\"Archived metadata is available for this case at URL:\\\\n\\\")\\n fname.write(case_dict[\\\"base_expdb_url\\\"])\\n fname.close()\",\n \"def make_readme(digest):\\n o = 'SHA1 digest: %s\\\\n\\\\n'%digest[:10]\\n print '...build readme file for GitHub' \\n open('README.md','w').write(o + make_readme.__doc__)\",\n \"def readme_md(cls):\\n\\n template = Helpers.File(Settings.readme_me_template).read()\\n\\n template = Helpers.Regex(\\n template, r\\\"%%version%%\\\", replace_with=Settings.version\\n ).replace()\\n template = Helpers.Regex(\\n template, r\\\"%%lenHosts%%\\\", replace_with=format(len(Settings.domains), \\\",d\\\")\\n ).replace()\\n template = Helpers.Regex(\\n template, r\\\"%%lenIPs%%\\\", replace_with=format(len(Settings.ips), \\\",d\\\")\\n ).replace()\\n template = Helpers.Regex(\\n template,\\n r\\\"%%lenHostsIPs%%\\\",\\n replace_with=format(len(Settings.ips) + len(Settings.domains), \\\",d\\\"),\\n ).replace()\\n\\n print(\\\"Generation of %s\\\" % Settings.readme_md_file, end=\\\" \\\")\\n Helpers.File(Settings.readme_md_file).write(template, overwrite=True)\\n print(Settings.done)\",\n \"def create_readme(histfile, vb):\\n\\tme = \\\"Utils.create_readme: \\\"\\n\\treadmefile = os.path.dirname(histfile)+\\\"/README.txt\\\"\\n\\ttry:\\n\\t\\tassert os.path.isfile(readmefile)\\n\\texcept AssertionError:\\n\\t\\tnow = str(datetime.now().strftime(\\\"%Y-%m-%d %H.%M\\\"))\\n\\t\\tcommit = subprocess.check_output(['git', 'rev-parse', 'HEAD'])\\n\\t\\theader = \\\"Time:\\\\t\\\"+now+\\\"\\\\nCommit hash:\\\\t\\\"+commit+\\\"\\\\n\\\\n\\\"\\n\\t\\twith open(readmefile,\\\"w\\\") as f:\\n\\t\\t\\tf.write(header)\\n\\t\\tif vb: print me+\\\"Created readme file \\\"+readmefile\\n\\treturn\",\n \"def _write_readme(variables):\\n with open(locations.readme_template) as source:\\n with open(locations.readme, \\\"w\\\") as destination:\\n contents = source.read()\\n contents = contents.format(**variables)\\n destination.write(contents)\",\n \"def create_readme(self) -> None:\\n # read the readme file and update the version and description\\n with open(CONFIG.template_path / \\\"README.md\\\", \\\"r\\\") as f:\\n TEMPLATE_README = f.read()\\n\\n # add a readme with the names of the stub-folders\\n\\n # read informations from firmware_stubs.json\\n firmware_stubs = {}\\n doc_stubs = {}\\n core_stubs = {}\\n try:\\n with open(self.package_path / \\\"firmware_stubs.json\\\", \\\"r\\\") as f:\\n firmware_stubs = json.load(f)\\n with open(self.package_path / \\\"doc_stubs.json\\\", \\\"r\\\") as f:\\n doc_stubs = json.load(f)\\n with open(self.package_path / \\\"modules.json\\\", \\\"r\\\") as f:\\n core_stubs = json.load(f)\\n except FileNotFoundError:\\n pass\\n\\n # Prettify this by merging with template text\\n with open(self.package_path / \\\"README.md\\\", \\\"w\\\") as f:\\n f.write(f\\\"# {self.package_name}\\\\n\\\\n\\\")\\n f.write(TEMPLATE_README)\\n f.write(f\\\"Included stubs:\\\\n\\\")\\n for name, folder in self.stub_sources:\\n f.write(f\\\"* {name} from `stubs/{Path(folder).as_posix()}`\\\\n\\\")\\n\\n f.write(f\\\"\\\\n\\\\n\\\")\\n f.write(f\\\"origin | Family | Port | Board | Version\\\\n\\\")\\n f.write(f\\\"-------|--------|------|-------|--------\\\\n\\\")\\n try:\\n f.write(\\n f\\\"Firmware | {firmware_stubs['firmware']['family']} | {firmware_stubs['firmware']['port']} | {firmware_stubs['firmware']['machine']} | {clean_version(firmware_stubs['firmware']['version'])} \\\\n\\\"\\n )\\n except Exception:\\n pass\\n try:\\n f.write(\\n f\\\"Documentation | {doc_stubs['firmware']['family']} | {doc_stubs['firmware']['port']} | - | {clean_version(doc_stubs['firmware']['version'])} \\\\n\\\"\\n )\\n except Exception:\\n pass\\n try:\\n f.write(\\n f\\\"Core | {core_stubs['firmware']['family']} | {core_stubs['firmware']['port']} | - | {clean_version(core_stubs['firmware']['version'])} \\\\n\\\"\\n )\\n except Exception:\\n pass\",\n \"def _create_readme(self, name, summary, description):\\n return \\\"\\\"\\\"\\n %(header_bar)s\\n %(header)s\\n %(header_bar)s\\n\\n %(content)s\\n \\\"\\\"\\\" % {\\n 'header': name,\\n 'header_bar': '=' * len(name),\\n 'content': '\\\\n\\\\n'.join(\\n content\\n for content in (summary, description)\\n if content\\n ) or 'Describe your extension.',\\n }\",\n \"def with_readme(request, new_package):\\n\\n new_module, pkg_root = new_package\\n pkg_name = os.path.basename(pkg_root)\\n\\n with open(os.path.join(new_module, \\\"README\\\"), \\\"w\\\") as openreadme:\\n openreadme.write(\\\"{n}\\\\n{d}\\\\n\\\\n{n}'s readme... with content!\\\".format(\\n n=pkg_name,\\n d=\\\"=\\\" * len(pkg_name),\\n ))\\n\\n with open(os.path.join(new_module, META_NAME), \\\"w\\\") as openmeta:\\n openmeta.write(\\n '{\\\"packages\\\": [\\\"find_packages()\\\"], \\\"long_description\\\": \\\"README\\\"}'\\n )\\n\\n request.addfinalizer(module_cleanup)\\n return new_module, pkg_root\",\n \"def readme():\\n with open('README.md') as readme_file:\\n return readme_file.read()\",\n \"def readmegen(session, sample):\\n session.install('jinja2', 'pyyaml')\\n\\n if os.path.exists(os.path.join(sample, 'requirements.txt')):\\n session.install('-r', os.path.join(sample, 'requirements.txt'))\\n\\n in_file = os.path.join(sample, 'README.rst.in')\\n session.run('python', 'scripts/readme-gen/readme_gen.py', in_file)\",\n \"def readme():\\n with open('README.md') as _file:\\n return _file.read()\",\n \"def readme():\\n\\n with open('README.rst') as readme_file:\\n return readme_file.read()\",\n \"def test_readme():\\n readme = Path(README_PATH).read_text()\\n Actions.read_from_md(readme)\",\n \"def update_readme():\\n\\n temp = \\\"\\\"\\\"<head>\\n <title>Unittest Results</title>\\n <meta charset=\\\"utf-8\\\">\\n <meta name=\\\"viewport\\\" content=\\\"width=device-width, initial-scale=1.0\\\">\\n <link rel=\\\"stylesheet\\\" href=\\\"https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css\\\" integrity=\\\"sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7\\\" crossorigin=\\\"anonymous\\\">\\n</head>\\\"\\\"\\\"\\n\\n with open(\\\"README_proxy.md\\\", \\\"r\\\") as old_readme_file:\\n old_readme_txt = old_readme_file.read()\\n\\n with open(\\\"reports/test_result.html\\\", \\\"r\\\") as html_file:\\n html = html_file.read().splitlines()[0:-21]\\n html = \\\"\\\\n\\\".join(html).replace(temp, \\\"\\\")\\n\\n with open(\\\"README.md\\\", \\\"w\\\") as new_readme_file:\\n new_readme_file.write(old_readme_txt + \\\"\\\\n\\\\n\\\\n\\\" + html + \\\"</body></html>\\\")\",\n \"def readme():\\n with open(os.path.join(build_root, 'README.rst')) as f:\\n return f.read()\",\n \"def update_readme(readme: str, updated_metadata: dict = None, extra_lines: list = None):\\n metadata, lines = read_readme(readme)\\n if updated_metadata:\\n metadata = {**metadata, **updated_metadata}\\n if extra_lines:\\n lines = lines + extra_lines\\n write_readme(readme, metadata, lines)\",\n \"def readme():\\n with open('README.rst') as f:\\n return f.read()\",\n \"def fix_readme(self):\\n import re\\n\\n readme = os.path.join(os.path.dirname(__file__), \\\"README.md\\\")\\n with open(readme, \\\"r\\\") as f:\\n content = f.read()\\n\\n tag = self.get_tag()\\n if not tag:\\n raise AssertionError(\\n \\\"Could not get tag! (are you checking out with full tag history?)\\\"\\n )\\n\\n new_content = re.sub(\\n r\\\"\\\\(docs/\\\",\\n rf\\\"(https://github.com/robocorp/robotframework-lsp/tree/{tag}/robocorp-code/docs/\\\",\\n content,\\n )\\n\\n new_content = re.sub(\\n r\\\"\\\\(images/\\\",\\n rf\\\"(https://raw.githubusercontent.com/robocorp/robotframework-lsp/{tag}/robocorp-code/images/\\\",\\n content,\\n )\\n\\n new_content = new_content.replace(\\n \\\"Apache 2.0\\\",\\n \\\"[Robocorp License Agreement (pdf)](https://cdn.robocorp.com/legal/Robocorp-EULA-v1.0.pdf)\\\",\\n )\\n\\n assert \\\"apache\\\" not in new_content.lower()\\n with open(readme, \\\"w\\\") as f:\\n f.write(new_content)\",\n \"def make_doc(description=False, sentinel=COMMENT):\\n for readme_path in [os.path.abspath(x) for x in glob(\\\"*/README.md\\\")]:\\n with open(readme_path, \\\"r+\\\") as readme_file:\\n readme = readme_file.read()\\n if sentinel in readme:\\n root = os.path.dirname(readme_path)\\n tree = make_tree_doc(root)\\n pattern = r\\\"{}.*?\\\\n(\\\\w+)?\\\\n\\\".format(sentinel)\\n text = re.sub(pattern, format_tree(tree), readme, flags=re.DOTALL)\\n readme_file.seek(0)\\n readme_file.truncate()\\n readme_file.write(text)\",\n \"def create_about():\\n meta_desc = (\\n 'Expected values and probability per lap of step-up banners'\\n ' in Final Fantasy Brave Exvius (FFBE)')\\n template_vars = {\\n 'title' : 'About - ' + sitesettings.SITE_NAME,\\n 'siteurl' : sitesettings.SITE_URL,\\n 'sitename' : sitesettings.SITE_NAME,\\n 'meta_desc' : meta_desc,\\n 'last_four_banners' : nav.get_last_four_banners('all'),\\n }\\n\\n about_path = os.path.join(sitesettings.LOCAL_FILE_PATH, 'about')\\n\\n if not os.path.exists(about_path):\\n os.makedirs(about_path)\\n\\n template_file = 'about.html'\\n html_file_loc = os.path.join(about_path, 'index.html')\\n generatehtml.generate_html(\\n html_file_loc, template_file, template_vars, os.path.join(os.getcwd(), 'templates'))\",\n \"def readme(fname='README'):\\n with open(os.path.join(os.path.dirname(__file__), fname)) as file:\\n return file.read()\",\n \"def _readme(datatype, fname, overwrite=False):\\n if os.path.isfile(fname) and not overwrite:\\n with open(fname, \\\"r\\\", encoding=\\\"utf-8-sig\\\") as fid:\\n orig_data = fid.read()\\n mne_bids_ref = REFERENCES[\\\"mne-bids\\\"] in orig_data\\n datatype_ref = REFERENCES[datatype] in orig_data\\n if mne_bids_ref and datatype_ref:\\n return\\n text = \\\"{}References\\\\n----------\\\\n{}{}\\\".format(\\n orig_data + \\\"\\\\n\\\\n\\\",\\n \\\"\\\" if mne_bids_ref else REFERENCES[\\\"mne-bids\\\"] + \\\"\\\\n\\\\n\\\",\\n \\\"\\\" if datatype_ref else REFERENCES[datatype] + \\\"\\\\n\\\",\\n )\\n else:\\n text = \\\"References\\\\n----------\\\\n{}{}\\\".format(\\n REFERENCES[\\\"mne-bids\\\"] + \\\"\\\\n\\\\n\\\", REFERENCES[datatype] + \\\"\\\\n\\\"\\n )\\n\\n _write_text(fname, text, overwrite=True)\",\n \"def OpenReadMe():\\n location = os.path.join(os.path.dirname(__file__), \\\"README.txt\\\")\\n os.startfile(location)\",\n \"def create(contents, title, path=\\\"\\\"):\\n filename = secure_filename(title)\\n data_dir = get_data_dir()\\n max_filename_length = 255\\n if len(filename + \\\".md\\\") > max_filename_length:\\n filename = filename[0 : max_filename_length - 3]\\n if not is_relative_to(data_dir / path, data_dir):\\n path = \\\"\\\"\\n path_to_md_file = data_dir / path / f\\\"{filename}.md\\\"\\n with open(path_to_md_file, \\\"w\\\", encoding=\\\"utf-8\\\") as file:\\n file.write(contents)\\n\\n return path_to_md_file\",\n \"def build_readme(comic: str, readme: str) -> str:\\n img = f\\\"{START_COMMENT}\\\\n{comic}\\\\n{END_COMMENT}\\\"\\n return re.sub(listReg, img, readme)\",\n \"def OpenReadMe():\\n location = os.path.join(os.path.dirname(__file__), \\\"README.txt\\\")\\n os.startfile(location)\\n return\",\n \"def new(cli):\\n __check_in_autonotes_dir()\\n\\n # Filename\\n filename = cli.config.new.filename\\n file_date = datetime.now().strftime(\\\"%Y%m%d\\\")\\n today = datetime.now().strftime(\\\"%b %d\\\")\\n if not cli.config.new.no_date:\\n filename += f'-{file_date}'\\n filename += '.tex'\\n if os.path.exists(filename):\\n cli.log.error(f'File {emph(filename)} already exists.')\\n exit(1)\\n\\n # Note title\\n title = cli.config.new.title\\n if title == '':\\n title = f'Untitled {cli.config.new.filename}'\\n\\n # Open file for writing\\n file = open(filename, 'w')\\n cli.log.info(f'Created {emph(filename)}')\\n new_note_str = f'% {filename}\\\\n\\\\n' \\\\\\n '\\\\\\\\section{' \\\\\\n f'{title.replace(\\\"_\\\", \\\" \\\")}' \\\\\\n '}\\\\n' \\\\\\n '\\\\\\\\marginnote{' \\\\\\n f'{today}' \\\\\\n '\\\\\\\\index{' \\\\\\n f'{today}' \\\\\\n '}}[.2cm]\\\\n'\\n file.write(new_note_str)\\n file.close()\\n\\n # Add the new file to master.tex\\n __add([filename])\",\n \"def prepare_agent_readme(agent):\\n readme_path = f'{os.path.join(parlai.agents.__path__[0], agent)}/README.md'\\n if not os.path.exists(readme_path):\\n raise RuntimeError(f'Agent {agent} must have README.md')\\n with open(readme_path) as f:\\n readme = f.readlines()\\n\\n if '# ' not in readme[0]:\\n readme[0] = f'# {agent}'\\n\\n return ''.join(readme)\",\n \"def get_readme():\\n for name in ('README', 'README.rst', 'README.md'):\\n if os.path.exists(name):\\n return read_file(name)\\n return ''\",\n \"def get_readme():\\n for name in ('README', 'README.txt', 'README.rst', 'README.md'):\\n if os.path.exists(name):\\n return read_file(name)\\n return ''\",\n \"def create_new(self, name):\\n validate_name(name, self.__class__.__name__)\\n self.data = {\\n \\\"author_name\\\": \\\"\\\",\\n \\\"author_email\\\": \\\"\\\",\\n \\\"git_profile_url\\\": \\\"\\\",\\n \\\"starting_version\\\": \\\"0.1.0\\\",\\n \\\"default_description\\\": \\\"My project, created using nusex\\\",\\n \\\"preferred_license\\\": \\\"unlicense\\\",\\n }\",\n \"def get_fsleyes_readme():\\n with open(op.join(basedir, 'README.rst'), 'rt', encoding='utf-8') as f:\\n return f.read().strip()\",\n \"def deploy(version):\\n toolkit.readmegen(version)\",\n \"def churn(old_readme: str, /) -> str | None:\\n # getting content\\n if not (waka_stats := fetch_stats()):\\n logger.error('Unable to fetch data, please rerun workflow\\\\n')\\n sys.exit(1)\\n # processing content\\n try:\\n generated_content = prep_content(waka_stats)\\n except AttributeError as err:\\n logger.error(f'Unable to read API data | {err}\\\\n')\\n sys.exit(1)\\n print(generated_content, '\\\\n', sep='')\\n new_readme = re.sub(\\n pattern=wk_i.waka_block_pattern,\\n repl=f'{wk_i.start_comment}\\\\n\\\\n```text\\\\n{generated_content}\\\\n```\\\\n\\\\n{wk_i.end_comment}',\\n string=old_readme\\n )\\n if len(sys.argv) == 2 and sys.argv[1] == '--dev':\\n logger.debug('Detected run in `dev` mode.')\\n # to avoid accidentally writing back to Github\\n # when developing and testing WakaReadme\\n return None\\n\\n return None if new_readme == old_readme else new_readme\",\n \"def argparser_to_readme(\\n argparser: Callable[[], ArgumentParser],\\n template: str = \\\"README-template.md\\\",\\n destination: str = \\\"README.md\\\",\\n indentation: int = 0,\\n placeholder: str = \\\"{{ argparse }}\\\",\\n) -> None:\\n help_string = argparser().format_help()\\n\\n if indentation > 0:\\n indent_lines: List[str] = []\\n lines = help_string.split(\\\"\\\\n\\\")\\n for line in lines:\\n indent_lines.append(\\\" \\\" * indentation + line)\\n\\n help_string = \\\"\\\\n\\\".join(indent_lines)\\n\\n with open(template, \\\"r\\\", encoding=\\\"utf-8\\\") as template_file:\\n template_string = template_file.read()\\n readme = template_string.replace(placeholder, help_string)\\n\\n readme_file = open(destination, \\\"w\\\")\\n readme_file.write(readme)\\n readme_file.close()\",\n \"def get_readme_text(self):\\n if self.readme_file:\\n readme_text = self.readme_file.read_text(encoding=\\\"utf-8\\\")\\n else:\\n readme_text = \\\"# foxBMS 2 GUI\\\"\\n return readme_text\",\n \"def main(src_file=\\\"README.md\\\", dst_file=\\\"docs/documentation.json\\\"):\\n with open(src_file, \\\"r\\\") as readme:\\n markdown = readme.read()\\n\\n data = {\\n \\\"info\\\": {\\n \\\"termsOfService\\\": \\\"https://github.com/bombsimon/redoc-theme\\\",\\n \\\"description\\\": markdown,\\n \\\"license\\\": {\\n \\\"url\\\": \\\"https://opensource.org/licenses/MIT\\\",\\n \\\"name\\\": \\\"MIT\\\",\\n },\\n \\\"title\\\": \\\"ReDoc Theme\\\",\\n \\\"version\\\": \\\"1.0\\\",\\n \\\"contact\\\": {\\\"email\\\": \\\"simon@sawert.se\\\"},\\n \\\"x-logo\\\": {\\\"url\\\": \\\"assets/logo.png\\\"},\\n },\\n \\\"swagger\\\": \\\"2.0\\\",\\n }\\n\\n with open(dst_file, \\\"w\\\") as doc_json:\\n json.dump(data, doc_json, indent=2)\",\n \"def read_readme(setup_file, name=\\\"README.rst\\\"):\\n import os\\n TOP_DIR = os.path.abspath(os.path.dirname(setup_file))\\n if not os.path.exists(TOP_DIR):\\n raise FileNotFoundError(\\n f\\\"Unable to find folder {TOP_DIR!r}.\\\")\\n readme = os.path.join(TOP_DIR, name)\\n if not os.path.exists(readme):\\n raise FileNotFoundError(\\n f\\\"Unable to find file {TOP_DIR!r}.\\\")\\n with open(readme, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n content = f.read()\\n return _clean_readme(content)\",\n \"def readme(self, ref=None):\\r\\n params = base.get_params(None, locals())\\r\\n url = '{0}/readme'.format(self.parent.get_url())\\r\\n\\r\\n return http.Request('GET', url, params), parsers.parse_json\",\n \"def parse_readme():\\n # Get the long description from the relevant file\\n readme_path = path.join(here, 'README.md')\\n with codecs.open(readme_path, encoding='utf-8') as handle:\\n desc = handle.read()\\n\\n return desc\",\n \"def __init__(self, name=''):\\r\\n if name:\\r\\n self.file_name = name + '.md'\\r\\n self.file = open(self.file_name, 'w+', encoding='UTF-8')\\r\\n self.file.close()\",\n \"def create_new_python_project():\\n\\t# Create the different variables\\n\\tfolder_name = str(sys.argv[1])\\n\\tdir_name = my_project_folder + folder_name\\n\\tpy_file = dir_name + '/' + folder_name + '.py'\\n\\treadme_file = dir_name + '/' + 'README.md'\\n\\ttodo_file = dir_name + '/' + 'TODO.txt'\\n\\n\\t# Create directory if it does not exist yet\\n\\tif not os.path.exists(dir_name):\\n\\t\\tos.mkdir(dir_name)\\n\\t\\tprint(\\\"Directory \\\" , dir_name , \\\" Created \\\")\\n\\n\\t\\t# Create Python file\\n\\t\\tdata = ''\\n\\t\\twith open(template_py, 'r') as file:\\n\\t\\t\\tdata += file.read()\\n\\n\\t\\twith open(py_file, 'w') as f:\\n\\t\\t\\tf.write(data)\\n\\t\\t\\tprint(\\\"Python file created\\\")\\n\\n\\t\\t# Create README file\\n\\t\\tdata = ''\\n\\t\\twith open(template_readme, 'r') as file:\\n\\t\\t\\tdata += file.read()\\n\\n\\t\\twith open(readme_file, 'w') as f:\\n\\t\\t\\tf.write(data)\\n\\t\\t\\tprint(\\\"Readme file created\\\")\\n\\n\\t\\t# Create Todo file\\n\\t\\twith open(todo_file, 'w') as f:\\n\\t\\t\\tprint(\\\"TODO file created\\\")\\n\\n\\t\\t# Create Github repo\\n\\t\\twith open(\\\".env\\\", \\\"r\\\") as f:\\n\\t\\t\\tdata = f.read()\\n\\n\\t\\tindex_1 = data.find('TOKEN=\\\"') + len('TOKEN=\\\"')\\n\\t\\ttoken = data[index_1:-1]\\n\\t\\tg = Github(token)\\n\\t\\tuser = g.get_user()\\n\\t\\trepo = user.create_repo(folder_name)\\n\\t\\tprint(\\\"Succesfully created repository {}\\\".format(folder_name))\\n\\n\\n\\telse: \\n\\t\\tprint(\\\"Directory \\\" , dir_name , \\\" already exists\\\")\",\n \"def read_readme(readme: str) -> Tuple[dict, list]:\\n metadata = {\\n \\\"name\\\": \\\"na\\\",\\n \\\"provider\\\": \\\"na\\\",\\n \\\"original name\\\": \\\"na\\\",\\n \\\"original filename\\\": \\\"na\\\",\\n \\\"assembly_accession\\\": \\\"na\\\",\\n \\\"tax_id\\\": \\\"na\\\",\\n \\\"mask\\\": \\\"na\\\",\\n \\\"genome url\\\": \\\"na\\\",\\n \\\"annotation url\\\": \\\"na\\\",\\n \\\"sanitized annotation\\\": \\\"na\\\",\\n \\\"genomepy version\\\": \\\"na\\\",\\n \\\"date\\\": \\\"na\\\",\\n }\\n lines = []\\n\\n if not os.path.exists(readme):\\n return metadata, lines\\n\\n # if the readme exists, overwrite all metadata fields found\\n with open(readme) as f:\\n for line in f.readlines():\\n if \\\": \\\" in line:\\n vals = line.strip().split(\\\": \\\")\\n metadata[vals[0].strip()] = (\\\": \\\".join(vals[1:])).strip()\\n else:\\n line = line.strip(\\\"\\\\n\\\").strip(\\\" \\\")\\n # blank lines are allowed, but only one in a row\\n if not (\\n line == \\\"\\\"\\n and len(lines) > 0\\n and lines[len(lines) - 1].strip() == \\\"\\\"\\n ):\\n lines.append(line)\\n\\n return metadata, lines\",\n \"def test_readme_contents():\\n readme = open(\\\"README.md\\\", \\\"r\\\", encoding=\\\"utf-8\\\")\\n readme_words = readme.read().split()\\n readme.close()\\n assert len(readme_words) >= 500, \\\"Make your README.md file interesting! Add atleast 500 words\\\"\",\n \"def hotkeys_readme():\\n\\n root = '/'.join(__file__.split('/')[:-4])\\n fname = root + '/README.rst'\\n with codecs.open(fname, 'r', 'utf-8') as f:\\n rst = f.read()\\n hotkeys = rst.split('.. hotkeys')[1]\\n return docutils.examples.html_body(hotkeys)\",\n \"def test_readmeExamplesAreExecutable(self) -> None:\\n temporary_code = extract_code_from_readme()\\n globals_for_exec = {\\\"__name__\\\": \\\"README.md\\\"}\\n\\n try:\\n exec(temporary_code, globals_for_exec)\\n except Exception:\\n print(\\\">>> Found error in generated readme code file\\\",\\n file=sys.stderr)\\n print(temporary_code, file=sys.stderr)\\n raise\",\n \"def create_file(date, title, text, n):\\r\\n \\\"\\\"\\\"with date as file name and text as content\\\"\\\"\\\"\\r\\n filename = \\\"%s_%s.txt\\\" % (date, n)\\r\\n with io.open(filename, \\\"w+\\\", encoding=\\\"UTF8\\\") as newfile:\\r\\n text = text.replace(\\\" \\\", \\\"\\\") #remove all spaces\\r\\n sentences= re.sub(\\\"，|。\\\", \\\"\\\\n\\\", text) #one sentence per line\\r\\n newfile.write(title+\\\"\\\\n\\\")\\r\\n newfile.write(date+\\\"\\\\n\\\")\\r\\n newfile.write(sentences)\\r\\n print(filename)\",\n \"def readme(self):\\n if \\\"README.md\\\" not in self:\\n ex_msg = \\\"This Package is missing a README file. A Quilt recognized README file is a file named \\\" \\\\\\n \\\"'README.md' (case-insensitive)\\\"\\n raise QuiltException(ex_msg)\\n\\n return self[\\\"README.md\\\"]\",\n \"def test_readme_file_for_formatting():\\n f = open(\\\"README.md\\\", \\\"r\\\", encoding=\\\"utf-8\\\")\\n content = f.read()\\n f.close()\\n assert content.count(\\\"#\\\") >= 10, \\\"Readme is not formatted properly\\\"\",\n \"def make_file():\\n get_content = input(\\\"Paste the content for your html file, include your doctype, html tags and header, body etc.\\\\n\\\")\\n get_name = input(\\\"what do you want to call your file?\\\\n\\\")\\n \\n new_html_file = open(str(get_name) + '.html', 'w')\\n page_content = \\\"\\\" + str(get_content) + \\\"\\\"\\n \\n new_html_file.write(page_content)\\n new_html_file.close()\",\n \"def main():\\n # Get the date and time in a formatted string.\\n today = datetime.datetime.today()\\n date_formatted = today.strftime(\\\"%Y-%m-%d\\\")\\n time_formatted = today.strftime(\\\"%H:%M:%S\\\")\\n\\n # Form the file name and path.\\n file_name = date_formatted+\\\"-post.md\\\"\\n file_path = os.path.join(POSTS_DIR, file_name)\\n\\n # Make the new header.\\n header = HEADER_TEMPLATE.format(date_formatted, time_formatted)\\n\\n with open(file_path, 'w') as f:\\n f.write(header)\\n \\n os.system(EDITOR+\\\" \\\"+file_path)\",\n \"def write_message(f, readme_txt, outdir):\\n name = f.split(\\\".gz\\\")[0].split('/')[-1]\\n rf = open(outdir + \\\"/\\\" + str(name) + \\\"_README.txt\\\", \\\"a\\\")\\n to_write = \\\" \\\" + str(readme_txt.pandascheck) + \\\" \\\" + str(readme_txt.samplesize) + \\\" \\\" + str(readme_txt.namecol)\\n rf.write(str(f) + to_write + \\\"\\\\n\\\")\\n rf.close()\\n\\n # Remove file if there is FAILED in error message\\n if 'FAILED' in to_write:\\n name = f.split(\\\".gz\\\")[0].split('/')[-1]\\n if os.path.exists(outdir + \\\"/\\\" + name + \\\"_cols_edit.gz\\\"):\\n os.remove(outdir + \\\"/\\\" + name + \\\"_cols_edit.gz\\\")\",\n \"def _create_releaseinfo_file(projname, relinfo_str):\\n dirs = projname.split('.')\\n os.chdir(os.path.join(*dirs))\\n print 'updating releaseinfo.py for %s' % projname\\n with open('releaseinfo.py', 'w') as f:\\n f.write(relinfo_str)\",\n \"def create_file(name, text=None):\\n\\n if os.path.exists(config_tools.full_dest+name):\\n print(f\\\"{name} уже существует, для записи текста введите его ниже, для завершения команды введите 'no': \\\")\\n answer = input()\\n if answer != \\\"no\\\":\\n with open(config_tools.full_dest + name, 'a', encoding='utf-8') as fi:\\n fi.write(answer)\\n print(f\\\"В {name} успешно записан текст\\\")\\n elif answer == \\\"no\\\":\\n quit()\\n else:\\n with open(config_tools.full_dest + name, 'w', encoding='utf-8') as fi:\\n print(f\\\"{name} успешно создан\\\")\\n if text:\\n fi.write(text)\\n print(f\\\"В {name} успешно записан текст\\\")\",\n \"def new(notebook, note):\\n nb = select_notebook(notebook)\\n if nb is None:\\n echo('The notebook `{0}` doesn\\\\'t exist.'.format(notebook))\\n return\\n\\n # Assume Markdown if no ext specified.\\n _, ext = os.path.splitext(note)\\n if not ext: note += '.md'\\n\\n path = os.path.join(nb.path.abs, note)\\n click.edit(filename=path)\",\n \"def start(self) -> \\\"UpdaterBase\\\":\\n\\n if self.administration.raw_link:\\n with importlib.resources.path(\\n \\\"ultimate_hosts_blacklist.test_launcher.data.docs\\\",\\n \\\"about_repository.md\\\",\\n ) as file_path:\\n content = FileHelper(str(file_path)).read()\\n else:\\n with importlib.resources.path(\\n \\\"ultimate_hosts_blacklist.test_launcher.data.docs\\\",\\n \\\"about_repository_self.md\\\",\\n ) as file_path:\\n content = FileHelper(str(file_path)).read()\\n\\n content += \\\"\\\\n\\\\n\\\"\\n\\n with importlib.resources.path(\\n \\\"ultimate_hosts_blacklist.test_launcher.data.docs\\\", \\\"about_ultimate.md\\\"\\n ) as file_path:\\n content += FileHelper(str(file_path)).read()\\n\\n content += \\\"\\\\n\\\\n\\\"\\n\\n with importlib.resources.path(\\n \\\"ultimate_hosts_blacklist.test_launcher.data.docs\\\", \\\"about_pyfunceble.md\\\"\\n ) as file_path:\\n content += FileHelper(str(file_path)).read()\\n\\n content += \\\"\\\\n\\\"\\n\\n readme_file = FileHelper(\\n os.path.join(outputs.CURRENT_DIRECTORY, outputs.README_FILENAME)\\n )\\n readme_file.write(content, overwrite=True)\\n\\n logging.info(\\\"Updated: %r\\\", readme_file.path)\",\n \"def index():\\n\\n # open the README file\\n with open(os.path.dirname(app.root_path) + '/README.md',\\n 'r', encoding=\\\"utf-8\\\") as markdown_file:\\n\\n # Read the content of the file\\n content = markdown_file.read()\\n\\n # convert to html\\n return markdown.markdown(content)\",\n \"def create(self):\\n self.create_file()\",\n \"def longdescription():\\r\\n print()\\r\\n here = path.abspath(path.dirname(__file__))\\r\\n with open(path.join(here, 'README.rst')) as f:\\r\\n long_description = f.read()\\r\\n\\r\\n print(long_description)\",\n \"def action(self, args):\\n create_new_scratch_file(args.file, self.settings, py_template_func)\",\n \"def _readme_file(self, readme_path=None, proxies=None):\\n if proxies is None:\\n proxies = self._proxies\\n if readme_path is None:\\n readme_path = self._README_PATH\\n url = \\\"{}{}\\\".format(self._url, readme_path)\\n response = self._http.request(url=url, method=\\\"GET\\\", proxies=proxies)\\n if response is None:\\n return False\\n if \\\"Stable tag:\\\" not in response.text:\\n return False\\n version = response.text.split(\\\"Stable tag:\\\")[1].split(\\\"\\\\n\\\")[0] # get the version of the plugin\\n return self.is_vulnerable_version(version)\",\n \"def get_long_description():\\n with open(\\\"README.md\\\", \\\"r\\\") as fh:\\n return fh.read()\",\n \"def test_readme_exists():\\n assert os.path.isfile(\\\"README.md\\\"), \\\"README.md file missing!\\\"\",\n \"def test_session10_readme_proper_description():\\n READMELOOKSGOOD = True\\n f = open(\\\"README.md\\\", \\\"r\\\", encoding=\\\"utf-8\\\")\\n content = f.read()\\n f.close()\\n for c in README_CONTENT_CHECK_FOR:\\n if c not in content:\\n print(c)\\n READMELOOKSGOOD = False\\n pass\\n assert READMELOOKSGOOD == True, \\\"You have not described all the functions/class well in your README.md file\\\"\",\n \"def create_file(file_name: str, startup_text: str) -> None:\\n with open(file_name, 'w') as f:\\n f.write(startup_text)\",\n \"def test_readme_proper_description():\\n READMELOOKSGOOD = True\\n f = open(\\\"README.md\\\", \\\"r\\\", encoding=\\\"utf-8\\\")\\n content = f.read()\\n f.close()\\n for c in README_CONTENT_CHECK_FOR:\\n if c not in content:\\n print(c)\\n READMELOOKSGOOD = False\\n break\\n\\n assert READMELOOKSGOOD is True, \\\"You have not described all the functions/class well in your README.md file\\\"\",\n \"def test_session10_readme_exists():\\n assert os.path.isfile(\\\"README.md\\\"), \\\"README.md file missing!\\\"\",\n \"def get_description():\\n with open(\\\"README.rst\\\", \\\"rb\\\") as readme:\\n long_description = readme.read().decode(\\\"utf-8\\\")\\n return long_description\",\n \"def create_new_project():\\n readline.parse_and_bind('tab: complete')\\n\\n print \\\\\\n\\\"\\\"\\\"\\n xbmcswift2 - A micro-framework for creating XBMC plugins.\\n xbmc@jonathanbeluch.com\\n --\\n\\\"\\\"\\\"\\n print 'I\\\\'m going to ask you a few questions to get this project' \\\\\\n ' started.'\\n\\n # noinspection PyDictCreation\\n opts = {}\\n\\n # Plugin Name\\n opts['plugin_name'] = get_valid_value(\\n 'What is your plugin name?',\\n validate_nonblank\\n )\\n\\n # Plugin ID\\n opts['plugin_id'] = get_valid_value(\\n 'Enter your plugin id.',\\n validate_pluginid,\\n 'plugin.video.%s' % (opts['plugin_name'].lower().replace(' ', ''))\\n )\\n\\n # Parent Directory\\n opts['parent_dir'] = get_valid_value(\\n 'Enter parent folder (where to create project)',\\n validate_isfolder,\\n getcwd()\\n )\\n opts['plugin_dir'] = os.path.join(opts['parent_dir'], opts['plugin_id'])\\n assert not os.path.isdir(opts['plugin_dir']), \\\\\\n 'A folder named %s already exists in %s.' % (opts['plugin_id'],\\n opts['parent_dir'])\\n\\n # Provider\\n opts['provider_name'] = get_valid_value(\\n 'Enter provider name',\\n validate_nonblank,\\n )\\n\\n # Create the project folder by copying over skel\\n copytree(SKEL, opts['plugin_dir'], ignore=ignore_patterns('*.pyc'))\\n\\n # Walk through all the new files and fill in with out options\\n for root, dirs, files in os.walk(opts['plugin_dir']):\\n for filename in files:\\n update_file(os.path.join(root, filename), opts)\\n\\n print 'Projects successfully created in %s.' % opts['plugin_dir']\\n print 'Done.'\",\n \"def createTXT(self):\\n now = dt.datetime.now().strftime(\\\"%m-%d %H-%M\\\")\\n self.filename = \\\"bwcca_tags \\\" + now\\n try:\\n if \\\"/\\\" in self.dir_lbl[\\\"text\\\"]:\\n desired_list = self.phraseMaker()\\n with open(f\\\"{self.folder}/{self.filename}.txt\\\", \\\"w\\\") as f:\\n for i in desired_list:\\n f.write(f\\\"{i}\\\\n\\\")\\n self.stat_lbl[\\\"text\\\"] = f\\\"/{self.filename} created!\\\"\\n else:\\n self.dir_lbl[\\\"text\\\"] = \\\"Select a folder!\\\"\\n self.dir_btn.focus()\\n except Exception as e:\\n self.dir_lbl[\\\"text\\\"] = e\",\n \"def readme_path(request):\\n # README path needs to be relative to the test.\\n test_path = os.path.dirname(os.path.realpath(request.module.__file__))\\n return os.path.join(test_path, '..', '..', 'README.md')\",\n \"def readme_tests(readme=None):\\n if readme is None:\\n readme = Path('..', 'readme.md')\\n with open(readme) as target:\\n for line in target:\\n if line.startswith(' ') and 'test_utils' not in line:\\n print()\\n print(line)\\n input('Press Enter to execute')\\n sb.run(line, shell=True, check=True)\",\n \"def create_file():\\n with open(\\\"example.txt\\\", \\\"w\\\") as file:\\n file.write(\\\"\\\")\",\n \"def help_create(self):\\n print(CREATE)\",\n \"def create_license(self) -> None:\\n # copy the license file from the template to the package folder\\n # option : append other license files\\n shutil.copy(CONFIG.template_path / \\\"LICENSE.md\\\", self.package_path)\",\n \"def test_init_with_description(isolated_runner, template):\\n result = isolated_runner.invoke(\\n cli, [\\\"init\\\", \\\"--description\\\", \\\"my project description\\\", \\\"new project\\\", \\\"--template-id\\\", template[\\\"id\\\"]]\\n )\\n\\n assert 0 == result.exit_code, format_result_exception(result)\\n\\n database = Database.from_path(Path(\\\"new project\\\") / \\\".renku\\\" / \\\"metadata\\\")\\n project = database.get(\\\"project\\\")\\n\\n assert \\\"new project\\\" == project.name\\n assert project.id.endswith(\\\"new-project\\\") # make sure id uses slug version of name without space\\n assert \\\"my project description\\\" in project.template_metadata\\n assert \\\"my project description\\\" == project.description\\n\\n readme_content = (Path(\\\"new project\\\") / \\\"README.md\\\").read_text()\\n assert \\\"my project description\\\" in readme_content\",\n \"def find_long_description():\\n return read_file('../README.md')\",\n \"def _get_bids_readme(self):\\n readme = []\\n # Grab all readme files, loop through\\n for README_fname in [\\n file for file in Path(self.dataset.path).glob(\\\"[Rr][Ee][Aa][Dd][Mm][Ee]*\\\")\\n ]:\\n # datalad get content if annexed\\n self.dataset.get(README_fname)\\n # read text from file\\n try:\\n file_text = ensure_unicode(README_fname.read_text()).strip()\\n except:\\n file_text = \\\"\\\"\\n # Append dict with file text + extension to list\\n readme.append({\\\"extension\\\": README_fname.suffix, \\\"text\\\": file_text})\\n return readme if readme else None\",\n \"def WriteDiary():\\r\\n from datetime import datetime\\r\\n\\r\\n diaryname = _getPOSCAR()\\r\\n diary = open(diaryname, \\\"w\\\")\\r\\n diary.write('***' + str(datetime.now()) + '***' + '\\\\n')\\r\\n diary.write('## ' + diaryname + '\\\\n')\\r\\n diary.close()\\r\\n _CopyWriteDiary('Readme', diaryname)\\r\\n _CopyWriteDiary('INCAR', diaryname)\\r\\n _CopyWriteDiary('KPOINTS', diaryname)\\r\\n _CopyWriteDiary('POSCAR', diaryname)\\r\\n _CopyWriteDiary('POTCAR', diaryname)\\r\\n os.rename(diaryname, diaryname + '.md')\",\n \"def get_long_description():\\n with open(path.join(root_path, \\\"README.md\\\"), encoding=\\\"utf-8\\\") as f:\\n long_description = f.read()\\n return long_description\",\n \"def make_document_metadata(name: str,\\n version: Optional[str] = None,\\n contact: Optional[str] = None,\\n description: Optional[str] = None,\\n authors: Optional[str] = None,\\n copyright: Optional[str] = None,\\n licenses: Optional[str] = None,\\n disclaimer: Optional[str] = None,\\n ) -> Iterable[str]:\\n yield '#' * 80\\n yield '#| Metadata'\\n yield '#' * 80 + '\\\\n'\\n\\n yield 'SET DOCUMENT Name = \\\"{}\\\"'.format(name)\\n yield 'SET DOCUMENT Version = \\\"{}\\\"'.format(version or time.strftime('%Y%m%d'))\\n\\n if description:\\n yield 'SET DOCUMENT Description = \\\"{}\\\"'.format(description.replace('\\\\n', ''))\\n\\n if authors:\\n yield 'SET DOCUMENT Authors = \\\"{}\\\"'.format(authors)\\n\\n if contact:\\n yield 'SET DOCUMENT ContactInfo = \\\"{}\\\"'.format(contact)\\n\\n if licenses:\\n yield 'SET DOCUMENT Licenses = \\\"{}\\\"'.format(licenses)\\n\\n if copyright:\\n yield 'SET DOCUMENT Copyright = \\\"{}\\\"'.format(copyright)\\n\\n if disclaimer:\\n yield 'SET DOCUMENT Disclaimer = \\\"{}\\\"'.format(disclaimer)\\n\\n yield ''\",\n \"def new(self, article_name):\\n name = article_name.strip(\\\" \\\")\\n\\n file_path = os.path.join('article', name + '.md')\\n io.write(file_path, '')\\n\\n io.write('.last_article', file_path)\\n\\n self.write()\",\n \"def new_entry(title, content):\\n\\n title.strip # Remove the spaces from both sides.\\n filename = f\\\"entries/{title}.md\\\"\\n if default_storage.exists(filename):\\n return False\\n default_storage.save(filename, ContentFile(content))\\n return True\",\n \"def mnote(tmp_path) -> Path:\\n path = tmp_path/\\\"test.md\\\"\\n path.write_text(\\\"# 0 Test\\\\n\\\\nTest note.\\\\n\\\")\\n yield path\",\n \"def update_readme_data(readme_file, **readme_updates):\\n\\n extensions_key = \\\"base\\\"\\n extensions = readme_updates[\\\"extensions\\\"]\\n\\n if extensions:\\n extensions_key = \\\"-\\\".join(extensions)\\n\\n output_folder = readme_updates[\\\"outputsubfolder\\\"]\\n generation_data = {\\n \\\"location\\\": path_join_robust(output_folder, \\\"\\\"),\\n \\\"entries\\\": readme_updates[\\\"numberofrules\\\"],\\n \\\"sourcesdata\\\": readme_updates[\\\"sourcesdata\\\"],\\n }\\n\\n with open(readme_file, \\\"r\\\") as f:\\n readme_data = json.load(f)\\n readme_data[extensions_key] = generation_data\\n\\n for denomination, data in readme_data.copy().items():\\n if \\\"location\\\" in data and data[\\\"location\\\"] and \\\"\\\\\\\\\\\" in data[\\\"location\\\"]:\\n # Windows compatibility: #1166\\n readme_data[denomination][\\\"location\\\"] = data[\\\"location\\\"].replace(\\\"\\\\\\\\\\\", \\\"/\\\")\\n\\n with open(readme_file, \\\"w\\\") as f:\\n json.dump(readme_data, f)\",\n \"def init():\\n if not os.path.exists(BASE_PATH):\\n os.makedirs(BASE_PATH)\\n\\n title = click.prompt(\\\"Title\\\")\\n author = click.prompt(\\\"Author\\\")\\n\\n with click.open_file(os.path.join(BASE_PATH, \\\".title\\\"), 'w') as title_file:\\n title_file.write(title)\\n\\n with click.open_file(os.path.join(BASE_PATH, \\\".author\\\"), 'w') as author_file:\\n author_file.write(author)\\n\\n else:\\n click.echo('Notes repository is initialized already.')\",\n \"def create_file(self, name: str, content: str) -> None:\\n file_path = self.path + os.path.sep + name\\n with open(file_path, \\\"w+\\\") as file:\\n file.write(content)\\n file.close()\",\n \"def render_readme(self):\\r\\n return self.manifest.get(\\\"render_readme\\\", False)\",\n \"def task_mkdocs():\\n return Task(\\n file_dep=[MKDOCS],\\n actions=[\\n (needs, [\\\"jupyter_book\\\"]),\\n ],\\n uptodate=[not MKDOCS.exists()],\\n )\",\n \"def about():\\n# return about string\\n about = (\\\"\\\"\\\"\\nJADM %s\\n-------------\\ncreator: Nikolay Georgiev Dachev, <nikolay@dachev.info>\\nsupport: jadm@dachev.info (only for bugs report and jadm issues)\\n\\nJadm is FreeBSD jail administration framework with jail.conf, vnet and zfs support.\\n\\n---------------- JADM is BSD 3-Clause Licensed ---------------------\\n\\nCopyright (c) <2014>, <Nikolay Georgiev Dachev> <nikolay@dachev.info>\\nAll rights reserved.\\n\\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\\n\\n1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\\n\\n2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distr\\n\\n3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\\n\\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \\\"AS IS\\\" AND ANY EXPRESS OR IMPLIED WARRANTIES,\\nINCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\\nIN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,\\nOR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\\n LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\\n OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\\n\\\"\\\"\\\") % (jadm_version)\\n return about\",\n \"def about():\\n return render_template(\\n 'about.jade',\\n title='About',\\n year=datetime.now().year,\\n repository_name=repository.name,\\n )\",\n \"def cmd_mkd(args):\",\n \"def _(fname: str) -> str:\\n with open(os.path.join(os.getcwd(), fname)) as readme:\\n content = readme.read() or '' # prevent ``content = None``\\n return content\",\n \"def create_conf_file (self, data, directory=None):\\n data.insert(0, \\\"# this file is automatically created by setup.py\\\")\\n data.insert(0, \\\"# -*- coding: iso-8859-1 -*-\\\")\\n if directory is None:\\n directory = os.getcwd()\\n filename = self.get_conf_filename(directory)\\n # add metadata\\n metanames = (\\\"name\\\", \\\"version\\\", \\\"author\\\", \\\"author_email\\\",\\n \\\"maintainer\\\", \\\"maintainer_email\\\", \\\"url\\\",\\n \\\"license\\\", \\\"description\\\", \\\"long_description\\\",\\n \\\"keywords\\\", \\\"platforms\\\", \\\"fullname\\\", \\\"contact\\\",\\n \\\"contact_email\\\")\\n for name in metanames:\\n method = \\\"get_\\\" + name\\n val = getattr(self.metadata, method)()\\n data.append(\\\"%s = %r\\\" % (name, val))\\n data.append('release_date = \\\"%s\\\"' % get_release_date())\\n # write the config file\\n util.execute(write_file, (filename, data),\\n \\\"creating %s\\\" % filename, self.verbose >= 1, self.dry_run)\",\n \"def create_file(self, value=None):\\n if not path.isdir(\\\"Project\\\"):\\n system(\\\"mkdir Project\\\")\\n string_to_systemize = \\\"echo \\\\\\\"#!/usr/bin/python\\\\n\\\" + \\\\\\n \\\"# Please use fp = open(\\\\'Project/yourfile.*\\\\') \\\" + \\\\\\n \\\"when opening YOUR files\\\\n\\\" + \\\\\\n \\\"# to not lose YOUR file in the jumble of OTHER files.\\\\n\\\" + \\\\\\n \\\"# Also, do NOT delete the very first comment line.\\\\n\\\" + \\\\\\n \\\"# \\\\'logs.txt\\\\' is your friend for your error logs.\\\\\\\"\\\" + \\\\\\n \\\"> Project/myfile.py\\\"\\n system(string_to_systemize)\\n system(\\\"chmod +x Project/myfile.py\\\")\\n self.open_file()\",\n \"def test_readme_commands(self, client):\\n with open(REPO_ROOT / \\\"README.md\\\") as f:\\n readme = f.read()\\n\\n documented = set(re.findall(\\\"^- `!([a-z]+)`: .*$\\\", readme, re.MULTILINE))\\n implemented = set(client.commands)\\n\\n assert documented == implemented\",\n \"def test_readme():\\n notebooks_readme = Path(\\\"notebooks/README.md\\\").read_text()\\n for item in Path(\\\"notebooks\\\").iterdir():\\n if item.is_dir():\\n # item is a notebook directory\\n notebook_dir = item.relative_to(\\\"notebooks\\\")\\n if str(notebook_dir)[0].isdigit():\\n assert \\\"README.md\\\" in [filename.name for filename in item.iterdir()], \\\\\\n f\\\"README not found in {item}\\\"\\n assert str(notebook_dir) in notebooks_readme, f\\\"{item} not found in notebooks README\\\"\",\n \"def makeHTML(header, body, footer):\\n f = open(\\\"crimenews.html\\\", \\\"w\\\")\\n f.write(header+body+footer)\",\n \"def provide_html_template():\\n get_content = str(input(\\\"Paste the content you want to see displayed in the browser here. \\\\n\\\"))\\n get_name = input(\\\"I am going to create an html file with your content. What do you want to call your file? \\\\n\\\")\\n \\n new_html_file = open(str(get_name) + '.html', 'w')\\n \\n page_content = '<html><head></head><body><p>' + get_content + '</p></body></html>'\\n \\n new_html_file.write(page_content)\\n new_html_file.close()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7987224","0.782059","0.7738895","0.77343196","0.76951265","0.7692684","0.7475079","0.740073","0.7256037","0.70500207","0.6997206","0.69900995","0.68761015","0.68635523","0.68394893","0.6829391","0.6792584","0.6766892","0.6707527","0.6680079","0.66443956","0.66354436","0.6514962","0.6513105","0.6493902","0.6449785","0.6445449","0.6373121","0.6355521","0.63379145","0.6310446","0.6299402","0.62764204","0.6273953","0.62109447","0.61801934","0.61604035","0.6129011","0.6127855","0.61251473","0.6095324","0.60782826","0.6020121","0.59516686","0.5947599","0.5919914","0.5872174","0.5867771","0.58544713","0.5845482","0.58391196","0.5813582","0.5799936","0.57834333","0.57774866","0.5767235","0.57266825","0.57205385","0.57142425","0.56946224","0.56940347","0.56933767","0.5676947","0.5644538","0.5636615","0.5616328","0.56146127","0.56096995","0.56050044","0.56043166","0.5587232","0.55743605","0.5571715","0.55697143","0.5569513","0.55687934","0.55669063","0.5564203","0.55475247","0.55423254","0.5541226","0.5537256","0.55328524","0.55149126","0.54933673","0.5485428","0.54714704","0.5467004","0.5454289","0.5447018","0.5432022","0.5421882","0.5413241","0.54084766","0.5392819","0.5390664","0.5387613","0.5380935","0.5378133","0.5367816"],"string":"[\n \"0.7987224\",\n \"0.782059\",\n \"0.7738895\",\n \"0.77343196\",\n \"0.76951265\",\n \"0.7692684\",\n \"0.7475079\",\n \"0.740073\",\n \"0.7256037\",\n \"0.70500207\",\n \"0.6997206\",\n \"0.69900995\",\n \"0.68761015\",\n \"0.68635523\",\n \"0.68394893\",\n \"0.6829391\",\n \"0.6792584\",\n \"0.6766892\",\n \"0.6707527\",\n \"0.6680079\",\n \"0.66443956\",\n \"0.66354436\",\n \"0.6514962\",\n \"0.6513105\",\n \"0.6493902\",\n \"0.6449785\",\n \"0.6445449\",\n \"0.6373121\",\n \"0.6355521\",\n \"0.63379145\",\n \"0.6310446\",\n \"0.6299402\",\n \"0.62764204\",\n \"0.6273953\",\n \"0.62109447\",\n \"0.61801934\",\n \"0.61604035\",\n \"0.6129011\",\n \"0.6127855\",\n \"0.61251473\",\n \"0.6095324\",\n \"0.60782826\",\n \"0.6020121\",\n \"0.59516686\",\n \"0.5947599\",\n \"0.5919914\",\n \"0.5872174\",\n \"0.5867771\",\n \"0.58544713\",\n \"0.5845482\",\n \"0.58391196\",\n \"0.5813582\",\n \"0.5799936\",\n \"0.57834333\",\n \"0.57774866\",\n \"0.5767235\",\n \"0.57266825\",\n \"0.57205385\",\n \"0.57142425\",\n \"0.56946224\",\n \"0.56940347\",\n \"0.56933767\",\n \"0.5676947\",\n \"0.5644538\",\n \"0.5636615\",\n \"0.5616328\",\n \"0.56146127\",\n \"0.56096995\",\n \"0.56050044\",\n \"0.56043166\",\n \"0.5587232\",\n \"0.55743605\",\n \"0.5571715\",\n \"0.55697143\",\n \"0.5569513\",\n \"0.55687934\",\n \"0.55669063\",\n \"0.5564203\",\n \"0.55475247\",\n \"0.55423254\",\n \"0.5541226\",\n \"0.5537256\",\n \"0.55328524\",\n \"0.55149126\",\n \"0.54933673\",\n \"0.5485428\",\n \"0.54714704\",\n \"0.5467004\",\n \"0.5454289\",\n \"0.5447018\",\n \"0.5432022\",\n \"0.5421882\",\n \"0.5413241\",\n \"0.54084766\",\n \"0.5392819\",\n \"0.5390664\",\n \"0.5387613\",\n \"0.5380935\",\n \"0.5378133\",\n \"0.5367816\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6952783"},"document_rank":{"kind":"string","value":"12"}}},{"rowIdx":83181,"cells":{"query":{"kind":"string","value":"Update a readme file with supplied information."},"document":{"kind":"string","value":"def update_readme(readme: str, updated_metadata: dict = None, extra_lines: list = None):\n metadata, lines = read_readme(readme)\n if updated_metadata:\n metadata = {**metadata, **updated_metadata}\n if extra_lines:\n lines = lines + extra_lines\n write_readme(readme, metadata, lines)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def update_readme():\n\n temp = \"\"\"<head>\n <title>Unittest Results</title>\n <meta charset=\"utf-8\">\n <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n <link rel=\"stylesheet\" href=\"https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css\" integrity=\"sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7\" crossorigin=\"anonymous\">\n</head>\"\"\"\n\n with open(\"README_proxy.md\", \"r\") as old_readme_file:\n old_readme_txt = old_readme_file.read()\n\n with open(\"reports/test_result.html\", \"r\") as html_file:\n html = html_file.read().splitlines()[0:-21]\n html = \"\\n\".join(html).replace(temp, \"\")\n\n with open(\"README.md\", \"w\") as new_readme_file:\n new_readme_file.write(old_readme_txt + \"\\n\\n\\n\" + html + \"</body></html>\")","def update_readme_data(readme_file, **readme_updates):\n\n extensions_key = \"base\"\n extensions = readme_updates[\"extensions\"]\n\n if extensions:\n extensions_key = \"-\".join(extensions)\n\n output_folder = readme_updates[\"outputsubfolder\"]\n generation_data = {\n \"location\": path_join_robust(output_folder, \"\"),\n \"entries\": readme_updates[\"numberofrules\"],\n \"sourcesdata\": readme_updates[\"sourcesdata\"],\n }\n\n with open(readme_file, \"r\") as f:\n readme_data = json.load(f)\n readme_data[extensions_key] = generation_data\n\n for denomination, data in readme_data.copy().items():\n if \"location\" in data and data[\"location\"] and \"\\\\\" in data[\"location\"]:\n # Windows compatibility: #1166\n readme_data[denomination][\"location\"] = data[\"location\"].replace(\"\\\\\", \"/\")\n\n with open(readme_file, \"w\") as f:\n json.dump(readme_data, f)","def readme_md(cls):\n\n template = Helpers.File(Settings.readme_me_template).read()\n\n template = Helpers.Regex(\n template, r\"%%version%%\", replace_with=Settings.version\n ).replace()\n template = Helpers.Regex(\n template, r\"%%lenHosts%%\", replace_with=format(len(Settings.domains), \",d\")\n ).replace()\n template = Helpers.Regex(\n template, r\"%%lenIPs%%\", replace_with=format(len(Settings.ips), \",d\")\n ).replace()\n template = Helpers.Regex(\n template,\n r\"%%lenHostsIPs%%\",\n replace_with=format(len(Settings.ips) + len(Settings.domains), \",d\"),\n ).replace()\n\n print(\"Generation of %s\" % Settings.readme_md_file, end=\" \")\n Helpers.File(Settings.readme_md_file).write(template, overwrite=True)\n print(Settings.done)","def fix_readme(self):\n import re\n\n readme = os.path.join(os.path.dirname(__file__), \"README.md\")\n with open(readme, \"r\") as f:\n content = f.read()\n\n tag = self.get_tag()\n if not tag:\n raise AssertionError(\n \"Could not get tag! (are you checking out with full tag history?)\"\n )\n\n new_content = re.sub(\n r\"\\(docs/\",\n rf\"(https://github.com/robocorp/robotframework-lsp/tree/{tag}/robocorp-code/docs/\",\n content,\n )\n\n new_content = re.sub(\n r\"\\(images/\",\n rf\"(https://raw.githubusercontent.com/robocorp/robotframework-lsp/{tag}/robocorp-code/images/\",\n content,\n )\n\n new_content = new_content.replace(\n \"Apache 2.0\",\n \"[Robocorp License Agreement (pdf)](https://cdn.robocorp.com/legal/Robocorp-EULA-v1.0.pdf)\",\n )\n\n assert \"apache\" not in new_content.lower()\n with open(readme, \"w\") as f:\n f.write(new_content)","def churn(old_readme: str, /) -> str | None:\n # getting content\n if not (waka_stats := fetch_stats()):\n logger.error('Unable to fetch data, please rerun workflow\\n')\n sys.exit(1)\n # processing content\n try:\n generated_content = prep_content(waka_stats)\n except AttributeError as err:\n logger.error(f'Unable to read API data | {err}\\n')\n sys.exit(1)\n print(generated_content, '\\n', sep='')\n new_readme = re.sub(\n pattern=wk_i.waka_block_pattern,\n repl=f'{wk_i.start_comment}\\n\\n```text\\n{generated_content}\\n```\\n\\n{wk_i.end_comment}',\n string=old_readme\n )\n if len(sys.argv) == 2 and sys.argv[1] == '--dev':\n logger.debug('Detected run in `dev` mode.')\n # to avoid accidentally writing back to Github\n # when developing and testing WakaReadme\n return None\n\n return None if new_readme == old_readme else new_readme","def test_readme():\n readme = Path(README_PATH).read_text()\n Actions.read_from_md(readme)","def start(self) -> \"UpdaterBase\":\n\n if self.administration.raw_link:\n with importlib.resources.path(\n \"ultimate_hosts_blacklist.test_launcher.data.docs\",\n \"about_repository.md\",\n ) as file_path:\n content = FileHelper(str(file_path)).read()\n else:\n with importlib.resources.path(\n \"ultimate_hosts_blacklist.test_launcher.data.docs\",\n \"about_repository_self.md\",\n ) as file_path:\n content = FileHelper(str(file_path)).read()\n\n content += \"\\n\\n\"\n\n with importlib.resources.path(\n \"ultimate_hosts_blacklist.test_launcher.data.docs\", \"about_ultimate.md\"\n ) as file_path:\n content += FileHelper(str(file_path)).read()\n\n content += \"\\n\\n\"\n\n with importlib.resources.path(\n \"ultimate_hosts_blacklist.test_launcher.data.docs\", \"about_pyfunceble.md\"\n ) as file_path:\n content += FileHelper(str(file_path)).read()\n\n content += \"\\n\"\n\n readme_file = FileHelper(\n os.path.join(outputs.CURRENT_DIRECTORY, outputs.README_FILENAME)\n )\n readme_file.write(content, overwrite=True)\n\n logging.info(\"Updated: %r\", readme_file.path)","def _write_readme(variables):\n with open(locations.readme_template) as source:\n with open(locations.readme, \"w\") as destination:\n contents = source.read()\n contents = contents.format(**variables)\n destination.write(contents)","def update_md(user, title, md_path):\n with open(md_path, \"a\") as f:\n f.writelines(f\"[@{user}](https://github.com/{user}) | {title}\\n\")","def readme():\n with open('README.md') as readme_file:\n return readme_file.read()","def readme():\n with open('README.rst') as f:\n return f.read()","def readme():\n with open('README.md') as _file:\n return _file.read()","def make_readme_txt(self, args):\n with open(self.readme_txt, 'w') as writer:\n log.info(\"args=%s\\n\", args)\n writer.write(\"# Created by pbtranscript-internal-validation.ValidationRunner.make_readme_txt()\\n\")\n writer.write(\"args=%s\\n\\n\" % args)\n\n files = self.common_files + self.collapse_human_files + self.reseq_human_files + self.sirv_files\n for desc, fn in files:\n if op.exists(fn):\n writer.write(\"%s=%s\\n\" % (desc, fn))","def with_readme(request, new_package):\n\n new_module, pkg_root = new_package\n pkg_name = os.path.basename(pkg_root)\n\n with open(os.path.join(new_module, \"README\"), \"w\") as openreadme:\n openreadme.write(\"{n}\\n{d}\\n\\n{n}'s readme... with content!\".format(\n n=pkg_name,\n d=\"=\" * len(pkg_name),\n ))\n\n with open(os.path.join(new_module, META_NAME), \"w\") as openmeta:\n openmeta.write(\n '{\"packages\": [\"find_packages()\"], \"long_description\": \"README\"}'\n )\n\n request.addfinalizer(module_cleanup)\n return new_module, pkg_root","def readme():\n\n with open('README.rst') as readme_file:\n return readme_file.read()","def readme():\n with open(os.path.join(build_root, 'README.rst')) as f:\n return f.read()","def create_readme(self) -> None:\n # read the readme file and update the version and description\n with open(CONFIG.template_path / \"README.md\", \"r\") as f:\n TEMPLATE_README = f.read()\n\n # add a readme with the names of the stub-folders\n\n # read informations from firmware_stubs.json\n firmware_stubs = {}\n doc_stubs = {}\n core_stubs = {}\n try:\n with open(self.package_path / \"firmware_stubs.json\", \"r\") as f:\n firmware_stubs = json.load(f)\n with open(self.package_path / \"doc_stubs.json\", \"r\") as f:\n doc_stubs = json.load(f)\n with open(self.package_path / \"modules.json\", \"r\") as f:\n core_stubs = json.load(f)\n except FileNotFoundError:\n pass\n\n # Prettify this by merging with template text\n with open(self.package_path / \"README.md\", \"w\") as f:\n f.write(f\"# {self.package_name}\\n\\n\")\n f.write(TEMPLATE_README)\n f.write(f\"Included stubs:\\n\")\n for name, folder in self.stub_sources:\n f.write(f\"* {name} from `stubs/{Path(folder).as_posix()}`\\n\")\n\n f.write(f\"\\n\\n\")\n f.write(f\"origin | Family | Port | Board | Version\\n\")\n f.write(f\"-------|--------|------|-------|--------\\n\")\n try:\n f.write(\n f\"Firmware | {firmware_stubs['firmware']['family']} | {firmware_stubs['firmware']['port']} | {firmware_stubs['firmware']['machine']} | {clean_version(firmware_stubs['firmware']['version'])} \\n\"\n )\n except Exception:\n pass\n try:\n f.write(\n f\"Documentation | {doc_stubs['firmware']['family']} | {doc_stubs['firmware']['port']} | - | {clean_version(doc_stubs['firmware']['version'])} \\n\"\n )\n except Exception:\n pass\n try:\n f.write(\n f\"Core | {core_stubs['firmware']['family']} | {core_stubs['firmware']['port']} | - | {clean_version(core_stubs['firmware']['version'])} \\n\"\n )\n except Exception:\n pass","def main(src_file=\"README.md\", dst_file=\"docs/documentation.json\"):\n with open(src_file, \"r\") as readme:\n markdown = readme.read()\n\n data = {\n \"info\": {\n \"termsOfService\": \"https://github.com/bombsimon/redoc-theme\",\n \"description\": markdown,\n \"license\": {\n \"url\": \"https://opensource.org/licenses/MIT\",\n \"name\": \"MIT\",\n },\n \"title\": \"ReDoc Theme\",\n \"version\": \"1.0\",\n \"contact\": {\"email\": \"simon@sawert.se\"},\n \"x-logo\": {\"url\": \"assets/logo.png\"},\n },\n \"swagger\": \"2.0\",\n }\n\n with open(dst_file, \"w\") as doc_json:\n json.dump(data, doc_json, indent=2)","def make_readme(digest):\n o = 'SHA1 digest: %s\\n\\n'%digest[:10]\n print '...build readme file for GitHub' \n open('README.md','w').write(o + make_readme.__doc__)","def readme(fname='README'):\n with open(os.path.join(os.path.dirname(__file__), fname)) as file:\n return file.read()","def _readme_file(self, readme_path=None, proxies=None):\n if proxies is None:\n proxies = self._proxies\n if readme_path is None:\n readme_path = self._README_PATH\n url = \"{}{}\".format(self._url, readme_path)\n response = self._http.request(url=url, method=\"GET\", proxies=proxies)\n if response is None:\n return False\n if \"Stable tag:\" not in response.text:\n return False\n version = response.text.split(\"Stable tag:\")[1].split(\"\\n\")[0] # get the version of the plugin\n return self.is_vulnerable_version(version)","def create_readme(case_dict):\n # ---------------------------------------------------------------------\n logger.debug(\"create_readme\")\n os.chdir(case_dict[\"archive_temp_dir\"])\n\n fname = open(\"README.archive\", \"w\")\n fname.write(\"Archived metadata is available for this case at URL:\\n\")\n fname.write(case_dict[\"base_expdb_url\"])\n fname.close()","def OpenReadMe():\n location = os.path.join(os.path.dirname(__file__), \"README.txt\")\n os.startfile(location)","def write_readme(readme: str, metadata: dict, lines: list = None):\n with open(readme, \"w\") as f:\n for k, v in metadata.items():\n print(f\"{k}: {v}\", file=f)\n if lines:\n for line in lines:\n print(line, file=f)","def readme(self, ref=None):\r\n params = base.get_params(None, locals())\r\n url = '{0}/readme'.format(self.parent.get_url())\r\n\r\n return http.Request('GET', url, params), parsers.parse_json","def readmegen(session, sample):\n session.install('jinja2', 'pyyaml')\n\n if os.path.exists(os.path.join(sample, 'requirements.txt')):\n session.install('-r', os.path.join(sample, 'requirements.txt'))\n\n in_file = os.path.join(sample, 'README.rst.in')\n session.run('python', 'scripts/readme-gen/readme_gen.py', in_file)","def _readme(datatype, fname, overwrite=False):\n if os.path.isfile(fname) and not overwrite:\n with open(fname, \"r\", encoding=\"utf-8-sig\") as fid:\n orig_data = fid.read()\n mne_bids_ref = REFERENCES[\"mne-bids\"] in orig_data\n datatype_ref = REFERENCES[datatype] in orig_data\n if mne_bids_ref and datatype_ref:\n return\n text = \"{}References\\n----------\\n{}{}\".format(\n orig_data + \"\\n\\n\",\n \"\" if mne_bids_ref else REFERENCES[\"mne-bids\"] + \"\\n\\n\",\n \"\" if datatype_ref else REFERENCES[datatype] + \"\\n\",\n )\n else:\n text = \"References\\n----------\\n{}{}\".format(\n REFERENCES[\"mne-bids\"] + \"\\n\\n\", REFERENCES[datatype] + \"\\n\"\n )\n\n _write_text(fname, text, overwrite=True)","def OpenReadMe():\n location = os.path.join(os.path.dirname(__file__), \"README.txt\")\n os.startfile(location)\n return","def get_readme_text(self):\n if self.readme_file:\n readme_text = self.readme_file.read_text(encoding=\"utf-8\")\n else:\n readme_text = \"# foxBMS 2 GUI\"\n return readme_text","def update(self, namein, nameout):\n\t\ttext = self.dict.sub(self.readFile(namein))\n\t\tself.writeFile(nameout, text)\n\t\treturn","def edit(ctx, name, header):\n\n # create local copies of ctx vaiables for easy access\n path = ctx.obj[\"path\"]\n gitCommand = ctx.obj[\"gitCommand\"]\n\n if(not isdir(path)):\n print(\"No notes directory found at \" + path)\n return\n\n if(header != ''):\n system('touch ' + path + '/' + name)\n system('echo ' + header + \" > \" + path + '/' + name)\n\n system('$EDITOR ' + path + \"/\" + name)\n system(gitCommand + \"add .\")\n system(gitCommand + \"commit -m 'edited \" + name + \"'\")","def edit_files(i_file):\n a_file = open(i_file, \"r\")\n content = a_file.readlines()\n\n content[3] = f\"years: {datetime.now().year}\\n\"\n content[4] = f'lastupdated: \"{date.today()}\"\\n'\n a_file = open(i_file, \"w\") #open the same file and overrite line3 & 4\n a_file.writelines(content)\n\n a_file.close()","def create_readme(histfile, vb):\n\tme = \"Utils.create_readme: \"\n\treadmefile = os.path.dirname(histfile)+\"/README.txt\"\n\ttry:\n\t\tassert os.path.isfile(readmefile)\n\texcept AssertionError:\n\t\tnow = str(datetime.now().strftime(\"%Y-%m-%d %H.%M\"))\n\t\tcommit = subprocess.check_output(['git', 'rev-parse', 'HEAD'])\n\t\theader = \"Time:\\t\"+now+\"\\nCommit hash:\\t\"+commit+\"\\n\\n\"\n\t\twith open(readmefile,\"w\") as f:\n\t\t\tf.write(header)\n\t\tif vb: print me+\"Created readme file \"+readmefile\n\treturn","def get_fsleyes_readme():\n with open(op.join(basedir, 'README.rst'), 'rt', encoding='utf-8') as f:\n return f.read().strip()","def process(dirty):\n log('processing', dirty.name)\n raw = db.one( 'SELECT readme_raw FROM packages '\n 'WHERE package_manager=%s and name=%s and readme_needs_to_be_processed'\n , (dirty.package_manager, dirty.name)\n )\n if raw is None:\n return\n processed = _render(raw)\n db.run('''\n\n UPDATE packages\n SET readme=%s\n , readme_needs_to_be_processed=false\n WHERE package_manager=%s\n AND name=%s\n\n ''', ( processed\n , dirty.package_manager\n , dirty.name\n ))","def _create_readme(self, name, summary, description):\n return \"\"\"\n %(header_bar)s\n %(header)s\n %(header_bar)s\n\n %(content)s\n \"\"\" % {\n 'header': name,\n 'header_bar': '=' * len(name),\n 'content': '\\n\\n'.join(\n content\n for content in (summary, description)\n if content\n ) or 'Describe your extension.',\n }","def update_changelog_file(log_lines, version):\n with open(\n f\"docs/changelog/{version}.md\", \"w+\", encoding=\"utf-8\"\n ) as change_log_file:\n for line in log_lines:\n LOG.info(line)\n change_log_file.write(line + \"\\n\")","def deploy(version):\n toolkit.readmegen(version)","def parse_readme():\n # Get the long description from the relevant file\n readme_path = path.join(here, 'README.md')\n with codecs.open(readme_path, encoding='utf-8') as handle:\n desc = handle.read()\n\n return desc","async def info(self, ctx):\r\n openfile = open(\"info.txt\", \"r\")\r\n embed = discord.Embed(title='Aristobot', description='This is a bot made by Aristoza that uses the TrueSkill '\r\n 'python package (http://trueskill.org/) which is based on '\r\n 'the '\r\n 'TrueSkill rating system developed by Microsoft.',\r\n color=33023)\r\n embed.add_field(name='How it works', value=openfile.read(), inline=False)\r\n await ctx.send(embed=embed)","def build_readme(comic: str, readme: str) -> str:\n img = f\"{START_COMMENT}\\n{comic}\\n{END_COMMENT}\"\n return re.sub(listReg, img, readme)","def update_metadata(self):\n self.data[\"keywords\"] = self.repo.topics(self.data.get(\"keywords\", []))\n self.data[\"description\"] = self.data.get(\"description\") or self.repo.description\n self.data[\"codeRepository\"] = (\n self.data.get(\"codeRepository\") or self.repo.html_url\n )\n self.data[\"name\"] = self.data.get(\"name\") or self.repo.name\n self.data[\"issueTracker\"] = (\n self.data.get(\"issueTracker\") or self.repo.issues_url\n )\n self.data[\"license\"] = self.data.get(\"license\") or self.repo.license","def read_readme(setup_file, name=\"README.rst\"):\n import os\n TOP_DIR = os.path.abspath(os.path.dirname(setup_file))\n if not os.path.exists(TOP_DIR):\n raise FileNotFoundError(\n f\"Unable to find folder {TOP_DIR!r}.\")\n readme = os.path.join(TOP_DIR, name)\n if not os.path.exists(readme):\n raise FileNotFoundError(\n f\"Unable to find file {TOP_DIR!r}.\")\n with open(readme, \"r\", encoding=\"utf-8\") as f:\n content = f.read()\n return _clean_readme(content)","def get_readme():\n for name in ('README', 'README.rst', 'README.md'):\n if os.path.exists(name):\n return read_file(name)\n return ''","def test_readme_file_for_formatting():\n f = open(\"README.md\", \"r\", encoding=\"utf-8\")\n content = f.read()\n f.close()\n assert content.count(\"#\") >= 10, \"Readme is not formatted properly\"","def _fingerprint_readme(self, domain_path, wp_unique_url, response):\n wp_readme_url = domain_path.url_join('readme.html')\n response = self._uri_opener.GET(wp_readme_url, cache=True)\n\n # Find the string in the response html\n find = '<br /> Version (\\d\\.\\d\\.?\\d?)'\n m = re.search(find, response.get_body())\n\n # If string found, group version\n if m:\n version = m.group(1)\n\n desc = 'WordPress version \"%s\" found in the readme.html file.'\n desc = desc % version\n\n i = Info('Fingerprinted Wordpress version', desc, response.id,\n self.get_name())\n i.set_url(wp_readme_url)\n \n kb.kb.append(self, 'info', i)\n om.out.information(i.get_desc())","def view_help_info(self):\n try:\n with open('README.md', 'r') as f:\n data = f.readlines()\n log = Tk.Listbox(self, height=30, width=100)\n for i, item in enumerate(data):\n log.insert(i+1, data[i])\n log.grid(row =0, column=0, sticky='ew')\n yscroll = Tk.Scrollbar(command=log.yview,\n orient=Tk.VERTICAL)\n yscroll.grid(row=0, column=1, sticky='ns')\n except Exception, ex:\n logging.error(ex)\n traceback.print_exc()\n except Exception, ex:\n logging.error(ex)\n traceback.print_exc()","def update(self):\n self.content = self.get_content()\n self.dependencies = self.content['requirements']['run']\n self.pythonversion = self.content['extra']['pythonversion']\n self.package_name = self.content['package']['name']","def metadata_update(self, _):\n self.details.original_widget = YesNoWidget('Update metadata files?', self.__metadata_update)","def get_readme():\n for name in ('README', 'README.txt', 'README.rst', 'README.md'):\n if os.path.exists(name):\n return read_file(name)\n return ''","def make_doc(description=False, sentinel=COMMENT):\n for readme_path in [os.path.abspath(x) for x in glob(\"*/README.md\")]:\n with open(readme_path, \"r+\") as readme_file:\n readme = readme_file.read()\n if sentinel in readme:\n root = os.path.dirname(readme_path)\n tree = make_tree_doc(root)\n pattern = r\"{}.*?\\n(\\w+)?\\n\".format(sentinel)\n text = re.sub(pattern, format_tree(tree), readme, flags=re.DOTALL)\n readme_file.seek(0)\n readme_file.truncate()\n readme_file.write(text)","def test_readme_contents():\n readme = open(\"README.md\", \"r\", encoding=\"utf-8\")\n readme_words = readme.read().split()\n readme.close()\n assert len(readme_words) >= 500, \"Make your README.md file interesting! Add atleast 500 words\"","def __call__(self, read, info: ModificationInfo):","def _create_releaseinfo_file(projname, relinfo_str):\n dirs = projname.split('.')\n os.chdir(os.path.join(*dirs))\n print 'updating releaseinfo.py for %s' % projname\n with open('releaseinfo.py', 'w') as f:\n f.write(relinfo_str)","def Update(cli):\n help_text = HelpIndexGenerator(cli).Walk(hidden=False)\n def SerializeCommand(command):\n return resource_projector.Compile().Evaluate(command)\n\n help_text = SerializeCommand(help_text)\n\n # Overwrite the help search table file with updated content\n table_path = IndexPath()\n with open(table_path, 'w') as index_file:\n json.dump(help_text, index_file, sort_keys=True)\n index_file.write('\\n')\n log.warn('updated help index at {0}'.format(table_path))","def help_update(self):\n print(UPDATE)","def test_changeVersionInFile(self):\n # The version numbers are arbitrary, the name is only kind of\n # arbitrary.\n packageName = 'foo'\n oldVersion = Version(packageName, 2, 5, 0)\n file = self.makeFile('README',\n \"Hello and welcome to %s.\" % oldVersion.base())\n\n newVersion = Version(packageName, 7, 6, 0)\n _changeVersionInFile(oldVersion, newVersion, file.path)\n\n self.assertEqual(file.getContent(),\n \"Hello and welcome to %s.\" % newVersion.base())","def longdescription():\r\n print()\r\n here = path.abspath(path.dirname(__file__))\r\n with open(path.join(here, 'README.rst')) as f:\r\n long_description = f.read()\r\n\r\n print(long_description)","def cmd_update(self, text):\n self.update(text)","def test_readme_proper_description():\n READMELOOKSGOOD = True\n f = open(\"README.md\", \"r\", encoding=\"utf-8\")\n content = f.read()\n f.close()\n for c in README_CONTENT_CHECK_FOR:\n if c not in content:\n print(c)\n READMELOOKSGOOD = False\n break\n\n assert READMELOOKSGOOD is True, \"You have not described all the functions/class well in your README.md file\"","def test_session10_readme_proper_description():\n READMELOOKSGOOD = True\n f = open(\"README.md\", \"r\", encoding=\"utf-8\")\n content = f.read()\n f.close()\n for c in README_CONTENT_CHECK_FOR:\n if c not in content:\n print(c)\n READMELOOKSGOOD = False\n pass\n assert READMELOOKSGOOD == True, \"You have not described all the functions/class well in your README.md file\"","def add_title_author_info(filepath, title, author):\n with open(filepath, 'r') as f:\n # create a temporary file with the modified content before it replaces the original file\n temp_dir = tempfile.mkdtemp()\n try:\n temp_filepath = os.path.join(temp_dir, 'temp.p8')\n with open(temp_filepath, 'w') as temp_f:\n # flag meta data version replacement to avoid replacing an actual code line\n # starting with \"version \" later\n has_replaced_version = False\n for line in f:\n if not has_replaced_version and line.startswith('version '):\n temp_f.write('version 27\\n')\n has_replaced_version = True\n continue\n temp_f.write(line)\n if line.strip() == '__lua__':\n # lua block detected, add title and author after the tag line, if any was passed\n # if none was passed, we still call this method just so the version header gets update above\n if title:\n temp_f.write(f'-- {title}\\n')\n if author:\n temp_f.write(f'-- by {author}\\n')\n shutil.copy(temp_filepath, filepath)\n finally:\n shutil.rmtree(temp_dir)","def main():\n # Get the date and time in a formatted string.\n today = datetime.datetime.today()\n date_formatted = today.strftime(\"%Y-%m-%d\")\n time_formatted = today.strftime(\"%H:%M:%S\")\n\n # Form the file name and path.\n file_name = date_formatted+\"-post.md\"\n file_path = os.path.join(POSTS_DIR, file_name)\n\n # Make the new header.\n header = HEADER_TEMPLATE.format(date_formatted, time_formatted)\n\n with open(file_path, 'w') as f:\n f.write(header)\n \n os.system(EDITOR+\" \"+file_path)","def get_description():\n with open(\"README.rst\", \"rb\") as readme:\n long_description = readme.read().decode(\"utf-8\")\n return long_description","def updateFileInfo(self, data, pid):\n self.db.updateLinkInfo(data)\n self.evm.dispatchEvent(\"packageUpdated\", pid)","def read_readme(readme: str) -> Tuple[dict, list]:\n metadata = {\n \"name\": \"na\",\n \"provider\": \"na\",\n \"original name\": \"na\",\n \"original filename\": \"na\",\n \"assembly_accession\": \"na\",\n \"tax_id\": \"na\",\n \"mask\": \"na\",\n \"genome url\": \"na\",\n \"annotation url\": \"na\",\n \"sanitized annotation\": \"na\",\n \"genomepy version\": \"na\",\n \"date\": \"na\",\n }\n lines = []\n\n if not os.path.exists(readme):\n return metadata, lines\n\n # if the readme exists, overwrite all metadata fields found\n with open(readme) as f:\n for line in f.readlines():\n if \": \" in line:\n vals = line.strip().split(\": \")\n metadata[vals[0].strip()] = (\": \".join(vals[1:])).strip()\n else:\n line = line.strip(\"\\n\").strip(\" \")\n # blank lines are allowed, but only one in a row\n if not (\n line == \"\"\n and len(lines) > 0\n and lines[len(lines) - 1].strip() == \"\"\n ):\n lines.append(line)\n\n return metadata, lines","def update(self, text: str) -> None:\n raise NotImplementedError","def render_readme(self):\r\n return self.manifest.get(\"render_readme\", False)","def update_rst(site_name, doc_name, contents, directory=''):\n if not doc_name:\n raise AttributeError('no_name')\n if not contents:\n raise AttributeError('no_contents')\n if not directory:\n directory = '/'\n doc_name = pathlib.Path(doc_name).stem\n\n siteid = _get_site_id(site_name)\n if siteid is None:\n raise FileNotFoundError('no_site')\n dirid = _get_dir_id(siteid, directory)\n if dirid is None:\n raise FileNotFoundError('no_subdir')\n doc_id, rst_id, _ = _get_doc_ids(dirid, doc_name)\n if doc_id is None:\n raise FileNotFoundError(\"no_document\")\n\n oldtext = _get_doc_text(rst_id)\n ## if contents == oldtext:\n ## return 'text has not changed'\n\n querystring = 'update {} set previous = %s, currtext = %s where id = %s;'.format(TABLES[4])\n result = execute_query(querystring, (oldtext, contents, rst_id))\n dts = datetime.datetime.utcnow()\n querystring = 'update {} set source_updated = %s where id = %s;'.format( TABLES[3])\n result = execute_query(querystring, (dts, doc_id))","def find_long_description():\n return read_file('../README.md')","def hotkeys_readme():\n\n root = '/'.join(__file__.split('/')[:-4])\n fname = root + '/README.rst'\n with codecs.open(fname, 'r', 'utf-8') as f:\n rst = f.read()\n hotkeys = rst.split('.. hotkeys')[1]\n return docutils.examples.html_body(hotkeys)","def statusupdate(filepath):\n pass","def update_item_md(dataobj_id, new_content):\n\n from archivy.models import DataObj\n\n filename = get_by_id(dataobj_id)\n dataobj = frontmatter.load(filename)\n dataobj[\"modified_at\"] = datetime.now().strftime(\"%x %H:%M\")\n dataobj.content = new_content\n md = frontmatter.dumps(dataobj)\n with open(filename, \"w\", encoding=\"utf-8\") as f:\n f.write(md)\n\n converted_dataobj = DataObj.from_md(md)\n converted_dataobj.fullpath = str(\n filename.relative_to(current_app.config[\"USER_DIR\"])\n )\n converted_dataobj.index()\n current_app.config[\"HOOKS\"].on_edit(converted_dataobj)","def note(self):\n content = sys.argv[2]\n self.record('NOTE %s' % content)\n print('Note added')","def write_message(f, readme_txt, outdir):\n name = f.split(\".gz\")[0].split('/')[-1]\n rf = open(outdir + \"/\" + str(name) + \"_README.txt\", \"a\")\n to_write = \" \" + str(readme_txt.pandascheck) + \" \" + str(readme_txt.samplesize) + \" \" + str(readme_txt.namecol)\n rf.write(str(f) + to_write + \"\\n\")\n rf.close()\n\n # Remove file if there is FAILED in error message\n if 'FAILED' in to_write:\n name = f.split(\".gz\")[0].split('/')[-1]\n if os.path.exists(outdir + \"/\" + name + \"_cols_edit.gz\"):\n os.remove(outdir + \"/\" + name + \"_cols_edit.gz\")","def readme_tests(readme=None):\n if readme is None:\n readme = Path('..', 'readme.md')\n with open(readme) as target:\n for line in target:\n if line.startswith(' ') and 'test_utils' not in line:\n print()\n print(line)\n input('Press Enter to execute')\n sb.run(line, shell=True, check=True)","def get_help(self, filename):\n f = open(filename, 'r')\n helptext = f.read()\n f.close()\n self.instruct.insert('1.0', helptext)","def get_long_description():\n with open(\"README.md\", \"r\") as fh:\n return fh.read()","def test_readme_commands(self, client):\n with open(REPO_ROOT / \"README.md\") as f:\n readme = f.read()\n\n documented = set(re.findall(\"^- `!([a-z]+)`: .*$\", readme, re.MULTILINE))\n implemented = set(client.commands)\n\n assert documented == implemented","def update_file(filename, sentinel, text):\n content = None\n with codecs.open(filename, 'r', encoding='utf-8') as handle:\n content = handle.read()\n\n replacement = u\"{0}\\n\\n{1}\".format(sentinel, text)\n content = content.replace(sentinel, replacement, 1)\n with codecs.open(filename, 'w', encoding='utf-8') as handle:\n handle.write(content)\n return","def update_info_when_add(descriptor, rel_path_from_repository,\n mtime, file_sha1_hash, index_dict):\n # If the file is already tracked, update it\n if rel_path_from_repository in index_dict.keys():\n # If the file is already up to date, no need to rewrite.\n if (mtime == index_dict[rel_path_from_repository][0]\n and\n file_sha1_hash == index_dict[rel_path_from_repository][2]):\n return\n # Move the file descriptor to the correct position\n lseek(descriptor, index_dict[rel_path_from_repository][5], 0)\n # Update the timestamp. current sha1 hash, add sha1 hash\n update_file_index(descriptor, \" \".join([mtime,\n file_sha1_hash,\n file_sha1_hash]), 0)\n # Else add a new index line.\n else:\n lseek(descriptor, 0, 2)\n add_new_index(descriptor, mtime, file_sha1_hash,\n rel_path_from_repository)","def replace_files(struct: Structure, opts: ScaffoldOpts) -> ActionParams:\n # Define new files\n NO_OVERWRITE = no_overwrite()\n files: Structure = {\n \"README.md\": (template(\"readme\"), NO_OVERWRITE),\n \"AUTHORS.md\": (template(\"authors\"), NO_OVERWRITE),\n \"CHANGELOG.md\": (template(\"changelog\"), NO_OVERWRITE),\n \"CONTRIBUTING.md\": (template(\"contributing\"), NO_OVERWRITE),\n \"docs\": {\n \"index.md\": (template(\"index\"), NO_OVERWRITE),\n \"readme.md\": (default_myst_include(\"README.md\"), NO_OVERWRITE),\n \"license.md\": (template(\"license\"), NO_OVERWRITE),\n \"authors.md\": (default_myst_include(\"AUTHORS.md\"), NO_OVERWRITE),\n \"changelog.md\": (default_myst_include(\"CHANGELOG.md\"), NO_OVERWRITE),\n \"contributing.md\": (default_myst_include(\"CONTRIBUTING.md\"), NO_OVERWRITE),\n },\n }\n\n # TODO: Automatically convert RST to MD\n #\n # >>> content, file_op = reify_leaf(struct.get(\"CONTRIBUTING.rst\"), opts)\n # >>> md_content = rst_to_myst(content or \"\", **RST2MYST_OPTS).text\n # >>> files[\"CONTRIBUTING.md\"] = (md_content, file_op)\n #\n # Currently there is a problem in rst-to-myst, preventing automatic conversion:\n # https://github.com/executablebooks/rst-to-myst/issues/33#issuecomment-922264030\n\n # Modify pre-existing files\n content, file_op = reify_leaf(struct[\"setup.cfg\"], opts)\n files[\"setup.cfg\"] = (add_long_desc(content), file_op)\n\n content, file_op = reify_leaf(struct[\"docs\"][\"conf.py\"], opts)\n files[\"docs\"][\"conf.py\"] = (add_myst(content), file_op)\n\n # Remove all unnecessary .rst files from struct\n unnecessary = [\n \"README.rst\",\n \"AUTHORS.rst\",\n \"CHANGELOG.rst\",\n \"CONTRIBUTING.rst\",\n \"docs/index.rst\",\n \"docs/readme.rst\",\n \"docs/license.rst\",\n \"docs/authors.rst\",\n \"docs/changelog.rst\",\n \"docs/contributing.rst\",\n ]\n struct = reduce(reject, unnecessary, struct)\n\n return merge(struct, files), opts","def update_main_page():\n\n line = house_keeping + '/acis_gain.html'\n text = open(line, 'r').read()\n\n today = tcnv. currentTime('Display')\n\n text = text.replace('#DATE#', today)\n\n file = web_dir + '/acis_gain.html'\n fo = open(file, 'w')\n fo.write(text)\n fo.close()","def information(self, bot, update):\n update.message.reply_markdown(\"Nun werden einige Informationen zu Alfred angezeigt.\",\n reply_markup=self.option_markup)","def readme(self):\n if \"README.md\" not in self:\n ex_msg = \"This Package is missing a README file. A Quilt recognized README file is a file named \" \\\n \"'README.md' (case-insensitive)\"\n raise QuiltException(ex_msg)\n\n return self[\"README.md\"]","def test_readmeExamplesAreExecutable(self) -> None:\n temporary_code = extract_code_from_readme()\n globals_for_exec = {\"__name__\": \"README.md\"}\n\n try:\n exec(temporary_code, globals_for_exec)\n except Exception:\n print(\">>> Found error in generated readme code file\",\n file=sys.stderr)\n print(temporary_code, file=sys.stderr)\n raise","def update(self, note, nf_meta):\n path = self.config.get_config('cfg_nt_path')\n filename = nf_meta['filename']\n access_time = time.time()\n\n try:\n f = open(path + \"/\" + filename, 'w')\n f.write(note['content'])\n f.close()\n self.log.info(\"Writing %s\", filename)\n\n os.utime(path + \"/\" + filename, (access_time, float(note['modifydate'])))\n\n return True\n except:\n self.log.error(\"Error writing note: %s\", note['key'])\n self.log.debug(\"Exception: %s\", sys.exc_info()[1])\n\n return False","def update_html(site_name, doc_name, contents, directory='', dry_run=True):\n if not doc_name:\n raise AttributeError('no_name')\n if not contents:\n raise AttributeError('no_contents')\n if not directory:\n directory = '/'\n doc_name = pathlib.Path(doc_name).stem\n\n siteid = _get_site_id(site_name)\n if siteid is None:\n raise FileNotFoundError('no_site')\n dirid = _get_dir_id(siteid, directory)\n if dirid is None:\n raise FileNotFoundError('no_subdir')\n doc_id, _, html_id = _get_doc_ids(dirid, doc_name)\n if doc_id is None:\n raise FileNotFoundError(\"no_document\")\n if dry_run:\n return\n\n if html_id is None:\n new_html_id = _add_doc()\n oldtext = ''\n else:\n oldtext = _get_doc_text(html_id)\n ## if contents == oldtext:\n ## return 'text has not changed'\n\n dts = datetime.datetime.utcnow()\n if html_id is None:\n querystring = 'update {} set currtext = %s where id = %s;'\n result = execute_query(querystring.format(TABLES[4]), (contents, new_html_id))\n querystring = 'update {} set target_docid = %s, target_updated = %s where id = %s;'\n result = execute_query(querystring.format(TABLES[3]), (new_html_id, dts, doc_id))\n else:\n querystring = 'update {} set previous = %s, currtext = %s where id = %s;'\n result = execute_query(querystring.format(TABLES[4]), (oldtext, contents, html_id))\n querystring = 'update {} set target_updated = %s where id = %s;'\n result = execute_query(querystring.format(TABLES[3]), (dts, doc_id))","def convert(label, tags, categories, projects, view, featured):\n\n filename = f\"content/publication/{label}/index.md\"\n content = readfile(filename)\n if featured: \n content = content.replace(\"featured: false\", f'featured: true') \n if tags: \n content = content.replace(\"tags: []\", f'tags: [\"{tags}\"]') \n if categories: \n content = content.replace(\"categories: []\", f'categories: [\"{categories}\"]') \n if projects: \n content = content.replace(\"projects: []\", f'projects: [\"{projects}\"]')\n writefile(filename, content)\n if view:\n print(content)","def index():\n\n # open the README file\n with open(os.path.dirname(app.root_path) + '/README.md',\n 'r', encoding=\"utf-8\") as markdown_file:\n\n # Read the content of the file\n content = markdown_file.read()\n\n # convert to html\n return markdown.markdown(content)","def update_vim(user, title, vim_path):\n # Read lines from file\n with open(vim_path, \"r\") as f:\n lines = f.readlines()\n # Insert title into file\n lines.insert(-5, f\" \\\\ ['{title}', '', '@{user}'],\\n\")\n with open(vim_path, \"w\") as f:\n f.writelines(lines)","def edit_document():","def update_cmakelists(name):\n relative_path = create_relative_path(\"../CMakeLists.txt\")\n\n file_contents = []\n with open(relative_path, \"r\") as f:\n file_contents = f.readlines()\n\n file_new_contents = insert_line_alphabetically(\n name,\n \" single-source/\" + name + \"\\n\",\n file_contents,\n r\" single-source\\/([a-zA-Z]+)\",\n )\n with open(relative_path, \"w\") as f:\n for line in file_new_contents:\n f.write(line)","def update_from_repo():\n\treturn","def update(src, des, tipe):\n from xbooks.Xinit import Xrc\n src = \"Xblog/docs/\" + src\n des = \"Xblog/docs/\" + des\n if \"Xblog/docs/notebooks/\" == des.replace(os.path.basename(des), \"\"):\n editNavBar(src, des, tipe, Xrc)\n else:\n editParentIndex(src, des, tipe, Xrc)\n ccc.success(\"updatation procedures for \" + des)","def _get_bids_readme(self):\n readme = []\n # Grab all readme files, loop through\n for README_fname in [\n file for file in Path(self.dataset.path).glob(\"[Rr][Ee][Aa][Dd][Mm][Ee]*\")\n ]:\n # datalad get content if annexed\n self.dataset.get(README_fname)\n # read text from file\n try:\n file_text = ensure_unicode(README_fname.read_text()).strip()\n except:\n file_text = \"\"\n # Append dict with file text + extension to list\n readme.append({\"extension\": README_fname.suffix, \"text\": file_text})\n return readme if readme else None","def update(self, line):","def _main(args):\n if args.files:\n _update_files()\n\n if args.templates:\n _update_template(args.template_definition)","def update_file(this_file, new_lines):\r\n file_format = get_file_format(this_file)\r\n return new_write_file(this_file, new_lines, file_format=file_format)","def prepare_agent_readme(agent):\n readme_path = f'{os.path.join(parlai.agents.__path__[0], agent)}/README.md'\n if not os.path.exists(readme_path):\n raise RuntimeError(f'Agent {agent} must have README.md')\n with open(readme_path) as f:\n readme = f.readlines()\n\n if '# ' not in readme[0]:\n readme[0] = f'# {agent}'\n\n return ''.join(readme)"],"string":"[\n \"def update_readme():\\n\\n temp = \\\"\\\"\\\"<head>\\n <title>Unittest Results</title>\\n <meta charset=\\\"utf-8\\\">\\n <meta name=\\\"viewport\\\" content=\\\"width=device-width, initial-scale=1.0\\\">\\n <link rel=\\\"stylesheet\\\" href=\\\"https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css\\\" integrity=\\\"sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7\\\" crossorigin=\\\"anonymous\\\">\\n</head>\\\"\\\"\\\"\\n\\n with open(\\\"README_proxy.md\\\", \\\"r\\\") as old_readme_file:\\n old_readme_txt = old_readme_file.read()\\n\\n with open(\\\"reports/test_result.html\\\", \\\"r\\\") as html_file:\\n html = html_file.read().splitlines()[0:-21]\\n html = \\\"\\\\n\\\".join(html).replace(temp, \\\"\\\")\\n\\n with open(\\\"README.md\\\", \\\"w\\\") as new_readme_file:\\n new_readme_file.write(old_readme_txt + \\\"\\\\n\\\\n\\\\n\\\" + html + \\\"</body></html>\\\")\",\n \"def update_readme_data(readme_file, **readme_updates):\\n\\n extensions_key = \\\"base\\\"\\n extensions = readme_updates[\\\"extensions\\\"]\\n\\n if extensions:\\n extensions_key = \\\"-\\\".join(extensions)\\n\\n output_folder = readme_updates[\\\"outputsubfolder\\\"]\\n generation_data = {\\n \\\"location\\\": path_join_robust(output_folder, \\\"\\\"),\\n \\\"entries\\\": readme_updates[\\\"numberofrules\\\"],\\n \\\"sourcesdata\\\": readme_updates[\\\"sourcesdata\\\"],\\n }\\n\\n with open(readme_file, \\\"r\\\") as f:\\n readme_data = json.load(f)\\n readme_data[extensions_key] = generation_data\\n\\n for denomination, data in readme_data.copy().items():\\n if \\\"location\\\" in data and data[\\\"location\\\"] and \\\"\\\\\\\\\\\" in data[\\\"location\\\"]:\\n # Windows compatibility: #1166\\n readme_data[denomination][\\\"location\\\"] = data[\\\"location\\\"].replace(\\\"\\\\\\\\\\\", \\\"/\\\")\\n\\n with open(readme_file, \\\"w\\\") as f:\\n json.dump(readme_data, f)\",\n \"def readme_md(cls):\\n\\n template = Helpers.File(Settings.readme_me_template).read()\\n\\n template = Helpers.Regex(\\n template, r\\\"%%version%%\\\", replace_with=Settings.version\\n ).replace()\\n template = Helpers.Regex(\\n template, r\\\"%%lenHosts%%\\\", replace_with=format(len(Settings.domains), \\\",d\\\")\\n ).replace()\\n template = Helpers.Regex(\\n template, r\\\"%%lenIPs%%\\\", replace_with=format(len(Settings.ips), \\\",d\\\")\\n ).replace()\\n template = Helpers.Regex(\\n template,\\n r\\\"%%lenHostsIPs%%\\\",\\n replace_with=format(len(Settings.ips) + len(Settings.domains), \\\",d\\\"),\\n ).replace()\\n\\n print(\\\"Generation of %s\\\" % Settings.readme_md_file, end=\\\" \\\")\\n Helpers.File(Settings.readme_md_file).write(template, overwrite=True)\\n print(Settings.done)\",\n \"def fix_readme(self):\\n import re\\n\\n readme = os.path.join(os.path.dirname(__file__), \\\"README.md\\\")\\n with open(readme, \\\"r\\\") as f:\\n content = f.read()\\n\\n tag = self.get_tag()\\n if not tag:\\n raise AssertionError(\\n \\\"Could not get tag! (are you checking out with full tag history?)\\\"\\n )\\n\\n new_content = re.sub(\\n r\\\"\\\\(docs/\\\",\\n rf\\\"(https://github.com/robocorp/robotframework-lsp/tree/{tag}/robocorp-code/docs/\\\",\\n content,\\n )\\n\\n new_content = re.sub(\\n r\\\"\\\\(images/\\\",\\n rf\\\"(https://raw.githubusercontent.com/robocorp/robotframework-lsp/{tag}/robocorp-code/images/\\\",\\n content,\\n )\\n\\n new_content = new_content.replace(\\n \\\"Apache 2.0\\\",\\n \\\"[Robocorp License Agreement (pdf)](https://cdn.robocorp.com/legal/Robocorp-EULA-v1.0.pdf)\\\",\\n )\\n\\n assert \\\"apache\\\" not in new_content.lower()\\n with open(readme, \\\"w\\\") as f:\\n f.write(new_content)\",\n \"def churn(old_readme: str, /) -> str | None:\\n # getting content\\n if not (waka_stats := fetch_stats()):\\n logger.error('Unable to fetch data, please rerun workflow\\\\n')\\n sys.exit(1)\\n # processing content\\n try:\\n generated_content = prep_content(waka_stats)\\n except AttributeError as err:\\n logger.error(f'Unable to read API data | {err}\\\\n')\\n sys.exit(1)\\n print(generated_content, '\\\\n', sep='')\\n new_readme = re.sub(\\n pattern=wk_i.waka_block_pattern,\\n repl=f'{wk_i.start_comment}\\\\n\\\\n```text\\\\n{generated_content}\\\\n```\\\\n\\\\n{wk_i.end_comment}',\\n string=old_readme\\n )\\n if len(sys.argv) == 2 and sys.argv[1] == '--dev':\\n logger.debug('Detected run in `dev` mode.')\\n # to avoid accidentally writing back to Github\\n # when developing and testing WakaReadme\\n return None\\n\\n return None if new_readme == old_readme else new_readme\",\n \"def test_readme():\\n readme = Path(README_PATH).read_text()\\n Actions.read_from_md(readme)\",\n \"def start(self) -> \\\"UpdaterBase\\\":\\n\\n if self.administration.raw_link:\\n with importlib.resources.path(\\n \\\"ultimate_hosts_blacklist.test_launcher.data.docs\\\",\\n \\\"about_repository.md\\\",\\n ) as file_path:\\n content = FileHelper(str(file_path)).read()\\n else:\\n with importlib.resources.path(\\n \\\"ultimate_hosts_blacklist.test_launcher.data.docs\\\",\\n \\\"about_repository_self.md\\\",\\n ) as file_path:\\n content = FileHelper(str(file_path)).read()\\n\\n content += \\\"\\\\n\\\\n\\\"\\n\\n with importlib.resources.path(\\n \\\"ultimate_hosts_blacklist.test_launcher.data.docs\\\", \\\"about_ultimate.md\\\"\\n ) as file_path:\\n content += FileHelper(str(file_path)).read()\\n\\n content += \\\"\\\\n\\\\n\\\"\\n\\n with importlib.resources.path(\\n \\\"ultimate_hosts_blacklist.test_launcher.data.docs\\\", \\\"about_pyfunceble.md\\\"\\n ) as file_path:\\n content += FileHelper(str(file_path)).read()\\n\\n content += \\\"\\\\n\\\"\\n\\n readme_file = FileHelper(\\n os.path.join(outputs.CURRENT_DIRECTORY, outputs.README_FILENAME)\\n )\\n readme_file.write(content, overwrite=True)\\n\\n logging.info(\\\"Updated: %r\\\", readme_file.path)\",\n \"def _write_readme(variables):\\n with open(locations.readme_template) as source:\\n with open(locations.readme, \\\"w\\\") as destination:\\n contents = source.read()\\n contents = contents.format(**variables)\\n destination.write(contents)\",\n \"def update_md(user, title, md_path):\\n with open(md_path, \\\"a\\\") as f:\\n f.writelines(f\\\"[@{user}](https://github.com/{user}) | {title}\\\\n\\\")\",\n \"def readme():\\n with open('README.md') as readme_file:\\n return readme_file.read()\",\n \"def readme():\\n with open('README.rst') as f:\\n return f.read()\",\n \"def readme():\\n with open('README.md') as _file:\\n return _file.read()\",\n \"def make_readme_txt(self, args):\\n with open(self.readme_txt, 'w') as writer:\\n log.info(\\\"args=%s\\\\n\\\", args)\\n writer.write(\\\"# Created by pbtranscript-internal-validation.ValidationRunner.make_readme_txt()\\\\n\\\")\\n writer.write(\\\"args=%s\\\\n\\\\n\\\" % args)\\n\\n files = self.common_files + self.collapse_human_files + self.reseq_human_files + self.sirv_files\\n for desc, fn in files:\\n if op.exists(fn):\\n writer.write(\\\"%s=%s\\\\n\\\" % (desc, fn))\",\n \"def with_readme(request, new_package):\\n\\n new_module, pkg_root = new_package\\n pkg_name = os.path.basename(pkg_root)\\n\\n with open(os.path.join(new_module, \\\"README\\\"), \\\"w\\\") as openreadme:\\n openreadme.write(\\\"{n}\\\\n{d}\\\\n\\\\n{n}'s readme... with content!\\\".format(\\n n=pkg_name,\\n d=\\\"=\\\" * len(pkg_name),\\n ))\\n\\n with open(os.path.join(new_module, META_NAME), \\\"w\\\") as openmeta:\\n openmeta.write(\\n '{\\\"packages\\\": [\\\"find_packages()\\\"], \\\"long_description\\\": \\\"README\\\"}'\\n )\\n\\n request.addfinalizer(module_cleanup)\\n return new_module, pkg_root\",\n \"def readme():\\n\\n with open('README.rst') as readme_file:\\n return readme_file.read()\",\n \"def readme():\\n with open(os.path.join(build_root, 'README.rst')) as f:\\n return f.read()\",\n \"def create_readme(self) -> None:\\n # read the readme file and update the version and description\\n with open(CONFIG.template_path / \\\"README.md\\\", \\\"r\\\") as f:\\n TEMPLATE_README = f.read()\\n\\n # add a readme with the names of the stub-folders\\n\\n # read informations from firmware_stubs.json\\n firmware_stubs = {}\\n doc_stubs = {}\\n core_stubs = {}\\n try:\\n with open(self.package_path / \\\"firmware_stubs.json\\\", \\\"r\\\") as f:\\n firmware_stubs = json.load(f)\\n with open(self.package_path / \\\"doc_stubs.json\\\", \\\"r\\\") as f:\\n doc_stubs = json.load(f)\\n with open(self.package_path / \\\"modules.json\\\", \\\"r\\\") as f:\\n core_stubs = json.load(f)\\n except FileNotFoundError:\\n pass\\n\\n # Prettify this by merging with template text\\n with open(self.package_path / \\\"README.md\\\", \\\"w\\\") as f:\\n f.write(f\\\"# {self.package_name}\\\\n\\\\n\\\")\\n f.write(TEMPLATE_README)\\n f.write(f\\\"Included stubs:\\\\n\\\")\\n for name, folder in self.stub_sources:\\n f.write(f\\\"* {name} from `stubs/{Path(folder).as_posix()}`\\\\n\\\")\\n\\n f.write(f\\\"\\\\n\\\\n\\\")\\n f.write(f\\\"origin | Family | Port | Board | Version\\\\n\\\")\\n f.write(f\\\"-------|--------|------|-------|--------\\\\n\\\")\\n try:\\n f.write(\\n f\\\"Firmware | {firmware_stubs['firmware']['family']} | {firmware_stubs['firmware']['port']} | {firmware_stubs['firmware']['machine']} | {clean_version(firmware_stubs['firmware']['version'])} \\\\n\\\"\\n )\\n except Exception:\\n pass\\n try:\\n f.write(\\n f\\\"Documentation | {doc_stubs['firmware']['family']} | {doc_stubs['firmware']['port']} | - | {clean_version(doc_stubs['firmware']['version'])} \\\\n\\\"\\n )\\n except Exception:\\n pass\\n try:\\n f.write(\\n f\\\"Core | {core_stubs['firmware']['family']} | {core_stubs['firmware']['port']} | - | {clean_version(core_stubs['firmware']['version'])} \\\\n\\\"\\n )\\n except Exception:\\n pass\",\n \"def main(src_file=\\\"README.md\\\", dst_file=\\\"docs/documentation.json\\\"):\\n with open(src_file, \\\"r\\\") as readme:\\n markdown = readme.read()\\n\\n data = {\\n \\\"info\\\": {\\n \\\"termsOfService\\\": \\\"https://github.com/bombsimon/redoc-theme\\\",\\n \\\"description\\\": markdown,\\n \\\"license\\\": {\\n \\\"url\\\": \\\"https://opensource.org/licenses/MIT\\\",\\n \\\"name\\\": \\\"MIT\\\",\\n },\\n \\\"title\\\": \\\"ReDoc Theme\\\",\\n \\\"version\\\": \\\"1.0\\\",\\n \\\"contact\\\": {\\\"email\\\": \\\"simon@sawert.se\\\"},\\n \\\"x-logo\\\": {\\\"url\\\": \\\"assets/logo.png\\\"},\\n },\\n \\\"swagger\\\": \\\"2.0\\\",\\n }\\n\\n with open(dst_file, \\\"w\\\") as doc_json:\\n json.dump(data, doc_json, indent=2)\",\n \"def make_readme(digest):\\n o = 'SHA1 digest: %s\\\\n\\\\n'%digest[:10]\\n print '...build readme file for GitHub' \\n open('README.md','w').write(o + make_readme.__doc__)\",\n \"def readme(fname='README'):\\n with open(os.path.join(os.path.dirname(__file__), fname)) as file:\\n return file.read()\",\n \"def _readme_file(self, readme_path=None, proxies=None):\\n if proxies is None:\\n proxies = self._proxies\\n if readme_path is None:\\n readme_path = self._README_PATH\\n url = \\\"{}{}\\\".format(self._url, readme_path)\\n response = self._http.request(url=url, method=\\\"GET\\\", proxies=proxies)\\n if response is None:\\n return False\\n if \\\"Stable tag:\\\" not in response.text:\\n return False\\n version = response.text.split(\\\"Stable tag:\\\")[1].split(\\\"\\\\n\\\")[0] # get the version of the plugin\\n return self.is_vulnerable_version(version)\",\n \"def create_readme(case_dict):\\n # ---------------------------------------------------------------------\\n logger.debug(\\\"create_readme\\\")\\n os.chdir(case_dict[\\\"archive_temp_dir\\\"])\\n\\n fname = open(\\\"README.archive\\\", \\\"w\\\")\\n fname.write(\\\"Archived metadata is available for this case at URL:\\\\n\\\")\\n fname.write(case_dict[\\\"base_expdb_url\\\"])\\n fname.close()\",\n \"def OpenReadMe():\\n location = os.path.join(os.path.dirname(__file__), \\\"README.txt\\\")\\n os.startfile(location)\",\n \"def write_readme(readme: str, metadata: dict, lines: list = None):\\n with open(readme, \\\"w\\\") as f:\\n for k, v in metadata.items():\\n print(f\\\"{k}: {v}\\\", file=f)\\n if lines:\\n for line in lines:\\n print(line, file=f)\",\n \"def readme(self, ref=None):\\r\\n params = base.get_params(None, locals())\\r\\n url = '{0}/readme'.format(self.parent.get_url())\\r\\n\\r\\n return http.Request('GET', url, params), parsers.parse_json\",\n \"def readmegen(session, sample):\\n session.install('jinja2', 'pyyaml')\\n\\n if os.path.exists(os.path.join(sample, 'requirements.txt')):\\n session.install('-r', os.path.join(sample, 'requirements.txt'))\\n\\n in_file = os.path.join(sample, 'README.rst.in')\\n session.run('python', 'scripts/readme-gen/readme_gen.py', in_file)\",\n \"def _readme(datatype, fname, overwrite=False):\\n if os.path.isfile(fname) and not overwrite:\\n with open(fname, \\\"r\\\", encoding=\\\"utf-8-sig\\\") as fid:\\n orig_data = fid.read()\\n mne_bids_ref = REFERENCES[\\\"mne-bids\\\"] in orig_data\\n datatype_ref = REFERENCES[datatype] in orig_data\\n if mne_bids_ref and datatype_ref:\\n return\\n text = \\\"{}References\\\\n----------\\\\n{}{}\\\".format(\\n orig_data + \\\"\\\\n\\\\n\\\",\\n \\\"\\\" if mne_bids_ref else REFERENCES[\\\"mne-bids\\\"] + \\\"\\\\n\\\\n\\\",\\n \\\"\\\" if datatype_ref else REFERENCES[datatype] + \\\"\\\\n\\\",\\n )\\n else:\\n text = \\\"References\\\\n----------\\\\n{}{}\\\".format(\\n REFERENCES[\\\"mne-bids\\\"] + \\\"\\\\n\\\\n\\\", REFERENCES[datatype] + \\\"\\\\n\\\"\\n )\\n\\n _write_text(fname, text, overwrite=True)\",\n \"def OpenReadMe():\\n location = os.path.join(os.path.dirname(__file__), \\\"README.txt\\\")\\n os.startfile(location)\\n return\",\n \"def get_readme_text(self):\\n if self.readme_file:\\n readme_text = self.readme_file.read_text(encoding=\\\"utf-8\\\")\\n else:\\n readme_text = \\\"# foxBMS 2 GUI\\\"\\n return readme_text\",\n \"def update(self, namein, nameout):\\n\\t\\ttext = self.dict.sub(self.readFile(namein))\\n\\t\\tself.writeFile(nameout, text)\\n\\t\\treturn\",\n \"def edit(ctx, name, header):\\n\\n # create local copies of ctx vaiables for easy access\\n path = ctx.obj[\\\"path\\\"]\\n gitCommand = ctx.obj[\\\"gitCommand\\\"]\\n\\n if(not isdir(path)):\\n print(\\\"No notes directory found at \\\" + path)\\n return\\n\\n if(header != ''):\\n system('touch ' + path + '/' + name)\\n system('echo ' + header + \\\" > \\\" + path + '/' + name)\\n\\n system('$EDITOR ' + path + \\\"/\\\" + name)\\n system(gitCommand + \\\"add .\\\")\\n system(gitCommand + \\\"commit -m 'edited \\\" + name + \\\"'\\\")\",\n \"def edit_files(i_file):\\n a_file = open(i_file, \\\"r\\\")\\n content = a_file.readlines()\\n\\n content[3] = f\\\"years: {datetime.now().year}\\\\n\\\"\\n content[4] = f'lastupdated: \\\"{date.today()}\\\"\\\\n'\\n a_file = open(i_file, \\\"w\\\") #open the same file and overrite line3 & 4\\n a_file.writelines(content)\\n\\n a_file.close()\",\n \"def create_readme(histfile, vb):\\n\\tme = \\\"Utils.create_readme: \\\"\\n\\treadmefile = os.path.dirname(histfile)+\\\"/README.txt\\\"\\n\\ttry:\\n\\t\\tassert os.path.isfile(readmefile)\\n\\texcept AssertionError:\\n\\t\\tnow = str(datetime.now().strftime(\\\"%Y-%m-%d %H.%M\\\"))\\n\\t\\tcommit = subprocess.check_output(['git', 'rev-parse', 'HEAD'])\\n\\t\\theader = \\\"Time:\\\\t\\\"+now+\\\"\\\\nCommit hash:\\\\t\\\"+commit+\\\"\\\\n\\\\n\\\"\\n\\t\\twith open(readmefile,\\\"w\\\") as f:\\n\\t\\t\\tf.write(header)\\n\\t\\tif vb: print me+\\\"Created readme file \\\"+readmefile\\n\\treturn\",\n \"def get_fsleyes_readme():\\n with open(op.join(basedir, 'README.rst'), 'rt', encoding='utf-8') as f:\\n return f.read().strip()\",\n \"def process(dirty):\\n log('processing', dirty.name)\\n raw = db.one( 'SELECT readme_raw FROM packages '\\n 'WHERE package_manager=%s and name=%s and readme_needs_to_be_processed'\\n , (dirty.package_manager, dirty.name)\\n )\\n if raw is None:\\n return\\n processed = _render(raw)\\n db.run('''\\n\\n UPDATE packages\\n SET readme=%s\\n , readme_needs_to_be_processed=false\\n WHERE package_manager=%s\\n AND name=%s\\n\\n ''', ( processed\\n , dirty.package_manager\\n , dirty.name\\n ))\",\n \"def _create_readme(self, name, summary, description):\\n return \\\"\\\"\\\"\\n %(header_bar)s\\n %(header)s\\n %(header_bar)s\\n\\n %(content)s\\n \\\"\\\"\\\" % {\\n 'header': name,\\n 'header_bar': '=' * len(name),\\n 'content': '\\\\n\\\\n'.join(\\n content\\n for content in (summary, description)\\n if content\\n ) or 'Describe your extension.',\\n }\",\n \"def update_changelog_file(log_lines, version):\\n with open(\\n f\\\"docs/changelog/{version}.md\\\", \\\"w+\\\", encoding=\\\"utf-8\\\"\\n ) as change_log_file:\\n for line in log_lines:\\n LOG.info(line)\\n change_log_file.write(line + \\\"\\\\n\\\")\",\n \"def deploy(version):\\n toolkit.readmegen(version)\",\n \"def parse_readme():\\n # Get the long description from the relevant file\\n readme_path = path.join(here, 'README.md')\\n with codecs.open(readme_path, encoding='utf-8') as handle:\\n desc = handle.read()\\n\\n return desc\",\n \"async def info(self, ctx):\\r\\n openfile = open(\\\"info.txt\\\", \\\"r\\\")\\r\\n embed = discord.Embed(title='Aristobot', description='This is a bot made by Aristoza that uses the TrueSkill '\\r\\n 'python package (http://trueskill.org/) which is based on '\\r\\n 'the '\\r\\n 'TrueSkill rating system developed by Microsoft.',\\r\\n color=33023)\\r\\n embed.add_field(name='How it works', value=openfile.read(), inline=False)\\r\\n await ctx.send(embed=embed)\",\n \"def build_readme(comic: str, readme: str) -> str:\\n img = f\\\"{START_COMMENT}\\\\n{comic}\\\\n{END_COMMENT}\\\"\\n return re.sub(listReg, img, readme)\",\n \"def update_metadata(self):\\n self.data[\\\"keywords\\\"] = self.repo.topics(self.data.get(\\\"keywords\\\", []))\\n self.data[\\\"description\\\"] = self.data.get(\\\"description\\\") or self.repo.description\\n self.data[\\\"codeRepository\\\"] = (\\n self.data.get(\\\"codeRepository\\\") or self.repo.html_url\\n )\\n self.data[\\\"name\\\"] = self.data.get(\\\"name\\\") or self.repo.name\\n self.data[\\\"issueTracker\\\"] = (\\n self.data.get(\\\"issueTracker\\\") or self.repo.issues_url\\n )\\n self.data[\\\"license\\\"] = self.data.get(\\\"license\\\") or self.repo.license\",\n \"def read_readme(setup_file, name=\\\"README.rst\\\"):\\n import os\\n TOP_DIR = os.path.abspath(os.path.dirname(setup_file))\\n if not os.path.exists(TOP_DIR):\\n raise FileNotFoundError(\\n f\\\"Unable to find folder {TOP_DIR!r}.\\\")\\n readme = os.path.join(TOP_DIR, name)\\n if not os.path.exists(readme):\\n raise FileNotFoundError(\\n f\\\"Unable to find file {TOP_DIR!r}.\\\")\\n with open(readme, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n content = f.read()\\n return _clean_readme(content)\",\n \"def get_readme():\\n for name in ('README', 'README.rst', 'README.md'):\\n if os.path.exists(name):\\n return read_file(name)\\n return ''\",\n \"def test_readme_file_for_formatting():\\n f = open(\\\"README.md\\\", \\\"r\\\", encoding=\\\"utf-8\\\")\\n content = f.read()\\n f.close()\\n assert content.count(\\\"#\\\") >= 10, \\\"Readme is not formatted properly\\\"\",\n \"def _fingerprint_readme(self, domain_path, wp_unique_url, response):\\n wp_readme_url = domain_path.url_join('readme.html')\\n response = self._uri_opener.GET(wp_readme_url, cache=True)\\n\\n # Find the string in the response html\\n find = '<br /> Version (\\\\d\\\\.\\\\d\\\\.?\\\\d?)'\\n m = re.search(find, response.get_body())\\n\\n # If string found, group version\\n if m:\\n version = m.group(1)\\n\\n desc = 'WordPress version \\\"%s\\\" found in the readme.html file.'\\n desc = desc % version\\n\\n i = Info('Fingerprinted Wordpress version', desc, response.id,\\n self.get_name())\\n i.set_url(wp_readme_url)\\n \\n kb.kb.append(self, 'info', i)\\n om.out.information(i.get_desc())\",\n \"def view_help_info(self):\\n try:\\n with open('README.md', 'r') as f:\\n data = f.readlines()\\n log = Tk.Listbox(self, height=30, width=100)\\n for i, item in enumerate(data):\\n log.insert(i+1, data[i])\\n log.grid(row =0, column=0, sticky='ew')\\n yscroll = Tk.Scrollbar(command=log.yview,\\n orient=Tk.VERTICAL)\\n yscroll.grid(row=0, column=1, sticky='ns')\\n except Exception, ex:\\n logging.error(ex)\\n traceback.print_exc()\\n except Exception, ex:\\n logging.error(ex)\\n traceback.print_exc()\",\n \"def update(self):\\n self.content = self.get_content()\\n self.dependencies = self.content['requirements']['run']\\n self.pythonversion = self.content['extra']['pythonversion']\\n self.package_name = self.content['package']['name']\",\n \"def metadata_update(self, _):\\n self.details.original_widget = YesNoWidget('Update metadata files?', self.__metadata_update)\",\n \"def get_readme():\\n for name in ('README', 'README.txt', 'README.rst', 'README.md'):\\n if os.path.exists(name):\\n return read_file(name)\\n return ''\",\n \"def make_doc(description=False, sentinel=COMMENT):\\n for readme_path in [os.path.abspath(x) for x in glob(\\\"*/README.md\\\")]:\\n with open(readme_path, \\\"r+\\\") as readme_file:\\n readme = readme_file.read()\\n if sentinel in readme:\\n root = os.path.dirname(readme_path)\\n tree = make_tree_doc(root)\\n pattern = r\\\"{}.*?\\\\n(\\\\w+)?\\\\n\\\".format(sentinel)\\n text = re.sub(pattern, format_tree(tree), readme, flags=re.DOTALL)\\n readme_file.seek(0)\\n readme_file.truncate()\\n readme_file.write(text)\",\n \"def test_readme_contents():\\n readme = open(\\\"README.md\\\", \\\"r\\\", encoding=\\\"utf-8\\\")\\n readme_words = readme.read().split()\\n readme.close()\\n assert len(readme_words) >= 500, \\\"Make your README.md file interesting! Add atleast 500 words\\\"\",\n \"def __call__(self, read, info: ModificationInfo):\",\n \"def _create_releaseinfo_file(projname, relinfo_str):\\n dirs = projname.split('.')\\n os.chdir(os.path.join(*dirs))\\n print 'updating releaseinfo.py for %s' % projname\\n with open('releaseinfo.py', 'w') as f:\\n f.write(relinfo_str)\",\n \"def Update(cli):\\n help_text = HelpIndexGenerator(cli).Walk(hidden=False)\\n def SerializeCommand(command):\\n return resource_projector.Compile().Evaluate(command)\\n\\n help_text = SerializeCommand(help_text)\\n\\n # Overwrite the help search table file with updated content\\n table_path = IndexPath()\\n with open(table_path, 'w') as index_file:\\n json.dump(help_text, index_file, sort_keys=True)\\n index_file.write('\\\\n')\\n log.warn('updated help index at {0}'.format(table_path))\",\n \"def help_update(self):\\n print(UPDATE)\",\n \"def test_changeVersionInFile(self):\\n # The version numbers are arbitrary, the name is only kind of\\n # arbitrary.\\n packageName = 'foo'\\n oldVersion = Version(packageName, 2, 5, 0)\\n file = self.makeFile('README',\\n \\\"Hello and welcome to %s.\\\" % oldVersion.base())\\n\\n newVersion = Version(packageName, 7, 6, 0)\\n _changeVersionInFile(oldVersion, newVersion, file.path)\\n\\n self.assertEqual(file.getContent(),\\n \\\"Hello and welcome to %s.\\\" % newVersion.base())\",\n \"def longdescription():\\r\\n print()\\r\\n here = path.abspath(path.dirname(__file__))\\r\\n with open(path.join(here, 'README.rst')) as f:\\r\\n long_description = f.read()\\r\\n\\r\\n print(long_description)\",\n \"def cmd_update(self, text):\\n self.update(text)\",\n \"def test_readme_proper_description():\\n READMELOOKSGOOD = True\\n f = open(\\\"README.md\\\", \\\"r\\\", encoding=\\\"utf-8\\\")\\n content = f.read()\\n f.close()\\n for c in README_CONTENT_CHECK_FOR:\\n if c not in content:\\n print(c)\\n READMELOOKSGOOD = False\\n break\\n\\n assert READMELOOKSGOOD is True, \\\"You have not described all the functions/class well in your README.md file\\\"\",\n \"def test_session10_readme_proper_description():\\n READMELOOKSGOOD = True\\n f = open(\\\"README.md\\\", \\\"r\\\", encoding=\\\"utf-8\\\")\\n content = f.read()\\n f.close()\\n for c in README_CONTENT_CHECK_FOR:\\n if c not in content:\\n print(c)\\n READMELOOKSGOOD = False\\n pass\\n assert READMELOOKSGOOD == True, \\\"You have not described all the functions/class well in your README.md file\\\"\",\n \"def add_title_author_info(filepath, title, author):\\n with open(filepath, 'r') as f:\\n # create a temporary file with the modified content before it replaces the original file\\n temp_dir = tempfile.mkdtemp()\\n try:\\n temp_filepath = os.path.join(temp_dir, 'temp.p8')\\n with open(temp_filepath, 'w') as temp_f:\\n # flag meta data version replacement to avoid replacing an actual code line\\n # starting with \\\"version \\\" later\\n has_replaced_version = False\\n for line in f:\\n if not has_replaced_version and line.startswith('version '):\\n temp_f.write('version 27\\\\n')\\n has_replaced_version = True\\n continue\\n temp_f.write(line)\\n if line.strip() == '__lua__':\\n # lua block detected, add title and author after the tag line, if any was passed\\n # if none was passed, we still call this method just so the version header gets update above\\n if title:\\n temp_f.write(f'-- {title}\\\\n')\\n if author:\\n temp_f.write(f'-- by {author}\\\\n')\\n shutil.copy(temp_filepath, filepath)\\n finally:\\n shutil.rmtree(temp_dir)\",\n \"def main():\\n # Get the date and time in a formatted string.\\n today = datetime.datetime.today()\\n date_formatted = today.strftime(\\\"%Y-%m-%d\\\")\\n time_formatted = today.strftime(\\\"%H:%M:%S\\\")\\n\\n # Form the file name and path.\\n file_name = date_formatted+\\\"-post.md\\\"\\n file_path = os.path.join(POSTS_DIR, file_name)\\n\\n # Make the new header.\\n header = HEADER_TEMPLATE.format(date_formatted, time_formatted)\\n\\n with open(file_path, 'w') as f:\\n f.write(header)\\n \\n os.system(EDITOR+\\\" \\\"+file_path)\",\n \"def get_description():\\n with open(\\\"README.rst\\\", \\\"rb\\\") as readme:\\n long_description = readme.read().decode(\\\"utf-8\\\")\\n return long_description\",\n \"def updateFileInfo(self, data, pid):\\n self.db.updateLinkInfo(data)\\n self.evm.dispatchEvent(\\\"packageUpdated\\\", pid)\",\n \"def read_readme(readme: str) -> Tuple[dict, list]:\\n metadata = {\\n \\\"name\\\": \\\"na\\\",\\n \\\"provider\\\": \\\"na\\\",\\n \\\"original name\\\": \\\"na\\\",\\n \\\"original filename\\\": \\\"na\\\",\\n \\\"assembly_accession\\\": \\\"na\\\",\\n \\\"tax_id\\\": \\\"na\\\",\\n \\\"mask\\\": \\\"na\\\",\\n \\\"genome url\\\": \\\"na\\\",\\n \\\"annotation url\\\": \\\"na\\\",\\n \\\"sanitized annotation\\\": \\\"na\\\",\\n \\\"genomepy version\\\": \\\"na\\\",\\n \\\"date\\\": \\\"na\\\",\\n }\\n lines = []\\n\\n if not os.path.exists(readme):\\n return metadata, lines\\n\\n # if the readme exists, overwrite all metadata fields found\\n with open(readme) as f:\\n for line in f.readlines():\\n if \\\": \\\" in line:\\n vals = line.strip().split(\\\": \\\")\\n metadata[vals[0].strip()] = (\\\": \\\".join(vals[1:])).strip()\\n else:\\n line = line.strip(\\\"\\\\n\\\").strip(\\\" \\\")\\n # blank lines are allowed, but only one in a row\\n if not (\\n line == \\\"\\\"\\n and len(lines) > 0\\n and lines[len(lines) - 1].strip() == \\\"\\\"\\n ):\\n lines.append(line)\\n\\n return metadata, lines\",\n \"def update(self, text: str) -> None:\\n raise NotImplementedError\",\n \"def render_readme(self):\\r\\n return self.manifest.get(\\\"render_readme\\\", False)\",\n \"def update_rst(site_name, doc_name, contents, directory=''):\\n if not doc_name:\\n raise AttributeError('no_name')\\n if not contents:\\n raise AttributeError('no_contents')\\n if not directory:\\n directory = '/'\\n doc_name = pathlib.Path(doc_name).stem\\n\\n siteid = _get_site_id(site_name)\\n if siteid is None:\\n raise FileNotFoundError('no_site')\\n dirid = _get_dir_id(siteid, directory)\\n if dirid is None:\\n raise FileNotFoundError('no_subdir')\\n doc_id, rst_id, _ = _get_doc_ids(dirid, doc_name)\\n if doc_id is None:\\n raise FileNotFoundError(\\\"no_document\\\")\\n\\n oldtext = _get_doc_text(rst_id)\\n ## if contents == oldtext:\\n ## return 'text has not changed'\\n\\n querystring = 'update {} set previous = %s, currtext = %s where id = %s;'.format(TABLES[4])\\n result = execute_query(querystring, (oldtext, contents, rst_id))\\n dts = datetime.datetime.utcnow()\\n querystring = 'update {} set source_updated = %s where id = %s;'.format( TABLES[3])\\n result = execute_query(querystring, (dts, doc_id))\",\n \"def find_long_description():\\n return read_file('../README.md')\",\n \"def hotkeys_readme():\\n\\n root = '/'.join(__file__.split('/')[:-4])\\n fname = root + '/README.rst'\\n with codecs.open(fname, 'r', 'utf-8') as f:\\n rst = f.read()\\n hotkeys = rst.split('.. hotkeys')[1]\\n return docutils.examples.html_body(hotkeys)\",\n \"def statusupdate(filepath):\\n pass\",\n \"def update_item_md(dataobj_id, new_content):\\n\\n from archivy.models import DataObj\\n\\n filename = get_by_id(dataobj_id)\\n dataobj = frontmatter.load(filename)\\n dataobj[\\\"modified_at\\\"] = datetime.now().strftime(\\\"%x %H:%M\\\")\\n dataobj.content = new_content\\n md = frontmatter.dumps(dataobj)\\n with open(filename, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n f.write(md)\\n\\n converted_dataobj = DataObj.from_md(md)\\n converted_dataobj.fullpath = str(\\n filename.relative_to(current_app.config[\\\"USER_DIR\\\"])\\n )\\n converted_dataobj.index()\\n current_app.config[\\\"HOOKS\\\"].on_edit(converted_dataobj)\",\n \"def note(self):\\n content = sys.argv[2]\\n self.record('NOTE %s' % content)\\n print('Note added')\",\n \"def write_message(f, readme_txt, outdir):\\n name = f.split(\\\".gz\\\")[0].split('/')[-1]\\n rf = open(outdir + \\\"/\\\" + str(name) + \\\"_README.txt\\\", \\\"a\\\")\\n to_write = \\\" \\\" + str(readme_txt.pandascheck) + \\\" \\\" + str(readme_txt.samplesize) + \\\" \\\" + str(readme_txt.namecol)\\n rf.write(str(f) + to_write + \\\"\\\\n\\\")\\n rf.close()\\n\\n # Remove file if there is FAILED in error message\\n if 'FAILED' in to_write:\\n name = f.split(\\\".gz\\\")[0].split('/')[-1]\\n if os.path.exists(outdir + \\\"/\\\" + name + \\\"_cols_edit.gz\\\"):\\n os.remove(outdir + \\\"/\\\" + name + \\\"_cols_edit.gz\\\")\",\n \"def readme_tests(readme=None):\\n if readme is None:\\n readme = Path('..', 'readme.md')\\n with open(readme) as target:\\n for line in target:\\n if line.startswith(' ') and 'test_utils' not in line:\\n print()\\n print(line)\\n input('Press Enter to execute')\\n sb.run(line, shell=True, check=True)\",\n \"def get_help(self, filename):\\n f = open(filename, 'r')\\n helptext = f.read()\\n f.close()\\n self.instruct.insert('1.0', helptext)\",\n \"def get_long_description():\\n with open(\\\"README.md\\\", \\\"r\\\") as fh:\\n return fh.read()\",\n \"def test_readme_commands(self, client):\\n with open(REPO_ROOT / \\\"README.md\\\") as f:\\n readme = f.read()\\n\\n documented = set(re.findall(\\\"^- `!([a-z]+)`: .*$\\\", readme, re.MULTILINE))\\n implemented = set(client.commands)\\n\\n assert documented == implemented\",\n \"def update_file(filename, sentinel, text):\\n content = None\\n with codecs.open(filename, 'r', encoding='utf-8') as handle:\\n content = handle.read()\\n\\n replacement = u\\\"{0}\\\\n\\\\n{1}\\\".format(sentinel, text)\\n content = content.replace(sentinel, replacement, 1)\\n with codecs.open(filename, 'w', encoding='utf-8') as handle:\\n handle.write(content)\\n return\",\n \"def update_info_when_add(descriptor, rel_path_from_repository,\\n mtime, file_sha1_hash, index_dict):\\n # If the file is already tracked, update it\\n if rel_path_from_repository in index_dict.keys():\\n # If the file is already up to date, no need to rewrite.\\n if (mtime == index_dict[rel_path_from_repository][0]\\n and\\n file_sha1_hash == index_dict[rel_path_from_repository][2]):\\n return\\n # Move the file descriptor to the correct position\\n lseek(descriptor, index_dict[rel_path_from_repository][5], 0)\\n # Update the timestamp. current sha1 hash, add sha1 hash\\n update_file_index(descriptor, \\\" \\\".join([mtime,\\n file_sha1_hash,\\n file_sha1_hash]), 0)\\n # Else add a new index line.\\n else:\\n lseek(descriptor, 0, 2)\\n add_new_index(descriptor, mtime, file_sha1_hash,\\n rel_path_from_repository)\",\n \"def replace_files(struct: Structure, opts: ScaffoldOpts) -> ActionParams:\\n # Define new files\\n NO_OVERWRITE = no_overwrite()\\n files: Structure = {\\n \\\"README.md\\\": (template(\\\"readme\\\"), NO_OVERWRITE),\\n \\\"AUTHORS.md\\\": (template(\\\"authors\\\"), NO_OVERWRITE),\\n \\\"CHANGELOG.md\\\": (template(\\\"changelog\\\"), NO_OVERWRITE),\\n \\\"CONTRIBUTING.md\\\": (template(\\\"contributing\\\"), NO_OVERWRITE),\\n \\\"docs\\\": {\\n \\\"index.md\\\": (template(\\\"index\\\"), NO_OVERWRITE),\\n \\\"readme.md\\\": (default_myst_include(\\\"README.md\\\"), NO_OVERWRITE),\\n \\\"license.md\\\": (template(\\\"license\\\"), NO_OVERWRITE),\\n \\\"authors.md\\\": (default_myst_include(\\\"AUTHORS.md\\\"), NO_OVERWRITE),\\n \\\"changelog.md\\\": (default_myst_include(\\\"CHANGELOG.md\\\"), NO_OVERWRITE),\\n \\\"contributing.md\\\": (default_myst_include(\\\"CONTRIBUTING.md\\\"), NO_OVERWRITE),\\n },\\n }\\n\\n # TODO: Automatically convert RST to MD\\n #\\n # >>> content, file_op = reify_leaf(struct.get(\\\"CONTRIBUTING.rst\\\"), opts)\\n # >>> md_content = rst_to_myst(content or \\\"\\\", **RST2MYST_OPTS).text\\n # >>> files[\\\"CONTRIBUTING.md\\\"] = (md_content, file_op)\\n #\\n # Currently there is a problem in rst-to-myst, preventing automatic conversion:\\n # https://github.com/executablebooks/rst-to-myst/issues/33#issuecomment-922264030\\n\\n # Modify pre-existing files\\n content, file_op = reify_leaf(struct[\\\"setup.cfg\\\"], opts)\\n files[\\\"setup.cfg\\\"] = (add_long_desc(content), file_op)\\n\\n content, file_op = reify_leaf(struct[\\\"docs\\\"][\\\"conf.py\\\"], opts)\\n files[\\\"docs\\\"][\\\"conf.py\\\"] = (add_myst(content), file_op)\\n\\n # Remove all unnecessary .rst files from struct\\n unnecessary = [\\n \\\"README.rst\\\",\\n \\\"AUTHORS.rst\\\",\\n \\\"CHANGELOG.rst\\\",\\n \\\"CONTRIBUTING.rst\\\",\\n \\\"docs/index.rst\\\",\\n \\\"docs/readme.rst\\\",\\n \\\"docs/license.rst\\\",\\n \\\"docs/authors.rst\\\",\\n \\\"docs/changelog.rst\\\",\\n \\\"docs/contributing.rst\\\",\\n ]\\n struct = reduce(reject, unnecessary, struct)\\n\\n return merge(struct, files), opts\",\n \"def update_main_page():\\n\\n line = house_keeping + '/acis_gain.html'\\n text = open(line, 'r').read()\\n\\n today = tcnv. currentTime('Display')\\n\\n text = text.replace('#DATE#', today)\\n\\n file = web_dir + '/acis_gain.html'\\n fo = open(file, 'w')\\n fo.write(text)\\n fo.close()\",\n \"def information(self, bot, update):\\n update.message.reply_markdown(\\\"Nun werden einige Informationen zu Alfred angezeigt.\\\",\\n reply_markup=self.option_markup)\",\n \"def readme(self):\\n if \\\"README.md\\\" not in self:\\n ex_msg = \\\"This Package is missing a README file. A Quilt recognized README file is a file named \\\" \\\\\\n \\\"'README.md' (case-insensitive)\\\"\\n raise QuiltException(ex_msg)\\n\\n return self[\\\"README.md\\\"]\",\n \"def test_readmeExamplesAreExecutable(self) -> None:\\n temporary_code = extract_code_from_readme()\\n globals_for_exec = {\\\"__name__\\\": \\\"README.md\\\"}\\n\\n try:\\n exec(temporary_code, globals_for_exec)\\n except Exception:\\n print(\\\">>> Found error in generated readme code file\\\",\\n file=sys.stderr)\\n print(temporary_code, file=sys.stderr)\\n raise\",\n \"def update(self, note, nf_meta):\\n path = self.config.get_config('cfg_nt_path')\\n filename = nf_meta['filename']\\n access_time = time.time()\\n\\n try:\\n f = open(path + \\\"/\\\" + filename, 'w')\\n f.write(note['content'])\\n f.close()\\n self.log.info(\\\"Writing %s\\\", filename)\\n\\n os.utime(path + \\\"/\\\" + filename, (access_time, float(note['modifydate'])))\\n\\n return True\\n except:\\n self.log.error(\\\"Error writing note: %s\\\", note['key'])\\n self.log.debug(\\\"Exception: %s\\\", sys.exc_info()[1])\\n\\n return False\",\n \"def update_html(site_name, doc_name, contents, directory='', dry_run=True):\\n if not doc_name:\\n raise AttributeError('no_name')\\n if not contents:\\n raise AttributeError('no_contents')\\n if not directory:\\n directory = '/'\\n doc_name = pathlib.Path(doc_name).stem\\n\\n siteid = _get_site_id(site_name)\\n if siteid is None:\\n raise FileNotFoundError('no_site')\\n dirid = _get_dir_id(siteid, directory)\\n if dirid is None:\\n raise FileNotFoundError('no_subdir')\\n doc_id, _, html_id = _get_doc_ids(dirid, doc_name)\\n if doc_id is None:\\n raise FileNotFoundError(\\\"no_document\\\")\\n if dry_run:\\n return\\n\\n if html_id is None:\\n new_html_id = _add_doc()\\n oldtext = ''\\n else:\\n oldtext = _get_doc_text(html_id)\\n ## if contents == oldtext:\\n ## return 'text has not changed'\\n\\n dts = datetime.datetime.utcnow()\\n if html_id is None:\\n querystring = 'update {} set currtext = %s where id = %s;'\\n result = execute_query(querystring.format(TABLES[4]), (contents, new_html_id))\\n querystring = 'update {} set target_docid = %s, target_updated = %s where id = %s;'\\n result = execute_query(querystring.format(TABLES[3]), (new_html_id, dts, doc_id))\\n else:\\n querystring = 'update {} set previous = %s, currtext = %s where id = %s;'\\n result = execute_query(querystring.format(TABLES[4]), (oldtext, contents, html_id))\\n querystring = 'update {} set target_updated = %s where id = %s;'\\n result = execute_query(querystring.format(TABLES[3]), (dts, doc_id))\",\n \"def convert(label, tags, categories, projects, view, featured):\\n\\n filename = f\\\"content/publication/{label}/index.md\\\"\\n content = readfile(filename)\\n if featured: \\n content = content.replace(\\\"featured: false\\\", f'featured: true') \\n if tags: \\n content = content.replace(\\\"tags: []\\\", f'tags: [\\\"{tags}\\\"]') \\n if categories: \\n content = content.replace(\\\"categories: []\\\", f'categories: [\\\"{categories}\\\"]') \\n if projects: \\n content = content.replace(\\\"projects: []\\\", f'projects: [\\\"{projects}\\\"]')\\n writefile(filename, content)\\n if view:\\n print(content)\",\n \"def index():\\n\\n # open the README file\\n with open(os.path.dirname(app.root_path) + '/README.md',\\n 'r', encoding=\\\"utf-8\\\") as markdown_file:\\n\\n # Read the content of the file\\n content = markdown_file.read()\\n\\n # convert to html\\n return markdown.markdown(content)\",\n \"def update_vim(user, title, vim_path):\\n # Read lines from file\\n with open(vim_path, \\\"r\\\") as f:\\n lines = f.readlines()\\n # Insert title into file\\n lines.insert(-5, f\\\" \\\\\\\\ ['{title}', '', '@{user}'],\\\\n\\\")\\n with open(vim_path, \\\"w\\\") as f:\\n f.writelines(lines)\",\n \"def edit_document():\",\n \"def update_cmakelists(name):\\n relative_path = create_relative_path(\\\"../CMakeLists.txt\\\")\\n\\n file_contents = []\\n with open(relative_path, \\\"r\\\") as f:\\n file_contents = f.readlines()\\n\\n file_new_contents = insert_line_alphabetically(\\n name,\\n \\\" single-source/\\\" + name + \\\"\\\\n\\\",\\n file_contents,\\n r\\\" single-source\\\\/([a-zA-Z]+)\\\",\\n )\\n with open(relative_path, \\\"w\\\") as f:\\n for line in file_new_contents:\\n f.write(line)\",\n \"def update_from_repo():\\n\\treturn\",\n \"def update(src, des, tipe):\\n from xbooks.Xinit import Xrc\\n src = \\\"Xblog/docs/\\\" + src\\n des = \\\"Xblog/docs/\\\" + des\\n if \\\"Xblog/docs/notebooks/\\\" == des.replace(os.path.basename(des), \\\"\\\"):\\n editNavBar(src, des, tipe, Xrc)\\n else:\\n editParentIndex(src, des, tipe, Xrc)\\n ccc.success(\\\"updatation procedures for \\\" + des)\",\n \"def _get_bids_readme(self):\\n readme = []\\n # Grab all readme files, loop through\\n for README_fname in [\\n file for file in Path(self.dataset.path).glob(\\\"[Rr][Ee][Aa][Dd][Mm][Ee]*\\\")\\n ]:\\n # datalad get content if annexed\\n self.dataset.get(README_fname)\\n # read text from file\\n try:\\n file_text = ensure_unicode(README_fname.read_text()).strip()\\n except:\\n file_text = \\\"\\\"\\n # Append dict with file text + extension to list\\n readme.append({\\\"extension\\\": README_fname.suffix, \\\"text\\\": file_text})\\n return readme if readme else None\",\n \"def update(self, line):\",\n \"def _main(args):\\n if args.files:\\n _update_files()\\n\\n if args.templates:\\n _update_template(args.template_definition)\",\n \"def update_file(this_file, new_lines):\\r\\n file_format = get_file_format(this_file)\\r\\n return new_write_file(this_file, new_lines, file_format=file_format)\",\n \"def prepare_agent_readme(agent):\\n readme_path = f'{os.path.join(parlai.agents.__path__[0], agent)}/README.md'\\n if not os.path.exists(readme_path):\\n raise RuntimeError(f'Agent {agent} must have README.md')\\n with open(readme_path) as f:\\n readme = f.readlines()\\n\\n if '# ' not in readme[0]:\\n readme[0] = f'# {agent}'\\n\\n return ''.join(readme)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7689971","0.722182","0.70508206","0.6771436","0.6603375","0.65443844","0.6535205","0.6525045","0.6332471","0.6293604","0.62730294","0.6270745","0.6242984","0.6230076","0.6186949","0.6171401","0.61592084","0.61382926","0.60904527","0.6066599","0.6053936","0.6024809","0.599621","0.5991829","0.5973389","0.5916031","0.5911982","0.5894305","0.583867","0.58327216","0.58101594","0.57992506","0.5796422","0.57921994","0.57800484","0.5778197","0.5712965","0.5681609","0.5642277","0.5618538","0.5607689","0.5598206","0.557698","0.557049","0.555963","0.55436665","0.5536016","0.5523562","0.5522004","0.5519541","0.5491558","0.5490245","0.5482695","0.5477311","0.54714876","0.5455842","0.5401068","0.53915024","0.5386421","0.5363864","0.5360252","0.53593147","0.534877","0.5342157","0.5334164","0.5332326","0.53286314","0.5322751","0.53197736","0.5297206","0.52938014","0.5286649","0.5274136","0.5269184","0.526877","0.5264399","0.52573866","0.52489525","0.5248707","0.5242126","0.5236954","0.5233255","0.5229459","0.52235085","0.52217656","0.52129364","0.5211666","0.5209115","0.5191541","0.5191292","0.51715356","0.5165973","0.51442236","0.5139641","0.5129319","0.5126168","0.51169896","0.51127255","0.51115495","0.51111734"],"string":"[\n \"0.7689971\",\n \"0.722182\",\n \"0.70508206\",\n \"0.6771436\",\n \"0.6603375\",\n \"0.65443844\",\n \"0.6535205\",\n \"0.6525045\",\n \"0.6332471\",\n \"0.6293604\",\n \"0.62730294\",\n \"0.6270745\",\n \"0.6242984\",\n \"0.6230076\",\n \"0.6186949\",\n \"0.6171401\",\n \"0.61592084\",\n \"0.61382926\",\n \"0.60904527\",\n \"0.6066599\",\n \"0.6053936\",\n \"0.6024809\",\n \"0.599621\",\n \"0.5991829\",\n \"0.5973389\",\n \"0.5916031\",\n \"0.5911982\",\n \"0.5894305\",\n \"0.583867\",\n \"0.58327216\",\n \"0.58101594\",\n \"0.57992506\",\n \"0.5796422\",\n \"0.57921994\",\n \"0.57800484\",\n \"0.5778197\",\n \"0.5712965\",\n \"0.5681609\",\n \"0.5642277\",\n \"0.5618538\",\n \"0.5607689\",\n \"0.5598206\",\n \"0.557698\",\n \"0.557049\",\n \"0.555963\",\n \"0.55436665\",\n \"0.5536016\",\n \"0.5523562\",\n \"0.5522004\",\n \"0.5519541\",\n \"0.5491558\",\n \"0.5490245\",\n \"0.5482695\",\n \"0.5477311\",\n \"0.54714876\",\n \"0.5455842\",\n \"0.5401068\",\n \"0.53915024\",\n \"0.5386421\",\n \"0.5363864\",\n \"0.5360252\",\n \"0.53593147\",\n \"0.534877\",\n \"0.5342157\",\n \"0.5334164\",\n \"0.5332326\",\n \"0.53286314\",\n \"0.5322751\",\n \"0.53197736\",\n \"0.5297206\",\n \"0.52938014\",\n \"0.5286649\",\n \"0.5274136\",\n \"0.5269184\",\n \"0.526877\",\n \"0.5264399\",\n \"0.52573866\",\n \"0.52489525\",\n \"0.5248707\",\n \"0.5242126\",\n \"0.5236954\",\n \"0.5233255\",\n \"0.5229459\",\n \"0.52235085\",\n \"0.52217656\",\n \"0.52129364\",\n \"0.5211666\",\n \"0.5209115\",\n \"0.5191541\",\n \"0.5191292\",\n \"0.51715356\",\n \"0.5165973\",\n \"0.51442236\",\n \"0.5139641\",\n \"0.5129319\",\n \"0.5126168\",\n \"0.51169896\",\n \"0.51127255\",\n \"0.51115495\",\n \"0.51111734\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8195249"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83182,"cells":{"query":{"kind":"string","value":"Context manager to work with (b)gzipped file."},"document":{"kind":"string","value":"def extracted_file(fname: str):\n new_fname = extract_gzip(fname)\n gzipped = True\n if new_fname is None:\n new_fname = fname\n gzipped = False\n\n try:\n yield new_fname\n finally:\n if gzipped:\n try:\n bgzip_and_name(new_fname)\n except Exception:\n gzip_and_name(new_fname)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def do_gzip(fileobj):\r\n sio = cStringIO.StringIO()\r\n gzf = gzip.GzipFile(fileobj = sio, mode = \"wb\")\r\n while True:\r\n data = fileobj.read(buf_size)\r\n if not data:\r\n break\r\n gzf.write(data)\r\n gzf.close()\r\n return sio","def open_gz(filename, mode):\n return gzip.open(filename, mode)","def __init__(self, path: str):\n self._path = path\n self._fp = gzip.open(self._path, mode=\"r\")","def handle_file(self, path):\n\n if path:\n if not matches_patterns(path, self.gzip_patterns):\n return\n\n try:\n original_file = self.open(path, mode=\"rb\")\n except FileNotFoundError:\n pass\n else:\n gzipped_path = \"{0}.gz\".format(path)\n\n if self.exists(gzipped_path):\n self.delete(gzipped_path)\n\n gzipped_file = self._compress(original_file)\n gzipped_path = self.save(gzipped_path, gzipped_file)\n\n return gzipped_path, gzipped_path, True","def _compress_content(self, content):\n zbuf = io.BytesIO()\n zfile = gzip.GzipFile(mode=\"wb\", compresslevel=9, fileobj=zbuf)\n\n try:\n zfile.write(content.read())\n finally:\n zfile.close()\n\n content.file = zbuf\n content.seek(0)\n\n return content","def open_gzip(fn):\n magic = b'\\x1f\\x8b\\x08'\n l = len(magic)\n with open(fn, 'rb') as f:\n file_start = f.read(l)\n f.seek(0)\n # check if the file is compressed\n if file_start.startswith(magic):\n return gzip.open(fn, 'rt')\n # not compressed\n return open(fn, 'rt')","def __init__(self, input_stream, level=9):\n super(Gzip, self).__init__(input_stream)\n\n self._level = level","def skip_gzip_check(self):\r\n _read_eof = gzip._GzipReader._read_eof\r\n gzip.GzipFile._read_eof = lambda *args, **kwargs: None\r\n yield\r\n gzip.GzipFile._read_eof = _read_eof","def test_compress_file_response(self):\n with open(__file__, \"rb\") as file1:\n\n def get_response(req):\n file_resp = FileResponse(file1)\n file_resp[\"Content-Type\"] = \"text/html; charset=UTF-8\"\n return file_resp\n\n r = GZipMiddleware(get_response)(self.req)\n with open(__file__, \"rb\") as file2:\n self.assertEqual(self.decompress(b\"\".join(r)), file2.read())\n self.assertEqual(r.get(\"Content-Encoding\"), \"gzip\")\n self.assertIsNot(r.file_to_stream, file1)","def gzopen(f):\n return gzip.open(f, 'rb') if f.endswith('.gz') else open(f, 'r')","def open_gzipped(infile, mode='rt'):\n import gzip\n import bz2\n if mode.startswith('r'):\n tmode = 'rt'\n bmode = 'r'\n elif mode.startswith('w'):\n tmode = 'wt'\n bmode = 'w'\n elif mode.startswith('a'):\n tmode = 'at'\n bmode = 'a'\n if hasattr(infile, 'write'):\n return infile\n if isinstance(infile, str):\n if infile.endswith('.gz'):\n return gzip.open(infile, tmode)\n if infile.endswith('.bz2'):\n if hasattr(bz2, 'open'):\n return bz2.open(infile, tmode)\n else:\n return bz2.BZ2File(infile, bmode)\n return open(infile, tmode)","def _determine_compression_safe_file_opener(self):\n f = gzip.open(self.input_fname, \"r\")\n try:\n f.read(1)\n self._compression_safe_file_opener = gzip.open\n except IOError:\n self._compression_safe_file_opener = open\n finally:\n f.close()","def __init__(self, resolver_context, path_spec):\n super(CompressedStreamFileSystem, self).__init__(\n resolver_context, path_spec)\n self._compression_method = None","def _open_zip(self):\n self.buffer = io.BytesIO()\n self.zf = zipfile.ZipFile(self.buffer, \"w\", zipfile.ZIP_DEFLATED)","def _gzip_file(filename):\n gzip_filename = filename + '.gz'\n with open(filename, 'rb') as f_in, gzip.open(gzip_filename, 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)","def prepare_gz(self, filename, *args, **kwargs):\n\n return '/vsigzip/' + filename, args, kwargs","def save_to_gzip(data,fname):\n with gzip.open(fname + '.gz', 'wb',compresslevel = 9) as f:\n f.write(data.tobytes())","def __unzip(self, data):\n compressed = StringIO.StringIO(data)\n gzipper = gzip.GzipFile(fileobj=compressed)\n return gzipper.read()","def gzip_worker(args):\n\tp = multiprocessing.current_process()\n\tprint('Start zipping %s: %s %s' %(args[1], p.name, p.pid))\n\tpath = args[0]\n\tfilename = args[1]\n\tassert os.path.splitext(filename)[1] == '.fastq', '%s is not a fastq file' %filename \n\t\n\tcall = 'gzip -c ' + os.path.join(path, filename) + ' > ' + os.path.join(path, filename) + '.gz'\n\tsubprocess.call(call, shell=True)\n\tprint('Completed zipping %s: %s %s' %(filename, p.name, p.pid))","def _CreateTaskStorageMergeReader(self, path):\n return gzip_file.GZIPStorageMergeReader(self, path)","def gunzip(data):\n return gzip.GzipFile(fileobj=StringIO(data)).read()","def crackOpen(path: Union[pathlib.Path, str], mode: str=\"r\", **args: Any) -> Generator[Union[gzip.GzipFile, TextIO, IO[Any]], None, None]:\n p = pathlib.Path(path)\n _, encoding = mimetypes.guess_type(p.name)\n if encoding == \"gzip\":\n if not mode.endswith(\"b\"):\n mode += \"t\" # Force text mode if binary not requested\n with gzip.open(path, mode, **args) as f:\n yield f\n else:\n with open(path, mode, **args) as g:\n yield g","def open_(filename, mode=None, compresslevel=9):\n if filename[-3:] == '.gz':\n if mode is None: mode = 'rt'\n return closing(gzip.open(filename, mode, compresslevel))\n else:\n if mode is None: mode = 'r'\n return open(filename, mode)","def parse(path):\n data = gzip.open(path, 'rb')\n for byte_line in data:\n yield eval(byte_line) # return generator instance to save memory","def de_gzip(data):\n cmps = StringIO.StringIO(data)\n gzipper = gzip.GzipFile(fileobj=cmps)\n return gzipper.read()","def de_gzip(data):\n cmps = StringIO.StringIO(data)\n gzipper = gzip.GzipFile(fileobj=cmps)\n return gzipper.read()","def decompress_gzip(in_str):\n # gzip can only handle file object therefore using StringIO\n copmressed_stream = StringIO.StringIO(in_str)\n gzipper = gzip.GzipFile(fileobj=copmressed_stream)\n s = gzipper.read()\n gzipper.close()\n return s","def gzip_compress(data):\n s = BytesIO()\n g = gzip.GzipFile(fileobj=s, mode='wb')\n g.write(data)\n g.close()\n return s.getvalue()","def decompress_gzip(in_str):\n import gzip\n # gzip can only handle file object therefore using StringIO\n copmressed_stream = StringIO.StringIO(in_str)\n gzipper = gzip.GzipFile(fileobj=copmressed_stream)\n s = gzipper.read()\n gzipper.close()\n return s","def _gzip_reader_fn():\n return tf.TFRecordReader(\n options=tf.python_io.TFRecordOptions(\n compression_type=tf.python_io.TFRecordCompressionType.GZIP))","def read_gzipped(response):\r\n if response.info().get('Content-Encoding') == 'gzip':\r\n with io.BytesIO(response.read()) as buf:\r\n with gzip.GzipFile(fileobj=buf) as unzipped:\r\n data = unzipped.read()\r\n else:\r\n data = response.read()\r\n return data","def tar_gz_compress(self, destination):\n\n if destination is not None and isinstance(destination, str):\n with tarfile_open(destination, \"w:gz\") as tar:\n tar.add(self.file)","def _gzipencode(content):\n import gzip\n out = BytesIO()\n f = gzip.GzipFile(fileobj=out, mode='w', compresslevel=5)\n f.write(content)\n f.close()\n return out.getvalue()","def open_compressed(filename, open_flag='r', compression_type='bz2'):\n # create temporary HDF5 file name\n hdf5_file_name = tempfile.mkstemp('.hdf5', 'bob_')[1]\n\n if open_flag == 'r':\n # extract the HDF5 file from the given file name into a temporary file name\n tar = tarfile.open(filename, mode=\"r:\" + compression_type)\n memory_file = tar.extractfile(tar.next())\n real_file = open(hdf5_file_name, 'wb')\n real_file.write(memory_file.read())\n del memory_file\n real_file.close()\n tar.close()\n\n return bob.io.base.HDF5File(hdf5_file_name, open_flag)","def _compress_string(content):\n zbuf = StringIO()\n zfile = GzipFile(mode='wb', compresslevel=6, fileobj=zbuf)\n zfile.write(content)\n zfile.close()\n return zbuf.getvalue()","def __handle_compression(self, x):\n if self.__compress:\n return zlib.compress(x)\n return x","def read_gzip_bytes(self):\n with gzip.open(self, 'rb') as f:\n return f.read()","def open_file(file_path, mode=None, buffer_size=FILE_BUFFER_SIZE, gzip_exts=('.gz','.gzip'), partial=False):\n import io\n \n if os.path.splitext(file_path)[1].lower() in gzip_exts:\n if mode and 'w' in mode:\n file_obj = BufferedWriter(gzip.open(file_path, mode), buffer_size)\n \n else:\n if partial:\n file_obj = BufferedReader(gzip.open(file_path, mode or 'rb'), buffer_size)\n \n else:\n try:\n file_obj = subprocess.Popen(['zcat', file_path], stdout=subprocess.PIPE).stdout\n except OSError:\n file_obj = BufferedReader(gzip.open(file_path, mode or 'rb'), buffer_size)\n \n if sys.version_info.major > 2:\n file_obj = io.TextIOWrapper(file_obj, encoding=\"utf-8\")\n \n else:\n if sys.version_info.major > 2:\n file_obj = open(file_path, mode or 'rU', buffer_size, encoding='utf-8')\n \n else:\n file_obj = open(file_path, mode or 'rU', buffer_size)\n \n return file_obj","def _unzip(self, data):\r\n with io.BytesIO(data) as buf:\r\n with gzip.GzipFile(fileobj=buf) as unzipped:\r\n return unzipped.read()","def compress_stream(src, dst):\n with gzip.GzipFile(fileobj=dst, mode='wb') as gz:\n for block in iterfile(src):\n gz.write(block)","def open_zip(path, *args, **kwargs):\r\n with contextlib.closing(zipfile.ZipFile(path, *args, **kwargs)) as zip:\r\n yield zip","def fixture_filled_gzip_file(non_existing_gzipped_file_path: Path, content: str) -> Path:\n with gzip.open(non_existing_gzipped_file_path, \"wb\") as outfile:\n with io.TextIOWrapper(outfile, encoding=\"utf-8\") as enc:\n enc.write(content)\n return non_existing_gzipped_file_path","def gunzip_file(gz_path, new_path):\n print(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def decompress_stream(src, dst):\n with gzip.GzipFile(fileobj=src, mode='rb') as gz:\n for block in iterfile(gz):\n dst.write(block)","def test_decompress_file():\n gz_file = os.path.join(\n tempfile.gettempdir(),\n \"jade-unit-test-file.gz\",\n )\n with gzip.open(gz_file, \"wb\") as f:\n f.write(b\"Hello World\")\n assert os.path.exists(gz_file)\n\n new_file = decompress_file(gz_file)\n assert os.path.exists(new_file)\n with open(new_file, \"r\") as f:\n data = f.read()\n assert data == \"Hello World\"\n\n if os.path.exists(gz_file):\n os.remove(gz_file)\n\n if os.path.exists(new_file):\n os.remove(new_file)","def gzipFile(aFile):\n f_in = open(aFile, \"rb\")\n f_out = gzip.open(aFile + \".gz\", \"wb\")\n f_out.writelines(f_in)\n f_out.close()\n f_in.close()\n os.remove(aFile)","def gzipPage(page):\n #if not hasattr(page,\"info\"):\n # return(\"\")\n data = object()\n # Check if content encoding is gzip\n if page.info().get('Content-Encoding') == 'gzip':\n buf = StringIO(page.read())\n f = gzip.GzipFile(fileobj=buf)\n data = f.read()\n else :\n data = page.read()\n return(data)","def smart_open(file, mode='rt', encoding='utf-8'):\n if file.endswith('.gz'):\n return gzip.open(file, mode=mode, encoding=encoding, newline=\"\\n\")\n return open(file, mode=mode, encoding=encoding, newline=\"\\n\")","def test_file_gzip_utf8_readwrite(self):\n if state.py2:\n FileWriter(self.unicode_path).gzip(self.unicode_string)\n gzip_contents = FileReader(self.unicode_path + \".gz\").read_gzip() # when read without explicit utf-8 decoding, the strings will not match\n self.assertNotEqual(gzip_contents, self.unicode_string)\n elif state.py3:\n FileWriter(self.unicode_path).gzip(bytes(self.unicode_string, 'utf-8'))\n gzip_contents = FileReader(self.unicode_path + \".gz\").read_gzip() # when read without explicit utf-8 decoding, the strings will not match\n self.assertNotEqual(gzip_contents, self.unicode_string)","def get_create_handler(self):\n return gzip.open(self.index_abspath, 'wt', compresslevel=self.compress_level)","def clean_gzip():\n this_dir = os.getcwd()\n os.chdir(\"/data/COHERENT2/data/CrystalChar/raw\")\n all_files = glob.glob(\"./**\", recursive=True)\n for f in all_files:\n if \".gz\" in f and \"tar\" not in f:\n print(f)\n sh(\"gunzip \" + f)\n os.chdir(this_dir)","def gunzip_file(gz_path, new_path):\n print(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def __init__(self,\n output_type=None,\n gzip_filehandle=None,\n gzip_filehandle_parent=None,\n schema=None):\n self.output_type = output_type\n self.gzip_filehandle = gzip_filehandle\n self.schema = schema\n self.gzip_filehandle_parent = gzip_filehandle_parent","def gunzip_file(gz_path, new_path):\n logging.info(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def _ReopenFileObject(self):\n if self._file_object:\n self._file_object.close()\n self._file_object = None\n\n self._file_object = self._zip_file.open(self.name, mode='r')\n self._stream_offset = 0","def test_compress_response(self):\n r = GZipMiddleware(self.get_response)(self.req)\n self.assertEqual(self.decompress(r.content), self.compressible_string)\n self.assertEqual(r.get(\"Content-Encoding\"), \"gzip\")\n self.assertEqual(r.get(\"Content-Length\"), str(len(r.content)))","def test_gzip_file_no_extension(self):\n # Write the data to a file\n temp_file = tempfile.NamedTemporaryFile()\n with gzip.open(temp_file.name, 'wb') as out:\n for item in self.data:\n serialzed = json.dumps(item).encode()\n out.write(serialzed + b'\\n')\n\n # Load from file, ensure it is correct\n actual_data = []\n with JsonlReader(temp_file.name) as f:\n for item in f:\n actual_data.append(item)\n self.assertEqual(self.data, actual_data)","def __init__(self, input_stream, threads=DEFAULT_THREADS, level=9):\n super(Pigz, self).__init__(\n input_stream,\n program=\"pigz\",\n threads=threads,\n level=level,\n suffix=\".gz\",\n )","def gunzip_file(gz_path, new_path):\n print(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def _tarfile_open_ex(*args, **kwargs):\n\treturn contextlib.closing(tarfile.open(*args, **kwargs))","def return_file_handle(input_file):\n if str(input_file).endswith(\".gz\"):\n gzipped_file_handle = gzip.open(input_file, \"rt\")\n return gzipped_file_handle\n else:\n normal_fh = open(input_file, \"r\")\n return normal_fh","def _OpenFileObject(self):\n try:\n if self._decompress_stream:\n self._zip_file.extract(self.name, self._temporary_path)\n else:\n self._file_object = self._zip_file.open(self.name, mode=b'r')\n return\n\n except KeyError as exception:\n raise IOError(\n 'Unable to open stream with error: {0!s}'.format(exception))\n\n self._stream_file_path = os.path.join(self._temporary_path, self.name)\n self._file_object = open(self._stream_file_path, 'rb')","def read_gzip_file_content(self, s3_path):\n s3_object = self._get_s3_object(s3_path)\n\n bytestream = BytesIO(s3_object.get()['Body'].read())\n\n gzip_file = GzipFile(mode=\"rb\", fileobj=bytestream)\n output = gzip_file.read().decode(\"utf-8\")\n\n return output","def __init__(self, fileref, compression_level=None):\n self.__ref = fileref\n if compression_level is None:\n compression_level = DEFAULT_COMPRESSION_LEVEL\n self.__lib = _zlib.compressobj(level=compression_level)\n self.__nwritten = 0","def __init__(self, path):\n super(ZIPStorageFileReader, self).__init__(path)\n self._storage_file = ZIPStorageFile()\n self._storage_file.Open(path=path)","def gzip_assets():\n run('cd %(repo_path)s; python gzip_assets.py' % env)","def gzip_files(topDir, afni_file,localizerfile):\n\n print 'GZIPPING FILES...'\n\n command1 = \"gzip %s*BRIK\" % (topDir)\n command2 = \"gzip %s*HEAD\" % (topDir)\n command3 = \"gzip %s%s/pb00*\" % (topDir,afni_file)\n command4 = \"gzip %s%s/errts*\" % (topDir,afni_file)\n command5 = \"gzip %s%s/fitts*\" % (topDir,afni_file)\n command6 = \"gzip %s%s/*al*\" % (topDir,afni_file)\n command7 = \"gzip %s%s/*ns*\" % (topDir,afni_file)\n command8 = \"gzip %s%s/all_runs*\" % (topDir,afni_file)\n command9 = \"gzip %s%s/*mask*\" % (topDir,afni_file)\n command10 = \"gzip %s*nii\" % (topDir)\n command11 = \"gzip %s%s/pb01*\" % (topDir,afni_file)\n command12 = \"gzip %s%s/pb03*\" % (topDir,afni_file)\n command13 = \"gzip %s%s/pb02*\" % (topDir,afni_file)\n\n os.system(command1)\n os.system(command2)\n os.system(command3)\n os.system(command4)\n os.system(command5)\n os.system(command6)\n os.system(command7)\n os.system(command8)\n #os.system(command9)\n os.system(command10)\n os.system(command11)\n try:\n os.system(command12)\n except:\n print 'Could not gzip pb03 files'\n\n if localizerfile == 'facescene_loc':\n os.system(command13)","def write_to_gzip(fname, html_body):\n dir_path = os.path.dirname(fname)\n ensure_dir_exists(dir_path)\n\n with gzip.open(fname, 'wb') as html_file:\n html_file.write(html_body)","def parse_fastq(filepath):\n if REGEX_GZIPPED.match(filepath):\n logging.debug('Opening \"%s\" as gzipped file', filepath)\n # using os.popen with zcat since it is much faster than gzip.open or gzip.open(io.BufferedReader)\n # http://aripollak.com/pythongzipbenchmarks/\n # assumes Linux os with zcat installed\n import os\n with os.popen('zcat < {}'.format(filepath)) as f:\n yield from _parse_fastq(f)\n else:\n with open(filepath, 'r') as f:\n yield from _parse_fastq(f)","def _gzip_reader_fn(filenames):\n return tf.data.TFRecordDataset(filenames, compression_type=\"GZIP\")","def test_file_gzip_ascii_readwrite(self):\n if state.py2:\n FileWriter(self.ascii_path).gzip(self.ascii_string)\n gzip_contents = FileReader(self.ascii_path + \".gz\").read_gzip()\n self.assertEqual(gzip_contents, self.ascii_string)\n elif state.py3:\n FileWriter(self.ascii_path).gzip(bytes(self.ascii_string, 'utf-8'))\n gzip_contents = FileReader(self.ascii_path + \".gz\").read_gzip()\n self.assertEqual(gzip_contents.decode('ascii'), self.ascii_string)","def _gzip_reader_fn(filenames):\n return tf.data.TFRecordDataset(filenames, compression_type='GZIP')","def _Close(self):\n self._compression_method = None","def extract_gzip(fname: str, outfile: Optional[str] = None) -> Union[str, None]:\n if not outfile:\n outfile = fname[:-3]\n\n if fname.endswith(\".gz\"):\n with gzip.open(fname, \"rb\") as f_in:\n with open(outfile, \"wb\") as f_out:\n shutil.copyfileobj(f_in, f_out)\n os.unlink(fname)\n return outfile","def _gzip_reader_fn(filenames):\n return tf.data.TFRecordDataset(\n filenames,\n compression_type='GZIP')","def _gzip_reader_fn(filenames):\n return tf.data.TFRecordDataset(\n filenames,\n compression_type='GZIP')","def __init__(\n self, session, output_file, buffer_size=0,\n storage_type=definitions.STORAGE_TYPE_SESSION, task=None):\n super(ZIPStorageFileWriter, self).__init__(\n session, output_file, storage_type=storage_type, task=task)\n self._buffer_size = buffer_size","def test_args_gzip(testapp):\n\n timepoint = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\n stream = sitemap.process(\n testapp,\n [\n holocron.WebSiteItem(\n {\n \"destination\": pathlib.Path(\"1.html\"),\n \"updated\": timepoint,\n \"baseurl\": testapp.metadata[\"url\"],\n }\n )\n ],\n gzip=True,\n )\n\n assert isinstance(stream, collections.abc.Iterable)\n assert list(stream) == [\n holocron.WebSiteItem(\n {\n \"destination\": pathlib.Path(\"1.html\"),\n \"updated\": timepoint,\n \"baseurl\": testapp.metadata[\"url\"],\n }\n ),\n holocron.WebSiteItem(\n {\n \"source\": pathlib.Path(\"sitemap://sitemap.xml.gz\"),\n \"destination\": pathlib.Path(\"sitemap.xml.gz\"),\n \"content\": _pytest_xmlasdict(\n {\n \"urlset\": {\n \"@xmlns\": \"http://www.sitemaps.org/schemas/sitemap/0.9\",\n \"url\": {\n \"loc\": \"https://yoda.ua/1.html\",\n \"lastmod\": \"1970-01-01T00:00:00+00:00\",\n },\n }\n },\n ungzip=True,\n ),\n \"baseurl\": testapp.metadata[\"url\"],\n }\n ),\n ]","def uncompress_gzip(location, target_dir):\n\n return uncompress(location, target_dir, decompressor=gzip.GzipFile)","def get_infile(filename):\r\n if filename.endswith(\".gz\"):\r\n fin = GzipFile(filename, \"rb\")\r\n else:\r\n fin = open(filename, \"U\")\r\n return fin","def get_infile(filename):\r\n if filename.endswith(\".gz\"):\r\n fin = GzipFile(filename, \"rb\")\r\n else:\r\n fin = open(filename, \"U\")\r\n return fin","def __enter__(self):\n self._in_context_block = True\n # TODO: create local backup of file in case we can't upload and have to roll back\n return self","def is_gzip(fp):\r\n return open(fp, 'rb').read(2) == '\\x1f\\x8b'","def _files_from_json(self, file_json):\n self.compressed_file_json = zlib.compress(json.dumps(file_json).encode('utf-8'))\n self.compression_algorithm = 'gzip'\n self.compressed_content_hash = hashlib.sha256(self.compressed_file_json).hexdigest()","def compress_file(path):\n\n process = Popen([\"xz\", \"--compress\", \"--force\", \"--stdout\", path], stdout=PIPE)\n return process.communicate()[0]","def compress_file(path):\n\n process = Popen([\"xz\", \"--compress\", \"--force\", \"--stdout\", path], stdout=PIPE)\n return process.communicate()[0]","def open_(filename, *args):\n\n if (filename[-3:] == '.gz'):\n return gzip.open(filename, *args)\n try:\n return open(filename, *args)\n except OSError:\n return gzip.open(filename + \".gz\", *args)","def _filehandle(self):\n if not self._fh or self._is_closed():\n filename = self._rotated_logfile or self.filename\n if filename.endswith('.gz'):\n self._fh = gzip.open(filename, 'r')\n else:\n self._fh = open(filename, \"r\", 1)\n self._fh.seek(self._offset)\n\n return self._fh","def genOpen(filename, mode):\n (name, ext) = os.path.splitext(filename)\n if ext == \".gz\":\n return gzip.open(filename, mode)\n else:\n return open(filename, mode)","def genOpen(filename, mode):\n (name, ext) = os.path.splitext(filename)\n if ext == \".gz\":\n return gzip.open(filename, mode)\n else:\n return open(filename, mode)","def test_gzip_page(self):\n content = self.unique_gzip()\n self.assertViewBehavior(\n {\"get\": content},\n headers={\"HTTP_ACCEPT_ENCODING\": \"gzip\"},\n status_code=200,\n content=self.compress(content),\n headers_exact={\"Content-Encoding\": \"gzip\"})","def generate(self):\n xml = self.template()\n fp = BytesIO()\n gzip = GzipFile(self.filename, \"wb\", 9, fp)\n if isinstance(xml, str):\n xml = xml.encode(\"utf8\")\n gzip.write(xml)\n gzip.close()\n data = fp.getvalue()\n fp.close()\n return data","def __init__(self,filePath,headerSymbols=['@','+']):\n if filePath.endswith('.gz'):\n self._file = gzip.open(filePath)\n else:\n self._file = open(filePath, 'rU')\n self._currentLineNumber = 0\n self._hdSyms = headerSymbols","def __init__(self,filePath,headerSymbols=['@','+']):\n if filePath.endswith('.gz'):\n self._file = gzip.open(filePath)\n else:\n self._file = open(filePath, 'rU')\n self._currentLineNumber = 0\n self._hdSyms = headerSymbols","def _compress_meds_file(self, ucfilename, fzfilename):\n from os.path import basename\n\n tup=(basename(ucfilename),basename(fzfilename))\n print('compressing file: %s -> %s' % tup)\n tpath=files.expandpath(fzfilename)\n if os.path.exists(tpath):\n os.remove(tpath)\n\n tmpdir = os.path.dirname(ucfilename)\n with StagedOutFile(fzfilename,tmpdir=tmpdir) as sf:\n cmd = self['fpack_command']\n cmd = cmd.format(fname=ucfilename)\n ret=os.system(cmd)\n\n if ret != 0:\n raise RuntimeError(\"failed to compress file\")\n\n print('output is in:',fzfilename)","def data_zip(self, data):\n stringio = StringIO.StringIO()\n gzip_file = gzip.GzipFile(fileobj=stringio, mode='wb')\n gzip_file.write(data)\n gzip_file.close()\n return stringio.getvalue()","def write_body_in_gz_file(self):\r\n if self.arguments['--out']:\r\n self.file = gzip.open(self.arguments['--out'] + '.gz', \"a+b\")\r\n for list_item in self.list_of_body_objects:\r\n self.file.write(list_item.line.encode('utf-8'))\r\n self.file.close()\r\n else:\r\n for list_item in self.list_of_body_objects:\r\n print(list_item.line.encode('utf-8'))\r\n\r\n self.file.close()","def compressBuffer(self, buffer):\r\n # http://jython.xhaus.com/http-compression-in-python-and-jython/\r\n zbuf = cStringIO.StringIO()\r\n zfile = gzip.GzipFile(mode='wb', fileobj=zbuf, compresslevel=9)\r\n zfile.write(buffer)\r\n zfile.close()\r\n return zbuf.getvalue()","def wrapped_tarball(export_context, context):\n result = export_result_dict(export_context)\n RESPONSE = context.REQUEST.RESPONSE\n RESPONSE.setHeader('Content-type', 'application/x-gzip')\n RESPONSE.setHeader('Content-disposition',\n 'attachment; filename=%s' % result['filename'])\n return result['tarball']","def _open_zipped(infile, mode='r', encoding='utf-8'):\n mode = mode[0] + 't'\n p2mode = mode\n if hasattr(infile, 'write'):\n return infile\n if isinstance(infile, str):\n if infile.endswith('.gz'):\n return _zopen(infile, mode)\n if infile.endswith('.bz2'):\n return _bopen(infile, mode)\n return open(infile, p2mode, encoding=encoding)"],"string":"[\n \"def do_gzip(fileobj):\\r\\n sio = cStringIO.StringIO()\\r\\n gzf = gzip.GzipFile(fileobj = sio, mode = \\\"wb\\\")\\r\\n while True:\\r\\n data = fileobj.read(buf_size)\\r\\n if not data:\\r\\n break\\r\\n gzf.write(data)\\r\\n gzf.close()\\r\\n return sio\",\n \"def open_gz(filename, mode):\\n return gzip.open(filename, mode)\",\n \"def __init__(self, path: str):\\n self._path = path\\n self._fp = gzip.open(self._path, mode=\\\"r\\\")\",\n \"def handle_file(self, path):\\n\\n if path:\\n if not matches_patterns(path, self.gzip_patterns):\\n return\\n\\n try:\\n original_file = self.open(path, mode=\\\"rb\\\")\\n except FileNotFoundError:\\n pass\\n else:\\n gzipped_path = \\\"{0}.gz\\\".format(path)\\n\\n if self.exists(gzipped_path):\\n self.delete(gzipped_path)\\n\\n gzipped_file = self._compress(original_file)\\n gzipped_path = self.save(gzipped_path, gzipped_file)\\n\\n return gzipped_path, gzipped_path, True\",\n \"def _compress_content(self, content):\\n zbuf = io.BytesIO()\\n zfile = gzip.GzipFile(mode=\\\"wb\\\", compresslevel=9, fileobj=zbuf)\\n\\n try:\\n zfile.write(content.read())\\n finally:\\n zfile.close()\\n\\n content.file = zbuf\\n content.seek(0)\\n\\n return content\",\n \"def open_gzip(fn):\\n magic = b'\\\\x1f\\\\x8b\\\\x08'\\n l = len(magic)\\n with open(fn, 'rb') as f:\\n file_start = f.read(l)\\n f.seek(0)\\n # check if the file is compressed\\n if file_start.startswith(magic):\\n return gzip.open(fn, 'rt')\\n # not compressed\\n return open(fn, 'rt')\",\n \"def __init__(self, input_stream, level=9):\\n super(Gzip, self).__init__(input_stream)\\n\\n self._level = level\",\n \"def skip_gzip_check(self):\\r\\n _read_eof = gzip._GzipReader._read_eof\\r\\n gzip.GzipFile._read_eof = lambda *args, **kwargs: None\\r\\n yield\\r\\n gzip.GzipFile._read_eof = _read_eof\",\n \"def test_compress_file_response(self):\\n with open(__file__, \\\"rb\\\") as file1:\\n\\n def get_response(req):\\n file_resp = FileResponse(file1)\\n file_resp[\\\"Content-Type\\\"] = \\\"text/html; charset=UTF-8\\\"\\n return file_resp\\n\\n r = GZipMiddleware(get_response)(self.req)\\n with open(__file__, \\\"rb\\\") as file2:\\n self.assertEqual(self.decompress(b\\\"\\\".join(r)), file2.read())\\n self.assertEqual(r.get(\\\"Content-Encoding\\\"), \\\"gzip\\\")\\n self.assertIsNot(r.file_to_stream, file1)\",\n \"def gzopen(f):\\n return gzip.open(f, 'rb') if f.endswith('.gz') else open(f, 'r')\",\n \"def open_gzipped(infile, mode='rt'):\\n import gzip\\n import bz2\\n if mode.startswith('r'):\\n tmode = 'rt'\\n bmode = 'r'\\n elif mode.startswith('w'):\\n tmode = 'wt'\\n bmode = 'w'\\n elif mode.startswith('a'):\\n tmode = 'at'\\n bmode = 'a'\\n if hasattr(infile, 'write'):\\n return infile\\n if isinstance(infile, str):\\n if infile.endswith('.gz'):\\n return gzip.open(infile, tmode)\\n if infile.endswith('.bz2'):\\n if hasattr(bz2, 'open'):\\n return bz2.open(infile, tmode)\\n else:\\n return bz2.BZ2File(infile, bmode)\\n return open(infile, tmode)\",\n \"def _determine_compression_safe_file_opener(self):\\n f = gzip.open(self.input_fname, \\\"r\\\")\\n try:\\n f.read(1)\\n self._compression_safe_file_opener = gzip.open\\n except IOError:\\n self._compression_safe_file_opener = open\\n finally:\\n f.close()\",\n \"def __init__(self, resolver_context, path_spec):\\n super(CompressedStreamFileSystem, self).__init__(\\n resolver_context, path_spec)\\n self._compression_method = None\",\n \"def _open_zip(self):\\n self.buffer = io.BytesIO()\\n self.zf = zipfile.ZipFile(self.buffer, \\\"w\\\", zipfile.ZIP_DEFLATED)\",\n \"def _gzip_file(filename):\\n gzip_filename = filename + '.gz'\\n with open(filename, 'rb') as f_in, gzip.open(gzip_filename, 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\",\n \"def prepare_gz(self, filename, *args, **kwargs):\\n\\n return '/vsigzip/' + filename, args, kwargs\",\n \"def save_to_gzip(data,fname):\\n with gzip.open(fname + '.gz', 'wb',compresslevel = 9) as f:\\n f.write(data.tobytes())\",\n \"def __unzip(self, data):\\n compressed = StringIO.StringIO(data)\\n gzipper = gzip.GzipFile(fileobj=compressed)\\n return gzipper.read()\",\n \"def gzip_worker(args):\\n\\tp = multiprocessing.current_process()\\n\\tprint('Start zipping %s: %s %s' %(args[1], p.name, p.pid))\\n\\tpath = args[0]\\n\\tfilename = args[1]\\n\\tassert os.path.splitext(filename)[1] == '.fastq', '%s is not a fastq file' %filename \\n\\t\\n\\tcall = 'gzip -c ' + os.path.join(path, filename) + ' > ' + os.path.join(path, filename) + '.gz'\\n\\tsubprocess.call(call, shell=True)\\n\\tprint('Completed zipping %s: %s %s' %(filename, p.name, p.pid))\",\n \"def _CreateTaskStorageMergeReader(self, path):\\n return gzip_file.GZIPStorageMergeReader(self, path)\",\n \"def gunzip(data):\\n return gzip.GzipFile(fileobj=StringIO(data)).read()\",\n \"def crackOpen(path: Union[pathlib.Path, str], mode: str=\\\"r\\\", **args: Any) -> Generator[Union[gzip.GzipFile, TextIO, IO[Any]], None, None]:\\n p = pathlib.Path(path)\\n _, encoding = mimetypes.guess_type(p.name)\\n if encoding == \\\"gzip\\\":\\n if not mode.endswith(\\\"b\\\"):\\n mode += \\\"t\\\" # Force text mode if binary not requested\\n with gzip.open(path, mode, **args) as f:\\n yield f\\n else:\\n with open(path, mode, **args) as g:\\n yield g\",\n \"def open_(filename, mode=None, compresslevel=9):\\n if filename[-3:] == '.gz':\\n if mode is None: mode = 'rt'\\n return closing(gzip.open(filename, mode, compresslevel))\\n else:\\n if mode is None: mode = 'r'\\n return open(filename, mode)\",\n \"def parse(path):\\n data = gzip.open(path, 'rb')\\n for byte_line in data:\\n yield eval(byte_line) # return generator instance to save memory\",\n \"def de_gzip(data):\\n cmps = StringIO.StringIO(data)\\n gzipper = gzip.GzipFile(fileobj=cmps)\\n return gzipper.read()\",\n \"def de_gzip(data):\\n cmps = StringIO.StringIO(data)\\n gzipper = gzip.GzipFile(fileobj=cmps)\\n return gzipper.read()\",\n \"def decompress_gzip(in_str):\\n # gzip can only handle file object therefore using StringIO\\n copmressed_stream = StringIO.StringIO(in_str)\\n gzipper = gzip.GzipFile(fileobj=copmressed_stream)\\n s = gzipper.read()\\n gzipper.close()\\n return s\",\n \"def gzip_compress(data):\\n s = BytesIO()\\n g = gzip.GzipFile(fileobj=s, mode='wb')\\n g.write(data)\\n g.close()\\n return s.getvalue()\",\n \"def decompress_gzip(in_str):\\n import gzip\\n # gzip can only handle file object therefore using StringIO\\n copmressed_stream = StringIO.StringIO(in_str)\\n gzipper = gzip.GzipFile(fileobj=copmressed_stream)\\n s = gzipper.read()\\n gzipper.close()\\n return s\",\n \"def _gzip_reader_fn():\\n return tf.TFRecordReader(\\n options=tf.python_io.TFRecordOptions(\\n compression_type=tf.python_io.TFRecordCompressionType.GZIP))\",\n \"def read_gzipped(response):\\r\\n if response.info().get('Content-Encoding') == 'gzip':\\r\\n with io.BytesIO(response.read()) as buf:\\r\\n with gzip.GzipFile(fileobj=buf) as unzipped:\\r\\n data = unzipped.read()\\r\\n else:\\r\\n data = response.read()\\r\\n return data\",\n \"def tar_gz_compress(self, destination):\\n\\n if destination is not None and isinstance(destination, str):\\n with tarfile_open(destination, \\\"w:gz\\\") as tar:\\n tar.add(self.file)\",\n \"def _gzipencode(content):\\n import gzip\\n out = BytesIO()\\n f = gzip.GzipFile(fileobj=out, mode='w', compresslevel=5)\\n f.write(content)\\n f.close()\\n return out.getvalue()\",\n \"def open_compressed(filename, open_flag='r', compression_type='bz2'):\\n # create temporary HDF5 file name\\n hdf5_file_name = tempfile.mkstemp('.hdf5', 'bob_')[1]\\n\\n if open_flag == 'r':\\n # extract the HDF5 file from the given file name into a temporary file name\\n tar = tarfile.open(filename, mode=\\\"r:\\\" + compression_type)\\n memory_file = tar.extractfile(tar.next())\\n real_file = open(hdf5_file_name, 'wb')\\n real_file.write(memory_file.read())\\n del memory_file\\n real_file.close()\\n tar.close()\\n\\n return bob.io.base.HDF5File(hdf5_file_name, open_flag)\",\n \"def _compress_string(content):\\n zbuf = StringIO()\\n zfile = GzipFile(mode='wb', compresslevel=6, fileobj=zbuf)\\n zfile.write(content)\\n zfile.close()\\n return zbuf.getvalue()\",\n \"def __handle_compression(self, x):\\n if self.__compress:\\n return zlib.compress(x)\\n return x\",\n \"def read_gzip_bytes(self):\\n with gzip.open(self, 'rb') as f:\\n return f.read()\",\n \"def open_file(file_path, mode=None, buffer_size=FILE_BUFFER_SIZE, gzip_exts=('.gz','.gzip'), partial=False):\\n import io\\n \\n if os.path.splitext(file_path)[1].lower() in gzip_exts:\\n if mode and 'w' in mode:\\n file_obj = BufferedWriter(gzip.open(file_path, mode), buffer_size)\\n \\n else:\\n if partial:\\n file_obj = BufferedReader(gzip.open(file_path, mode or 'rb'), buffer_size)\\n \\n else:\\n try:\\n file_obj = subprocess.Popen(['zcat', file_path], stdout=subprocess.PIPE).stdout\\n except OSError:\\n file_obj = BufferedReader(gzip.open(file_path, mode or 'rb'), buffer_size)\\n \\n if sys.version_info.major > 2:\\n file_obj = io.TextIOWrapper(file_obj, encoding=\\\"utf-8\\\")\\n \\n else:\\n if sys.version_info.major > 2:\\n file_obj = open(file_path, mode or 'rU', buffer_size, encoding='utf-8')\\n \\n else:\\n file_obj = open(file_path, mode or 'rU', buffer_size)\\n \\n return file_obj\",\n \"def _unzip(self, data):\\r\\n with io.BytesIO(data) as buf:\\r\\n with gzip.GzipFile(fileobj=buf) as unzipped:\\r\\n return unzipped.read()\",\n \"def compress_stream(src, dst):\\n with gzip.GzipFile(fileobj=dst, mode='wb') as gz:\\n for block in iterfile(src):\\n gz.write(block)\",\n \"def open_zip(path, *args, **kwargs):\\r\\n with contextlib.closing(zipfile.ZipFile(path, *args, **kwargs)) as zip:\\r\\n yield zip\",\n \"def fixture_filled_gzip_file(non_existing_gzipped_file_path: Path, content: str) -> Path:\\n with gzip.open(non_existing_gzipped_file_path, \\\"wb\\\") as outfile:\\n with io.TextIOWrapper(outfile, encoding=\\\"utf-8\\\") as enc:\\n enc.write(content)\\n return non_existing_gzipped_file_path\",\n \"def gunzip_file(gz_path, new_path):\\n print(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def decompress_stream(src, dst):\\n with gzip.GzipFile(fileobj=src, mode='rb') as gz:\\n for block in iterfile(gz):\\n dst.write(block)\",\n \"def test_decompress_file():\\n gz_file = os.path.join(\\n tempfile.gettempdir(),\\n \\\"jade-unit-test-file.gz\\\",\\n )\\n with gzip.open(gz_file, \\\"wb\\\") as f:\\n f.write(b\\\"Hello World\\\")\\n assert os.path.exists(gz_file)\\n\\n new_file = decompress_file(gz_file)\\n assert os.path.exists(new_file)\\n with open(new_file, \\\"r\\\") as f:\\n data = f.read()\\n assert data == \\\"Hello World\\\"\\n\\n if os.path.exists(gz_file):\\n os.remove(gz_file)\\n\\n if os.path.exists(new_file):\\n os.remove(new_file)\",\n \"def gzipFile(aFile):\\n f_in = open(aFile, \\\"rb\\\")\\n f_out = gzip.open(aFile + \\\".gz\\\", \\\"wb\\\")\\n f_out.writelines(f_in)\\n f_out.close()\\n f_in.close()\\n os.remove(aFile)\",\n \"def gzipPage(page):\\n #if not hasattr(page,\\\"info\\\"):\\n # return(\\\"\\\")\\n data = object()\\n # Check if content encoding is gzip\\n if page.info().get('Content-Encoding') == 'gzip':\\n buf = StringIO(page.read())\\n f = gzip.GzipFile(fileobj=buf)\\n data = f.read()\\n else :\\n data = page.read()\\n return(data)\",\n \"def smart_open(file, mode='rt', encoding='utf-8'):\\n if file.endswith('.gz'):\\n return gzip.open(file, mode=mode, encoding=encoding, newline=\\\"\\\\n\\\")\\n return open(file, mode=mode, encoding=encoding, newline=\\\"\\\\n\\\")\",\n \"def test_file_gzip_utf8_readwrite(self):\\n if state.py2:\\n FileWriter(self.unicode_path).gzip(self.unicode_string)\\n gzip_contents = FileReader(self.unicode_path + \\\".gz\\\").read_gzip() # when read without explicit utf-8 decoding, the strings will not match\\n self.assertNotEqual(gzip_contents, self.unicode_string)\\n elif state.py3:\\n FileWriter(self.unicode_path).gzip(bytes(self.unicode_string, 'utf-8'))\\n gzip_contents = FileReader(self.unicode_path + \\\".gz\\\").read_gzip() # when read without explicit utf-8 decoding, the strings will not match\\n self.assertNotEqual(gzip_contents, self.unicode_string)\",\n \"def get_create_handler(self):\\n return gzip.open(self.index_abspath, 'wt', compresslevel=self.compress_level)\",\n \"def clean_gzip():\\n this_dir = os.getcwd()\\n os.chdir(\\\"/data/COHERENT2/data/CrystalChar/raw\\\")\\n all_files = glob.glob(\\\"./**\\\", recursive=True)\\n for f in all_files:\\n if \\\".gz\\\" in f and \\\"tar\\\" not in f:\\n print(f)\\n sh(\\\"gunzip \\\" + f)\\n os.chdir(this_dir)\",\n \"def gunzip_file(gz_path, new_path):\\n print(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def __init__(self,\\n output_type=None,\\n gzip_filehandle=None,\\n gzip_filehandle_parent=None,\\n schema=None):\\n self.output_type = output_type\\n self.gzip_filehandle = gzip_filehandle\\n self.schema = schema\\n self.gzip_filehandle_parent = gzip_filehandle_parent\",\n \"def gunzip_file(gz_path, new_path):\\n logging.info(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def _ReopenFileObject(self):\\n if self._file_object:\\n self._file_object.close()\\n self._file_object = None\\n\\n self._file_object = self._zip_file.open(self.name, mode='r')\\n self._stream_offset = 0\",\n \"def test_compress_response(self):\\n r = GZipMiddleware(self.get_response)(self.req)\\n self.assertEqual(self.decompress(r.content), self.compressible_string)\\n self.assertEqual(r.get(\\\"Content-Encoding\\\"), \\\"gzip\\\")\\n self.assertEqual(r.get(\\\"Content-Length\\\"), str(len(r.content)))\",\n \"def test_gzip_file_no_extension(self):\\n # Write the data to a file\\n temp_file = tempfile.NamedTemporaryFile()\\n with gzip.open(temp_file.name, 'wb') as out:\\n for item in self.data:\\n serialzed = json.dumps(item).encode()\\n out.write(serialzed + b'\\\\n')\\n\\n # Load from file, ensure it is correct\\n actual_data = []\\n with JsonlReader(temp_file.name) as f:\\n for item in f:\\n actual_data.append(item)\\n self.assertEqual(self.data, actual_data)\",\n \"def __init__(self, input_stream, threads=DEFAULT_THREADS, level=9):\\n super(Pigz, self).__init__(\\n input_stream,\\n program=\\\"pigz\\\",\\n threads=threads,\\n level=level,\\n suffix=\\\".gz\\\",\\n )\",\n \"def gunzip_file(gz_path, new_path):\\n print(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def _tarfile_open_ex(*args, **kwargs):\\n\\treturn contextlib.closing(tarfile.open(*args, **kwargs))\",\n \"def return_file_handle(input_file):\\n if str(input_file).endswith(\\\".gz\\\"):\\n gzipped_file_handle = gzip.open(input_file, \\\"rt\\\")\\n return gzipped_file_handle\\n else:\\n normal_fh = open(input_file, \\\"r\\\")\\n return normal_fh\",\n \"def _OpenFileObject(self):\\n try:\\n if self._decompress_stream:\\n self._zip_file.extract(self.name, self._temporary_path)\\n else:\\n self._file_object = self._zip_file.open(self.name, mode=b'r')\\n return\\n\\n except KeyError as exception:\\n raise IOError(\\n 'Unable to open stream with error: {0!s}'.format(exception))\\n\\n self._stream_file_path = os.path.join(self._temporary_path, self.name)\\n self._file_object = open(self._stream_file_path, 'rb')\",\n \"def read_gzip_file_content(self, s3_path):\\n s3_object = self._get_s3_object(s3_path)\\n\\n bytestream = BytesIO(s3_object.get()['Body'].read())\\n\\n gzip_file = GzipFile(mode=\\\"rb\\\", fileobj=bytestream)\\n output = gzip_file.read().decode(\\\"utf-8\\\")\\n\\n return output\",\n \"def __init__(self, fileref, compression_level=None):\\n self.__ref = fileref\\n if compression_level is None:\\n compression_level = DEFAULT_COMPRESSION_LEVEL\\n self.__lib = _zlib.compressobj(level=compression_level)\\n self.__nwritten = 0\",\n \"def __init__(self, path):\\n super(ZIPStorageFileReader, self).__init__(path)\\n self._storage_file = ZIPStorageFile()\\n self._storage_file.Open(path=path)\",\n \"def gzip_assets():\\n run('cd %(repo_path)s; python gzip_assets.py' % env)\",\n \"def gzip_files(topDir, afni_file,localizerfile):\\n\\n print 'GZIPPING FILES...'\\n\\n command1 = \\\"gzip %s*BRIK\\\" % (topDir)\\n command2 = \\\"gzip %s*HEAD\\\" % (topDir)\\n command3 = \\\"gzip %s%s/pb00*\\\" % (topDir,afni_file)\\n command4 = \\\"gzip %s%s/errts*\\\" % (topDir,afni_file)\\n command5 = \\\"gzip %s%s/fitts*\\\" % (topDir,afni_file)\\n command6 = \\\"gzip %s%s/*al*\\\" % (topDir,afni_file)\\n command7 = \\\"gzip %s%s/*ns*\\\" % (topDir,afni_file)\\n command8 = \\\"gzip %s%s/all_runs*\\\" % (topDir,afni_file)\\n command9 = \\\"gzip %s%s/*mask*\\\" % (topDir,afni_file)\\n command10 = \\\"gzip %s*nii\\\" % (topDir)\\n command11 = \\\"gzip %s%s/pb01*\\\" % (topDir,afni_file)\\n command12 = \\\"gzip %s%s/pb03*\\\" % (topDir,afni_file)\\n command13 = \\\"gzip %s%s/pb02*\\\" % (topDir,afni_file)\\n\\n os.system(command1)\\n os.system(command2)\\n os.system(command3)\\n os.system(command4)\\n os.system(command5)\\n os.system(command6)\\n os.system(command7)\\n os.system(command8)\\n #os.system(command9)\\n os.system(command10)\\n os.system(command11)\\n try:\\n os.system(command12)\\n except:\\n print 'Could not gzip pb03 files'\\n\\n if localizerfile == 'facescene_loc':\\n os.system(command13)\",\n \"def write_to_gzip(fname, html_body):\\n dir_path = os.path.dirname(fname)\\n ensure_dir_exists(dir_path)\\n\\n with gzip.open(fname, 'wb') as html_file:\\n html_file.write(html_body)\",\n \"def parse_fastq(filepath):\\n if REGEX_GZIPPED.match(filepath):\\n logging.debug('Opening \\\"%s\\\" as gzipped file', filepath)\\n # using os.popen with zcat since it is much faster than gzip.open or gzip.open(io.BufferedReader)\\n # http://aripollak.com/pythongzipbenchmarks/\\n # assumes Linux os with zcat installed\\n import os\\n with os.popen('zcat < {}'.format(filepath)) as f:\\n yield from _parse_fastq(f)\\n else:\\n with open(filepath, 'r') as f:\\n yield from _parse_fastq(f)\",\n \"def _gzip_reader_fn(filenames):\\n return tf.data.TFRecordDataset(filenames, compression_type=\\\"GZIP\\\")\",\n \"def test_file_gzip_ascii_readwrite(self):\\n if state.py2:\\n FileWriter(self.ascii_path).gzip(self.ascii_string)\\n gzip_contents = FileReader(self.ascii_path + \\\".gz\\\").read_gzip()\\n self.assertEqual(gzip_contents, self.ascii_string)\\n elif state.py3:\\n FileWriter(self.ascii_path).gzip(bytes(self.ascii_string, 'utf-8'))\\n gzip_contents = FileReader(self.ascii_path + \\\".gz\\\").read_gzip()\\n self.assertEqual(gzip_contents.decode('ascii'), self.ascii_string)\",\n \"def _gzip_reader_fn(filenames):\\n return tf.data.TFRecordDataset(filenames, compression_type='GZIP')\",\n \"def _Close(self):\\n self._compression_method = None\",\n \"def extract_gzip(fname: str, outfile: Optional[str] = None) -> Union[str, None]:\\n if not outfile:\\n outfile = fname[:-3]\\n\\n if fname.endswith(\\\".gz\\\"):\\n with gzip.open(fname, \\\"rb\\\") as f_in:\\n with open(outfile, \\\"wb\\\") as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n os.unlink(fname)\\n return outfile\",\n \"def _gzip_reader_fn(filenames):\\n return tf.data.TFRecordDataset(\\n filenames,\\n compression_type='GZIP')\",\n \"def _gzip_reader_fn(filenames):\\n return tf.data.TFRecordDataset(\\n filenames,\\n compression_type='GZIP')\",\n \"def __init__(\\n self, session, output_file, buffer_size=0,\\n storage_type=definitions.STORAGE_TYPE_SESSION, task=None):\\n super(ZIPStorageFileWriter, self).__init__(\\n session, output_file, storage_type=storage_type, task=task)\\n self._buffer_size = buffer_size\",\n \"def test_args_gzip(testapp):\\n\\n timepoint = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\\n stream = sitemap.process(\\n testapp,\\n [\\n holocron.WebSiteItem(\\n {\\n \\\"destination\\\": pathlib.Path(\\\"1.html\\\"),\\n \\\"updated\\\": timepoint,\\n \\\"baseurl\\\": testapp.metadata[\\\"url\\\"],\\n }\\n )\\n ],\\n gzip=True,\\n )\\n\\n assert isinstance(stream, collections.abc.Iterable)\\n assert list(stream) == [\\n holocron.WebSiteItem(\\n {\\n \\\"destination\\\": pathlib.Path(\\\"1.html\\\"),\\n \\\"updated\\\": timepoint,\\n \\\"baseurl\\\": testapp.metadata[\\\"url\\\"],\\n }\\n ),\\n holocron.WebSiteItem(\\n {\\n \\\"source\\\": pathlib.Path(\\\"sitemap://sitemap.xml.gz\\\"),\\n \\\"destination\\\": pathlib.Path(\\\"sitemap.xml.gz\\\"),\\n \\\"content\\\": _pytest_xmlasdict(\\n {\\n \\\"urlset\\\": {\\n \\\"@xmlns\\\": \\\"http://www.sitemaps.org/schemas/sitemap/0.9\\\",\\n \\\"url\\\": {\\n \\\"loc\\\": \\\"https://yoda.ua/1.html\\\",\\n \\\"lastmod\\\": \\\"1970-01-01T00:00:00+00:00\\\",\\n },\\n }\\n },\\n ungzip=True,\\n ),\\n \\\"baseurl\\\": testapp.metadata[\\\"url\\\"],\\n }\\n ),\\n ]\",\n \"def uncompress_gzip(location, target_dir):\\n\\n return uncompress(location, target_dir, decompressor=gzip.GzipFile)\",\n \"def get_infile(filename):\\r\\n if filename.endswith(\\\".gz\\\"):\\r\\n fin = GzipFile(filename, \\\"rb\\\")\\r\\n else:\\r\\n fin = open(filename, \\\"U\\\")\\r\\n return fin\",\n \"def get_infile(filename):\\r\\n if filename.endswith(\\\".gz\\\"):\\r\\n fin = GzipFile(filename, \\\"rb\\\")\\r\\n else:\\r\\n fin = open(filename, \\\"U\\\")\\r\\n return fin\",\n \"def __enter__(self):\\n self._in_context_block = True\\n # TODO: create local backup of file in case we can't upload and have to roll back\\n return self\",\n \"def is_gzip(fp):\\r\\n return open(fp, 'rb').read(2) == '\\\\x1f\\\\x8b'\",\n \"def _files_from_json(self, file_json):\\n self.compressed_file_json = zlib.compress(json.dumps(file_json).encode('utf-8'))\\n self.compression_algorithm = 'gzip'\\n self.compressed_content_hash = hashlib.sha256(self.compressed_file_json).hexdigest()\",\n \"def compress_file(path):\\n\\n process = Popen([\\\"xz\\\", \\\"--compress\\\", \\\"--force\\\", \\\"--stdout\\\", path], stdout=PIPE)\\n return process.communicate()[0]\",\n \"def compress_file(path):\\n\\n process = Popen([\\\"xz\\\", \\\"--compress\\\", \\\"--force\\\", \\\"--stdout\\\", path], stdout=PIPE)\\n return process.communicate()[0]\",\n \"def open_(filename, *args):\\n\\n if (filename[-3:] == '.gz'):\\n return gzip.open(filename, *args)\\n try:\\n return open(filename, *args)\\n except OSError:\\n return gzip.open(filename + \\\".gz\\\", *args)\",\n \"def _filehandle(self):\\n if not self._fh or self._is_closed():\\n filename = self._rotated_logfile or self.filename\\n if filename.endswith('.gz'):\\n self._fh = gzip.open(filename, 'r')\\n else:\\n self._fh = open(filename, \\\"r\\\", 1)\\n self._fh.seek(self._offset)\\n\\n return self._fh\",\n \"def genOpen(filename, mode):\\n (name, ext) = os.path.splitext(filename)\\n if ext == \\\".gz\\\":\\n return gzip.open(filename, mode)\\n else:\\n return open(filename, mode)\",\n \"def genOpen(filename, mode):\\n (name, ext) = os.path.splitext(filename)\\n if ext == \\\".gz\\\":\\n return gzip.open(filename, mode)\\n else:\\n return open(filename, mode)\",\n \"def test_gzip_page(self):\\n content = self.unique_gzip()\\n self.assertViewBehavior(\\n {\\\"get\\\": content},\\n headers={\\\"HTTP_ACCEPT_ENCODING\\\": \\\"gzip\\\"},\\n status_code=200,\\n content=self.compress(content),\\n headers_exact={\\\"Content-Encoding\\\": \\\"gzip\\\"})\",\n \"def generate(self):\\n xml = self.template()\\n fp = BytesIO()\\n gzip = GzipFile(self.filename, \\\"wb\\\", 9, fp)\\n if isinstance(xml, str):\\n xml = xml.encode(\\\"utf8\\\")\\n gzip.write(xml)\\n gzip.close()\\n data = fp.getvalue()\\n fp.close()\\n return data\",\n \"def __init__(self,filePath,headerSymbols=['@','+']):\\n if filePath.endswith('.gz'):\\n self._file = gzip.open(filePath)\\n else:\\n self._file = open(filePath, 'rU')\\n self._currentLineNumber = 0\\n self._hdSyms = headerSymbols\",\n \"def __init__(self,filePath,headerSymbols=['@','+']):\\n if filePath.endswith('.gz'):\\n self._file = gzip.open(filePath)\\n else:\\n self._file = open(filePath, 'rU')\\n self._currentLineNumber = 0\\n self._hdSyms = headerSymbols\",\n \"def _compress_meds_file(self, ucfilename, fzfilename):\\n from os.path import basename\\n\\n tup=(basename(ucfilename),basename(fzfilename))\\n print('compressing file: %s -> %s' % tup)\\n tpath=files.expandpath(fzfilename)\\n if os.path.exists(tpath):\\n os.remove(tpath)\\n\\n tmpdir = os.path.dirname(ucfilename)\\n with StagedOutFile(fzfilename,tmpdir=tmpdir) as sf:\\n cmd = self['fpack_command']\\n cmd = cmd.format(fname=ucfilename)\\n ret=os.system(cmd)\\n\\n if ret != 0:\\n raise RuntimeError(\\\"failed to compress file\\\")\\n\\n print('output is in:',fzfilename)\",\n \"def data_zip(self, data):\\n stringio = StringIO.StringIO()\\n gzip_file = gzip.GzipFile(fileobj=stringio, mode='wb')\\n gzip_file.write(data)\\n gzip_file.close()\\n return stringio.getvalue()\",\n \"def write_body_in_gz_file(self):\\r\\n if self.arguments['--out']:\\r\\n self.file = gzip.open(self.arguments['--out'] + '.gz', \\\"a+b\\\")\\r\\n for list_item in self.list_of_body_objects:\\r\\n self.file.write(list_item.line.encode('utf-8'))\\r\\n self.file.close()\\r\\n else:\\r\\n for list_item in self.list_of_body_objects:\\r\\n print(list_item.line.encode('utf-8'))\\r\\n\\r\\n self.file.close()\",\n \"def compressBuffer(self, buffer):\\r\\n # http://jython.xhaus.com/http-compression-in-python-and-jython/\\r\\n zbuf = cStringIO.StringIO()\\r\\n zfile = gzip.GzipFile(mode='wb', fileobj=zbuf, compresslevel=9)\\r\\n zfile.write(buffer)\\r\\n zfile.close()\\r\\n return zbuf.getvalue()\",\n \"def wrapped_tarball(export_context, context):\\n result = export_result_dict(export_context)\\n RESPONSE = context.REQUEST.RESPONSE\\n RESPONSE.setHeader('Content-type', 'application/x-gzip')\\n RESPONSE.setHeader('Content-disposition',\\n 'attachment; filename=%s' % result['filename'])\\n return result['tarball']\",\n \"def _open_zipped(infile, mode='r', encoding='utf-8'):\\n mode = mode[0] + 't'\\n p2mode = mode\\n if hasattr(infile, 'write'):\\n return infile\\n if isinstance(infile, str):\\n if infile.endswith('.gz'):\\n return _zopen(infile, mode)\\n if infile.endswith('.bz2'):\\n return _bopen(infile, mode)\\n return open(infile, p2mode, encoding=encoding)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6809535","0.675466","0.661344","0.6587002","0.65678066","0.6511136","0.6488444","0.6413921","0.63567406","0.63266903","0.62170494","0.6216539","0.62095344","0.6157152","0.606511","0.60540587","0.6029327","0.60214204","0.59915817","0.59607774","0.5935949","0.5887478","0.5882752","0.58777726","0.58726037","0.58726037","0.5851364","0.5846711","0.580837","0.5804596","0.58015794","0.5786722","0.5766549","0.5765804","0.57606226","0.5746137","0.5737775","0.57139343","0.56938624","0.5690978","0.5677442","0.567659","0.5660232","0.5651689","0.5643902","0.5639313","0.5638976","0.5615948","0.56135964","0.5600457","0.55931264","0.5584459","0.5573924","0.5566271","0.5561689","0.5551396","0.5540777","0.55219644","0.55191416","0.55125886","0.55120033","0.55061525","0.55030674","0.54955137","0.5482991","0.54742414","0.5472507","0.5468805","0.5461835","0.5461239","0.5453872","0.54393405","0.54254663","0.541932","0.54120225","0.54120225","0.5406205","0.5399559","0.5387203","0.53812504","0.53812504","0.53799176","0.5379385","0.5377148","0.53556263","0.53556263","0.534931","0.53459245","0.53398746","0.53398746","0.5332305","0.532423","0.5323624","0.5323624","0.53166974","0.53155917","0.5309263","0.5305012","0.53017116","0.53007793"],"string":"[\n \"0.6809535\",\n \"0.675466\",\n \"0.661344\",\n \"0.6587002\",\n \"0.65678066\",\n \"0.6511136\",\n \"0.6488444\",\n \"0.6413921\",\n \"0.63567406\",\n \"0.63266903\",\n \"0.62170494\",\n \"0.6216539\",\n \"0.62095344\",\n \"0.6157152\",\n \"0.606511\",\n \"0.60540587\",\n \"0.6029327\",\n \"0.60214204\",\n \"0.59915817\",\n \"0.59607774\",\n \"0.5935949\",\n \"0.5887478\",\n \"0.5882752\",\n \"0.58777726\",\n \"0.58726037\",\n \"0.58726037\",\n \"0.5851364\",\n \"0.5846711\",\n \"0.580837\",\n \"0.5804596\",\n \"0.58015794\",\n \"0.5786722\",\n \"0.5766549\",\n \"0.5765804\",\n \"0.57606226\",\n \"0.5746137\",\n \"0.5737775\",\n \"0.57139343\",\n \"0.56938624\",\n \"0.5690978\",\n \"0.5677442\",\n \"0.567659\",\n \"0.5660232\",\n \"0.5651689\",\n \"0.5643902\",\n \"0.5639313\",\n \"0.5638976\",\n \"0.5615948\",\n \"0.56135964\",\n \"0.5600457\",\n \"0.55931264\",\n \"0.5584459\",\n \"0.5573924\",\n \"0.5566271\",\n \"0.5561689\",\n \"0.5551396\",\n \"0.5540777\",\n \"0.55219644\",\n \"0.55191416\",\n \"0.55125886\",\n \"0.55120033\",\n \"0.55061525\",\n \"0.55030674\",\n \"0.54955137\",\n \"0.5482991\",\n \"0.54742414\",\n \"0.5472507\",\n \"0.5468805\",\n \"0.5461835\",\n \"0.5461239\",\n \"0.5453872\",\n \"0.54393405\",\n \"0.54254663\",\n \"0.541932\",\n \"0.54120225\",\n \"0.54120225\",\n \"0.5406205\",\n \"0.5399559\",\n \"0.5387203\",\n \"0.53812504\",\n \"0.53812504\",\n \"0.53799176\",\n \"0.5379385\",\n \"0.5377148\",\n \"0.53556263\",\n \"0.53556263\",\n \"0.534931\",\n \"0.53459245\",\n \"0.53398746\",\n \"0.53398746\",\n \"0.5332305\",\n \"0.532423\",\n \"0.5323624\",\n \"0.5323624\",\n \"0.53166974\",\n \"0.53155917\",\n \"0.5309263\",\n \"0.5305012\",\n \"0.53017116\",\n \"0.53007793\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66227496"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":83183,"cells":{"query":{"kind":"string","value":"Extract files from an archive. Archive may be a gzipped or bgzipped file (.gz), a zipped file (.zip) or a tarball (.tar.gz). Optionally, if multiple files are present they may be concatenated into one file."},"document":{"kind":"string","value":"def extract_archive(\n fname: str, outfile: Optional[str] = None, concat: bool = False\n) -> Union[str, None]:\n if fname.endswith((\".tgz\", \".tar.gz\")):\n return extract_tarball(fname, outfile=outfile)\n elif fname.endswith(\".gz\"):\n return extract_gzip(fname, outfile=outfile)\n elif fname.endswith(\n \".zip\",\n ):\n return extract_zip(fname, outfile=outfile, concat=concat)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def extract(apath, ffilter=[]):\n\n files = []\n\n def extract_recursive(curr_apath):\n \"\"\"Look into archive recursively to extract files considering ffilter\"\"\"\n\n handler = resolve_format(curr_apath)\n unpacker = HandlersFactory.get_handler(handler)\n _files = unpacker.files_list(curr_apath)\n\n for f in _files:\n if is_matched(f, ffilter=ffilter):\n _fpath = unpacker.extract(curr_apath, f)\n files.append(_fpath)\n if is_archive(f):\n _apath = unpacker.extract(curr_apath, f)\n extract_recursive(_apath)\n\n extract_recursive(apath)\n return files","def extract_tars(file_pattern, path_in, path_out):\n for f in glob.glob(os.path.join(path_in, file_pattern)):\n shutil.unpack_archive(f, path_out)","def extract_one(self, archive: Path, dest: Path):\n if dest.exists():\n shutil.rmtree(dest)\n\n dest.mkdir(parents=True)\n\n if self.should_use_libarchive_c:\n import libarchive\n\n old_cwd = os.getcwd()\n os.chdir(str(dest))\n try:\n libarchive.extract_file(str(archive))\n finally:\n os.chdir(old_cwd)\n return\n\n if archive.name.endswith(EXTENSION_ZIP):\n with zipfile.ZipFile(archive) as zf:\n zf.extractall(dest)\n elif archive.name.endswith(EXTENSION_TAR):\n mode = \"r:bz2\" if archive.name.endswith(\".bz2\") else \"r:gz\"\n with tarfile.open(archive, mode) as tf:\n self.safe_extract_all(tf, dest)\n else:\n raise ValueError(f\"Unrecognized archive format {archive.name}\")\n\n for path in [dest, *dest.rglob(\"*\")]:\n path.chmod(MOD_DIRECTORY if path.is_dir() else MOD_FILE)","def extract_all(fn,dst=\".\"):\r\n if tarfile.is_tarfile(fn): \r\n with tarfile.open(fn,'r') as tf:\r\n tf.extractall(dst)\r\n tf.close()\r\n elif zipfile.is_zipfile(fn):\r\n with zipfile.ZipFile(fn, 'r') as zf:\r\n zf.extractall(dst)\r\n zf.close()\r\n else:\r\n print( \"Please provide a tar archive file or zip file\" )","def extract(self, archive_path: str, extracted_path: str) -> None:\n if not os.listdir(archive_path):\n self.log.warning(\n \"No files found in directory: {}\".format(archive_path))\n return\n\n for root, _, archive_files in os.walk(archive_path):\n if not archive_files:\n continue\n\n extract_to = os.path.normpath(os.path.join(\n extracted_path,\n os.path.relpath(root, archive_path)\n ))\n if not os.path.isdir(extract_to):\n os.makedirs(extract_to)\n\n for zfile in archive_files:\n zfile = os.path.join(root, zfile)\n filename, ext = os.path.splitext(os.path.basename(zfile))\n # unzip (tree) each archive file in archive_path\n if ext in self.zip_ext:\n # double splitext for .tar.gz\n fname, ext = os.path.splitext(os.path.basename(filename))\n if ext == '.tar':\n filename = fname\n self.log.info(\"Extracting from: {}\".format(zfile))\n self.log.info(\" Extracting to: {}\".format(\n os.path.join(extract_to, filename)))\n unzip(\n zfile,\n extract_to,\n zip_ext=self.zip_ext,\n create_own_folder=True,\n tree=True\n )\n\n # move each non-archive file in archive_path\n else:\n dest = os.path.join(extract_to, os.path.basename(zfile))\n self.log.info(\"Copying from: {}\".format(zfile))\n self.log.info(\" Copying to: {}\".format(dest))\n shutil.copy(zfile, dest)","def archive_files(archive_fileprefix, flist, zip_type, reldir, prefix=\"\"):\n def archive_filter(tinfo):\n fdir, fbase = os.path.split(tinfo.name)\n archpath = os.path.join(prefix, os.path.relpath(tinfo.name, reldir))\n tinfo.name = archpath\n return tinfo\n write_type = 'w:'+zip_type\n\n if zip_type:\n archive_filename = '{}.tar.{}'.format(archive_fileprefix, zip_type)\n else:\n archive_filename = '{}.tar'.format(archive_fileprefix)\n\n with tarfile.open(archive_filename, write_type) as out_file:\n for f in flist:\n out_file.add(f, filter=archive_filter)","def unpack(archive: Union[Path, str],\n cwd: Optional[Path] = None,\n files: Optional[List[Union[Path, str]]] = ()):\n archive = Path(archive)\n if cwd is None:\n cwd = Path.cwd()\n if files:\n files = ['--'] + list(files)\n else:\n files = []\n\n # Try to make symlink usage easier in Windows.\n extra_env = {\n 'MSYS': 'winsymlinks:nativestrict',\n }\n\n logging.info('Unpacking %s', archive.name)\n # We use relpath here to help out tar on platforms where it doesn't like\n # paths with colons in them (e.g. Windows). We have to construct the full\n # before running through relpath as relative archives will implicitly be\n # checked against os.getcwd rather than the explicit cwd.\n src = os.path.relpath(cwd / archive, cwd)\n run(['tar', '--no-same-owner', '-xf', src] + files, cwd=cwd,\n extra_env=extra_env)","def extractall(self, *args, **kwargs):\n self.zipfile.extractall(*args, **kwargs)","def unpack_archive(self, archive_name):\n archive = zipfile.ZipFile(\n os.path.join(\n self.current_path,\n os.path.split(self.exe_file)[0],\n archive_name\n )\n )\n\n self.extraction_path = os.getcwd()\n\n archive.extractall(self.extraction_path)\n\n self.rename_main_script()\n\n archive_pyc_files = []\n\n for path, dirs, files in os.walk(self.extraction_path):\n for f in files:\n archive_pyc_files.append(os.path.join(path, f))\n\n return archive_pyc_files","def unpackArchiveToFiles(source, target = None, filter = None):\n if target is None:\n target, _ = os.path.split(source)\n \n for fileRecord, fileData in unpackArchive(source, filter):\n path, offset, size, compressedSize, archiveFileIndex = fileRecord\n \n outPath = os.path.join(target, path)\n outHead, outTail = os.path.split(outPath)\n os.makedirs(outHead, exist_ok = True)\n outFile = open(outPath, \"wb\")\n outFile.write(fileData)\n outFile.close()","def extract(archive_path, images_dir, test_zip=False):\n log(\"TRACE\", \"Attempting to extracted files from {}\".format(archive_path))\n with zipfile.ZipFile(archive_path) as images_zip:\n # Check that the Zip file is valid, in which case `testzip()` returns\n # None. If it's bad, that function will return a list of bad files\n try:\n if test_zip and images_zip.testzip():\n log(\"ERROR\", \"Could not extract the following invalid Zip file:\"\n \" {}\".format(archive_path))\n return []\n except OSError:\n log(\"ERROR\", \"Could not extract the following invalid Zip file:\"\n \" {}\".format(archive_path))\n return []\n images_zip.extractall(images_dir)\n archive_namelist = images_zip.namelist()\n log(\"TRACE\", \"Extracted files: {}\".format(archive_namelist))\n return archive_namelist","def _extract_archive(file_path, path='.', archive_format='auto'):\n if archive_format is None:\n return False\n if archive_format == 'auto':\n archive_format = ['tar', 'zip']\n if isinstance(archive_format, str):\n archive_format = [archive_format]\n\n file_path = path_to_string(file_path)\n path = path_to_string(path)\n\n for archive_type in archive_format:\n if archive_type == 'tar':\n open_fn = tarfile.open\n is_match_fn = tarfile.is_tarfile\n if archive_type == 'zip':\n open_fn = zipfile.ZipFile\n is_match_fn = zipfile.is_zipfile\n\n if is_match_fn(file_path):\n with open_fn(file_path) as archive:\n try:\n archive.extractall(path)\n except (tarfile.TarError, RuntimeError, KeyboardInterrupt):\n if os.path.exists(path):\n if os.path.isfile(path):\n os.remove(path)\n else:\n shutil.rmtree(path)\n raise\n return True\n return False","def extractFiles(self, archivePath, extractedFiles, filterList = None, ignoreList = None, isExtractingToCurrentDirectory = False, outputMessage = None):\r\n archiveNameWithoutExtension = os.path.splitext(os.path.split(archivePath)[1])[0]\r\n archivePathWithoutName = os.path.split(archivePath)[0]\r\n\r\n if isExtractingToCurrentDirectory:\r\n directoryToExtractTo = os.path.realpath(os.path.join(archivePathWithoutName, archiveNameWithoutExtension))\r\n else:\r\n directoryToExtractTo = os.path.realpath(os.path.join(self.tempDirectory, archiveNameWithoutExtension))\r\n \r\n try:\r\n with zipfile.ZipFile(archivePath, 'r') as zip:\r\n for name in zip.namelist():\r\n if EtFile.isIgnoredFile(name, filterList, ignoreList):\r\n continue\r\n\r\n pathToExtractedFile = os.path.realpath(os.path.join(directoryToExtractTo, name))\r\n if not pathToExtractedFile.startswith(directoryToExtractTo):\r\n # Files inside of zip archives can be maliciously named to cause writing to unexpected locations. All versions\r\n # of python prior to 2.7.4 are vulnerable to this sort of attack. Therefore, we must manually guarantee\r\n # that all writes are to our temporary directory.\r\n raise Exception(\"Security warning: Blocked directory traversal when extracting: '{}'\".format(name))\r\n\r\n zip.extract(name, directoryToExtractTo)\r\n \r\n if os.path.splitext(pathToExtractedFile)[1].lower() == \".zip\":\r\n self.extractFiles(pathToExtractedFile, extractedFiles, filterList, ignoreList, True, outputMessage)\r\n else:\r\n extractedFiles.append(pathToExtractedFile)\r\n except zipfile.BadZipfile:\r\n outputMessage(\"BadZipfile: \" + archivePath)","def _extract_archive(file_path, path='.', archive_format='auto'):\n if archive_format is None:\n return False\n if archive_format is 'auto':\n archive_format = ['tar', 'zip']\n if isinstance(archive_format, six.string_types):\n archive_format = [archive_format]\n\n for archive_type in archive_format:\n if archive_type is 'tar':\n open_fn = tarfile.open\n is_match_fn = tarfile.is_tarfile\n if archive_type is 'zip':\n open_fn = zipfile.ZipFile\n is_match_fn = zipfile.is_zipfile\n\n if is_match_fn(file_path):\n with open_fn(file_path) as archive:\n # check weather extracted or not\n extracted = True\n for fname in archive.getnames():\n if not os.path.exists(os.path.join(path, fname)):\n extracted = False\n if not extracted:\n try:\n archive.extractall(path)\n print('extracted to', path)\n except (tarfile.TarError, RuntimeError,\n KeyboardInterrupt):\n if os.path.exists(path):\n if os.path.isfile(path):\n os.remove(path)\n else:\n shutil.rmtree(path)\n raise\n return True\n return False","def _extract_archive(file_path, path='.', archive_format='auto'):\n if archive_format is None:\n return False\n if archive_format == 'auto':\n archive_format = ['tar', 'zip']\n if isinstance(archive_format, six.string_types):\n archive_format = [archive_format]\n\n for archive_type in archive_format:\n if archive_type == 'tar':\n open_fn = tarfile.open\n is_match_fn = tarfile.is_tarfile\n if archive_type == 'zip':\n open_fn = zipfile.ZipFile\n is_match_fn = zipfile.is_zipfile\n\n if is_match_fn(file_path):\n with open_fn(file_path) as archive:\n try:\n archive.extractall(path)\n except (tarfile.TarError, RuntimeError, KeyboardInterrupt):\n if os.path.exists(path):\n if os.path.isfile(path):\n os.remove(path)\n else:\n shutil.rmtree(path)\n raise\n return True\n return False","def _extract_archive(file_path, path=\".\", archive_format=\"auto\"):\n if archive_format is None:\n return False\n if archive_format == \"auto\":\n archive_format = [\"tar\", \"zip\"]\n if isinstance(archive_format, six.string_types):\n archive_format = [archive_format]\n\n for archive_type in archive_format:\n if archive_type == \"tar\":\n open_fn = tarfile.open\n is_match_fn = tarfile.is_tarfile\n if archive_type == \"zip\":\n open_fn = zipfile.ZipFile\n is_match_fn = zipfile.is_zipfile\n\n if is_match_fn(file_path):\n with open_fn(file_path) as archive:\n try:\n archive.extractall(path)\n except (tarfile.TarError, RuntimeError, KeyboardInterrupt):\n if os.path.exists(path):\n if os.path.isfile(path):\n os.remove(path)\n else:\n shutil.rmtree(path)\n raise\n return True\n return False","def extract_web_archive(cls, url, apath, ffilter=[]):\n\n if apath not in cls._archives.keys():\n download(url, apath)\n\n _files = extract(apath, ffilter=ffilter)\n\n return _files","def safetar_extractall(tarf, *args, **kwargs):\r\n return tarf.extractall(members=safemembers(tarf), *args, **kwargs)","def extract_web_archive(url, apath, ffilter=[]):\n\n download(url, apath)\n output_files = extract(apath, ffilter=ffilter)\n\n return output_files","def load_zip_archive(archive_file, \n file_list=None, \n suffix_list=['jpeg', 'jpg', 'png'],\n as_float=False):\n if type(file_list) in [str]:\n file_list = [file_list]\n\n if type(suffix_list) in [str]:\n suffix_list = [suffix_list]\n if suffix_list and type(suffix_list) not in [set]:\n suffix_list = set(suffix_list)\n\n imgs = []\n with ZipFile(archive_file, 'r') as zfa:\n for f_info in zfa.infolist():\n if f_info.is_dir():\n continue\n\n if suffix_list:\n i = f_info.filename.rfind('.')\n suffix = f_info.filename[i+1:].lower() if i >= 0 else ''\n if suffix not in suffix_list:\n continue\n\n if file_list:\n use_f = False\n for fl in file_list:\n if re.match(fl, f_info.filename):\n use_f = True\n break\n if not use_f:\n continue\n\n imgs.append((load_image(zfa.open(f_info)), f_info.filename))\n return imgs","def unzip_archive(archive):\n tmpdir = os.path.join(tempfile.gettempdir(),\n os.path.basename(archive))\n assert tmpdir != archive # That wouldn't work out\n\n if os.path.exists(tmpdir):\n # files are already extracted\n pass\n else:\n if tarfile.is_tarfile(archive):\n print 'Extracting tarfile ...'\n with tarfile.open(archive) as tf:\n tf.extractall(path=tmpdir)\n elif zipfile.is_zipfile(archive):\n print 'Extracting zipfile ...'\n with zipfile.ZipFile(archive) as zf:\n zf.extractall(path=tmpdir)\n else:\n raise ValueError('Unknown file type for %s' % os.path.basename(archive))\n return tmpdir","def _extract_multi_vol_zip(src, dst):\n cat_zip_path = os.path.join(dst, os.path.basename(src))\n _cat_multi_vol_zip(src, cat_zip_path)\n _extract_zip(cat_zip_path, dst)\n os.remove(cat_zip_path)","def extract_recursive(curr_apath):\n\n handler = resolve_format(curr_apath)\n unpacker = HandlersFactory.get_handler(handler)\n _files = unpacker.files_list(curr_apath)\n\n for f in _files:\n if is_matched(f, ffilter=ffilter):\n _fpath = unpacker.extract(curr_apath, f)\n files.append(_fpath)\n if is_archive(f):\n _apath = unpacker.extract(curr_apath, f)\n extract_recursive(_apath)","def git_archive_all(path, archive_file_name):\n import os\n import tarfile\n\n def ls_files(prefix=''):\n \"\"\"\n Does a `git ls-files` on every git repository (eg: submodules)\n found in the working git repository and returns a list with all the\n filenames returned by each `git ls-files`\n\n --full-name Forces paths to be output relative to the project top\n directory\n --exclude-standard adds standard git exclusions\n (.git/info/exclude, .gitignore, ...)\n \"\"\"\n cmd = 'git ls-files --full-name --exclude-standard'\n raw_files = local(cmd, capture=True)\n files = []\n\n for filename in raw_files.split('\\n'):\n if (os.path.isdir(filename) and\n os.path.exists(os.path.join(filename, '.git'))):\n os.chdir(filename)\n files.extend(ls_files(prefix=filename))\n else:\n files.append(os.path.join(prefix, filename))\n\n return files\n\n cwd = os.getcwd()\n os.chdir(path)\n files = ls_files()\n os.chdir(path)\n project_tar = tarfile.open(archive_file_name, 'w:gz')\n\n for filename in files:\n project_tar.add(filename)\n\n project_tar.close()\n os.chdir(cwd)\n\n print(green('Archive created at %s/%s' % (path, archive_file_name)))","def pack(archive: Union[Path, str],\n paths: List[Union[Path, str]],\n cwd: Optional[Path] = None,\n exclude: Optional[List[Union[Path, str]]] = ()):\n archive = Path(archive)\n if cwd is None:\n cwd = Path.cwd()\n if archive.suffix == '.xz':\n archive = archive.with_suffix('')\n\n # Make sure all the paths have sane permissions.\n def walk(path):\n if path.is_symlink():\n return\n elif path.is_dir():\n # All dirs should be 755.\n mode = path.stat().st_mode & 0o777\n if mode != 0o755:\n path.chmod(0o755)\n\n for subpath in path.glob('*'):\n walk(subpath)\n elif path.is_file():\n # All scripts should be 755 while other files should be 644.\n mode = path.stat().st_mode & 0o777\n if mode in (0o755, 0o644):\n return\n if mode & 0o111:\n path.chmod(0o755)\n else:\n path.chmod(0o644)\n else:\n raise ValueError(f'{path}: unknown file type')\n\n logging.info('Forcing sane permissions on inputs')\n for path in paths:\n walk(cwd / path)\n\n logging.info('Creating %s tarball', archive.name)\n # We use relpath here to help out tar on platforms where it doesn't like\n # paths with colons in them (e.g. Windows). We have to construct the full\n # before running through relpath as relative archives will implicitly be\n # checked against os.getcwd rather than the explicit cwd.\n tar = os.path.relpath(cwd / archive, cwd)\n run(['tar', '--owner=0', '--group=0', '-cf', tar] +\n [f'--exclude={x}' for x in exclude] + ['--'] + paths, cwd=cwd)\n\n logging.info('Compressing tarball')\n run(['xz', '-f', '-T0', '-9', tar], cwd=cwd)","def extract(self, step_name, archive_file, output, mode='safe',\n include_files=()):\n assert mode in ('safe', 'unsafe'), 'Unknown mode %r' % (mode,)\n\n step_result = self.m.python(\n step_name,\n self.resource('extract.py'),\n [\n '--json-input', self.m.json.input({\n 'output': str(output),\n 'archive_file': str(archive_file),\n 'safe_mode': mode == 'safe',\n 'include_files': list(include_files),\n }),\n '--json-output', self.m.json.output(),\n ],\n step_test_data=lambda: self.m.json.test_api.output({\n 'extracted': {\n 'filecount': 1337,\n 'bytes': 0xbadc0ffee,\n },\n }))\n self.m.path.mock_add_paths(output)\n j = step_result.json.output\n if j.get('extracted', {}).get('filecount'):\n stat = j['extracted']\n step_result.presentation.step_text += (\n '<br/>extracted %s files - %.02f MB' % (\n stat['filecount'], stat['bytes'] / (1000.0**2)))\n if j.get('skipped', {}).get('filecount'):\n stat = j['skipped']\n step_result.presentation.step_text += (\n '<br/>SKIPPED %s files - %.02f MB' % (\n stat['filecount'], stat['bytes'] / (1000.0**2)))\n step_result.presentation.logs['skipped files'] = stat['names']\n step_result.presentation.status = self.m.step.FAILURE\n ex = self.m.step.StepFailure(step_name)\n ex.archive_skipped_files = stat['names']\n raise ex","def extract_files(self, *filenames):\n for filename in filenames:\n data = self.read_file(filename)\n f = open(filename, 'wb')\n f.write(data or b'')\n f.close()","def _extract_zip(src, dst):\n # check if src is a valid .zip\n assert zipfile.is_zipfile(src), \"{} is not a valid .zip file.\".format(src)\n\n zip_file = zipfile.ZipFile(src, \"r\")\n for file in zip_file.namelist():\n zip_file.extract(file, dst)","def extract_sources(tarsources=[], zipsources=[]):\n for source in tarsources:\n cmd = [\"tar\", \"-xvf\", source, \"-C\", WHEEL_BUILD_DIR]\n subprocess.check_call(cmd)\n\n for source in zipsources:\n cmd = [\"unzip\", source, \"-d\", WHEEL_BUILD_DIR]\n subprocess.check_call(cmd)","def _extract_all_gz_in_dir(directory):\n for file in os.listdir(directory):\n if file.endswith(\".gz\"):\n gz_fname = os.path.join(directory, file)\n _extract_gz(gz_fname, os.path.dirname(gz_fname))\n os.remove(gz_fname)","def extract_tarball(fname, outfile=None, concat=True) -> Union[str, None]:\n fnames = []\n # Extract files to temporary directory\n tmp_dir = mkdtemp(dir=os.path.dirname(outfile))\n with tarfile.open(fname) as tar:\n tar.extractall(path=tmp_dir)\n for root, _, files in os.walk(tmp_dir):\n fnames += [os.path.join(root, fname) for fname in files]\n\n if len(fnames) > 1 and not concat:\n raise ValueError(\"tarball contains multiple files, but concat not specified!\")\n\n # Concatenate (also works woth one file)\n with open(outfile, \"w\") as out:\n for infile in fnames:\n for line in open(infile):\n out.write(line)\n\n rm_rf(tmp_dir)\n\n return outfile","def _unzip_files(self) -> None:\n for file in self.input_path.iterdir():\n if is_zipfile(file):\n with ZipFile(file, mode=\"r\") as archive:\n archive.extractall(path=self.temp_path)","def extract(file, fileFormat):\n\tspeech.speak(\"Extracting files in \" + file + \".\")\n\tpatoolib.extract_archive(file)","def extract(self, paths=None):\n\n all_files = self._get_package_files()\n if paths is None:\n extracted_files = all_files.values()\n else:\n extracted_files = [all_files[path] for path in paths]\n\n # filter already extracted file\n extracted_files = [pf for pf in extracted_files if not os.path.isfile(self.project.storage.fspath(pf.extract_path))]\n\n # group files by package\n files_by_package = defaultdict(list)\n for pf in extracted_files:\n files_by_package[pf.package].append(pf)\n\n package_files_path = f\"{self.path}/packages/files\"\n\n for package, files in files_by_package.items():\n with self.project.storage.stream(f\"{package_files_path}/{package}\") as reader:\n # sort files by offset to extract while streaming the bin file\n for pkgfile in sorted(files, key=lambda f: f.offset):\n logger.debug(f\"extracting {pkgfile.path}\")\n reader.skip_to(pkgfile.offset)\n fspath = self.project.storage.fspath(pkgfile.extract_path)\n with write_file_or_remove(fspath) as fout:\n if pkgfile.compressed:\n zobj = zlib.decompressobj(zlib.MAX_WBITS | 32)\n def writer(data):\n return fout.write(zobj.decompress(data))\n reader.copy(writer, pkgfile.size)\n fout.write(zobj.flush())\n else:\n reader.copy(fout.write, pkgfile.size)","def inspect(apath):\n\n files = []\n\n def inspect_into(curr_apath):\n handler = resolve_format(curr_apath)\n unpacker = HandlersFactory.get_handler(handler)\n _files = unpacker.files_list(curr_apath)\n for f in _files:\n # go into nested archive or compressed file\n if is_archive(f):\n _apath = unpacker.extract(curr_apath, f)\n inspect_into(_apath)\n\n else:\n files.append(f)\n\n inspect_into(apath)\n return files","def unpackToTemp(self,archive,fileNames,progress=None):\n if not fileNames: raise ArgumentError(_(\"No files to extract for %s.\") % archive.s)\n progress = progress or bolt.Progress()\n progress.state,progress.full = 0,len(fileNames)\n #--Dump file list\n out = self.tempList.open('w')\n out.write('\\n'.join(fileNames).encode('utf8'))\n out.close()\n #--Extract files\n self.clearTemp()\n apath = dirs['installers'].join(archive)\n command = '7z.exe x \"%s\" -y -o%s @%s' % (apath.s, self.tempDir.s, self.tempList.s)\n ins = os.popen(command,'r')\n reExtracting = re.compile('Extracting\\s+(.+)')\n extracted = []\n for line in ins:\n maExtracting = reExtracting.match(line)\n if maExtracting: \n extracted.append(maExtracting.group(1).strip())\n progress.plus()\n result = ins.close()\n if result:\n raise StateError(_(\"Extraction failed.\"))\n #ensure that no file is read only\n for thedir, subdirs, files in os.walk(self.tempDir.s):\n for f in files:\n os.chmod(os.path.join(thedir, f),stat.S_IWRITE)\n #--Done\n self.tempList.remove()","def _unpack_archive(self, dir, filters):\n ext = os.path.splitext(self.path)[1]\n if ext in [\".zip\", \".xpi\"]:\n if filters:\n raise GbpError(\"Can only filter tar archives: %s\", (ext, self.path))\n self._unpack_zip(dir)\n else:\n self._unpack_tar(dir, filters)","def _cat_multi_vol_zip(src, dst):\n concat_cmd = \"zip -s 0 {} --out {}\".format(src, dst)\n os.system(concat_cmd)","def Zip(args):\n parser = argparse.ArgumentParser(description=Zip.__doc__)\n parser.add_argument(\n '-r', dest='recursive', action='store_true',\n default=False,\n help='recurse into directories')\n parser.add_argument(\n '-q', dest='quiet', action='store_true',\n default=False,\n help='quiet operation')\n parser.add_argument('zipfile')\n parser.add_argument('filenames', nargs='+')\n options = parser.parse_args(args)\n\n src_files = []\n for filename in options.filenames:\n globbed_src_args = glob.glob(filename)\n if not globbed_src_args:\n if not options.quiet:\n print('zip warning: name not matched: %s' % filename)\n\n for src_file in globbed_src_args:\n src_file = os.path.normpath(src_file)\n src_files.append(src_file)\n if options.recursive and os.path.isdir(src_file):\n for root, dirs, files in os.walk(src_file):\n for dirname in dirs:\n src_files.append(os.path.join(root, dirname))\n for filename in files:\n src_files.append(os.path.join(root, filename))\n\n # zip_data represents a list of the data to be written or appended to the\n # zip_stream. It is a list of tuples:\n # (OS file path, zip path/zip file info, and file data)\n # In all cases one of the |os path| or the |file data| will be None.\n # |os path| is None when there is no OS file to write to the archive (i.e.\n # the file data already existed in the archive). |file data| is None when the\n # file is new (never existed in the archive) or being updated.\n zip_data = []\n new_files_to_add = [OSMakeZipPath(src_file) for src_file in src_files]\n zip_path_to_os_path_dict = dict((new_files_to_add[i], src_files[i])\n for i in range(len(src_files)))\n write_mode = 'a'\n if os.path.exists(options.zipfile):\n with zipfile.ZipFile(options.zipfile, 'r') as zip_stream:\n try:\n files_to_update = set(new_files_to_add).intersection(\n set(zip_stream.namelist()))\n if files_to_update:\n # As far as I can tell, there is no way to update a zip entry using\n # zipfile; the best you can do is rewrite the archive.\n # Iterate through the zipfile to maintain file order.\n write_mode = 'w'\n for zip_path in zip_stream.namelist():\n if zip_path in files_to_update:\n os_path = zip_path_to_os_path_dict[zip_path]\n zip_data.append((os_path, zip_path, None))\n new_files_to_add.remove(zip_path)\n else:\n file_bytes = zip_stream.read(zip_path)\n file_info = zip_stream.getinfo(zip_path)\n zip_data.append((None, file_info, file_bytes))\n except IOError:\n pass\n\n for zip_path in new_files_to_add:\n zip_data.append((zip_path_to_os_path_dict[zip_path], zip_path, None))\n\n if not zip_data:\n print('zip error: Nothing to do! (%s)' % options.zipfile)\n return 1\n\n with zipfile.ZipFile(options.zipfile, write_mode,\n zipfile.ZIP_DEFLATED) as zip_stream:\n for os_path, file_info_or_zip_path, file_bytes in zip_data:\n if isinstance(file_info_or_zip_path, zipfile.ZipInfo):\n zip_path = file_info_or_zip_path.filename\n else:\n zip_path = file_info_or_zip_path\n\n if os_path:\n st = os.stat(os_path)\n if stat.S_ISDIR(st.st_mode):\n # Python 2.6 on the buildbots doesn't support writing directories to\n # zip files. This was resolved in a later version of Python 2.6.\n # We'll work around it by writing an empty file with the correct\n # path. (This is basically what later versions do anyway.)\n zip_info = zipfile.ZipInfo()\n zip_info.filename = zip_path\n zip_info.date_time = time.localtime(st.st_mtime)[0:6]\n zip_info.compress_type = zip_stream.compression\n zip_info.flag_bits = 0x00\n zip_info.external_attr = (st[0] & 0xFFFF) << 16\n zip_info.CRC = 0\n zip_info.compress_size = 0\n zip_info.file_size = 0\n zip_stream.writestr(zip_info, '')\n else:\n zip_stream.write(os_path, zip_path)\n else:\n zip_stream.writestr(file_info_or_zip_path, file_bytes)\n\n if not options.quiet:\n if zip_path in new_files_to_add:\n operation = 'adding'\n else:\n operation = 'updating'\n zip_info = zip_stream.getinfo(zip_path)\n if (zip_info.compress_type == zipfile.ZIP_STORED or\n zip_info.file_size == 0):\n print(' %s: %s (stored 0%%)' % (operation, zip_path))\n elif zip_info.compress_type == zipfile.ZIP_DEFLATED:\n print(' %s: %s (deflated %d%%)' % (operation, zip_path,\n 100 - zip_info.compress_size * 100 / zip_info.file_size))\n\n return 0","def _zipfile_single_file_extract_worker(\n zip_file_path: Path,\n file_in_archive: zipfile.ZipInfo,\n destination_folder: Path,\n is_dir: bool,\n) -> Path:\n with _FastZipFileReader(zip_file_path) as zf:\n # assemble destination and ensure it exits\n destination_path = destination_folder / file_in_archive.filename\n\n if is_dir:\n destination_path.mkdir(parents=True, exist_ok=True)\n return destination_path\n desc = f\"decompressing {zip_file_path}:{file_in_archive.filename} -> {destination_path}\\n\"\n with zf.open(name=file_in_archive) as zip_fp, destination_path.open(\n \"wb\"\n ) as dest_fp, tqdm_logging_redirect(\n total=file_in_archive.file_size,\n desc=desc,\n **(\n _TQDM_FILE_OPTIONS\n | dict(miniters=_compute_tqdm_miniters(file_in_archive.file_size))\n ),\n ) as pbar:\n while chunk := zip_fp.read(_CHUNK_SIZE):\n dest_fp.write(chunk)\n pbar.update(len(chunk))\n return destination_path","def extract_file(source_path, destination_path):\n extender_tar = ['tar.gz', 'tar', 'gz']\n extender_zip = ['zip']\n\n extend = source_path.split('.')[-1]\n if extend in extender_tar:\n extract_tar(source_path, destination_path)\n elif extend in extender_zip:\n extract_zip(source_path, destination_path)","def extract_zip(\n fname: str, outfile: Optional[str] = None, concat: bool = False\n) -> Union[str, None]:\n if not outfile:\n outfile = fname[:-4]\n\n with ZipFile(fname, \"r\") as fzip, TemporaryDirectory() as tmpdir:\n fzip.extractall(path=tmpdir)\n fnames = glob(f\"{tmpdir}/*\")\n\n if len(fnames) > 1 and not concat:\n raise ValueError(\n \"Downloaded zip file contains multiple files, but concat is not specified!\"\n )\n\n # Concatenate (also works with one file)\n with open(outfile, \"w\") as out:\n for infile in fnames:\n for line in open(infile):\n out.write(line)\n\n os.unlink(fname)\n\n return outfile","def mass_extract(source_directory, target_directory):\n\n import os\n import ZipFile\n\n source_directory = raw_input(\"Where are the zips? \")\n target_directory = raw_input(\"To where do you want to extract the files? \")\n \n if not os.path.exists(source_directory):\n print \"Sorry, that folder doesn't seem to exist.\"\n source_directory = raw_input(\"Where are the zips? \")\n\n if not os.path.exists(target_directory):\n os.mkdir(target_directory)\n \n for path, directory, filename in os.walk(source_directory):\n zip_file = ZipFile.ZipFile(filenames)\n ZipFile.extract(zip_file, target_directory)\n zip_file.close()\n\n print \"Done.\"","async def extract(self, destination, entries=None, callback=None):\n # :param srcdestpairs: A list of 2-tuples where the first item\n # is the source path within the archive of a file to install,\n # and the second item is the path (relative to the mod\n # installation directory) where the source should be extracted.\n\n # TODO: ignore \"._\"-prefixed mac-cruft files\n loop = asyncio.get_event_loop()\n c=0\n # noinspection PyTypeChecker\n async for extracted in self.archiver.extract(\n archive=self.archive,\n destination=destination,\n specific_entries=entries,\n # callback=callback\n ):\n c+=1\n if callback:\n loop.call_soon_threadsafe(callback, extracted, c)\n self.LOGGER << f\"{c} files extracted\"\n\n # srcdestpairs = srcdestpairs,","def extract_tar_file(archive_path, output_dir, relative_to, extractors=None):\n if extractors is None:\n extractors = DEFAULT_EXTRACTORS\n\n current_platform = get_running_platform()\n if current_platform == PlatformEnum.WINDOWS:\n # Try to use 7-zip first\n sevenzip_cmd = extractors.get(ExtractorEnum.SEVENZIP)\n if sevenzip_cmd == USE_REGISTRY:\n sevenzip_cmd = str(_find_7z_by_registry())\n sevenzip_bin = _find_extractor_by_cmd(sevenzip_cmd)\n if sevenzip_bin is not None:\n _extract_tar_with_7z(sevenzip_bin, archive_path, output_dir, relative_to)\n return\n\n # Use WinRAR if 7-zip is not found\n winrar_cmd = extractors.get(ExtractorEnum.WINRAR)\n if winrar_cmd == USE_REGISTRY:\n winrar_cmd = str(_find_winrar_by_registry())\n winrar_bin = _find_extractor_by_cmd(winrar_cmd)\n if winrar_bin is not None:\n _extract_tar_with_winrar(winrar_bin, archive_path, output_dir, relative_to)\n return\n get_logger().warning(\n 'Neither 7-zip nor WinRAR were found. Falling back to Python extractor...')\n elif current_platform == PlatformEnum.UNIX:\n # NOTE: 7-zip isn't an option because it doesn't preserve file permissions\n tar_bin = _find_extractor_by_cmd(extractors.get(ExtractorEnum.TAR))\n if not tar_bin is None:\n _extract_tar_with_tar(tar_bin, archive_path, output_dir, relative_to)\n return\n else:\n # This is not a normal code path, so make it clear.\n raise NotImplementedError(current_platform)\n # Fallback to Python-based extractor on all platforms\n _extract_tar_with_python(archive_path, output_dir, relative_to)","def archive_folders(args, directory_list):\n # Archive each of the subfolders\n # If we haven't selected archive then we return immediately.\n if not args.archive:\n return\n\n # Otherwise a simple tar command should do\n tar_commands = []\n for directory in directory_list:\n tar_commands.append(\"tar -cf - %s --remove-files | pigz -9 -p 8 > %s.tar.gz\" %\n (directory, directory))\n\n # Multi-thread our tar command\n processes = (subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n for cmd in tar_commands)\n\n # We use the islice command to split our commands into five smaller lists.\n running_processes = list(itertools.islice(processes, args.num_threads))\n\n while running_processes:\n for i, process in enumerate(running_processes):\n if process.poll() is not None: # Means that the process is complete!\n stdout, stderr = process.communicate() # Get the output of the completed process\n if not stderr == \"\":\n print stderr\n running_processes[i] = next(processes, None)\n # Run the next number in the list.\n if running_processes[i] is None: # No more commands waiting to be processed.\n del running_processes[i] # Not a valid process.\n break","def compress_files(time_stamp, files_to_be_appended):\n process = subprocess.run([\"tar\", \"-czf\", f\"connect-log.{time_stamp}.tar.gz\", files_to_be_appended[0],\n files_to_be_appended[1],\n files_to_be_appended[2],\n files_to_be_appended[3], files_to_be_appended[4]], capture_output=True)","def extract_source(source_archive, target):\r\n with tarfile.open(source_archive) as tar_file:\r\n safetar_extractall(tar_file, target)","def archive_files(output_dir, output_dir_name):\n\n file_name = output_dir + \".tar.gz\"\n\n logger.info(\"Archiving files into %s\", file_name)\n with tarfile.open(file_name, \"w|gz\") as tar:\n tar.add(output_dir, arcname=output_dir_name)\n logger.info(\"Archived files into %s\", file_name)\n\n try:\n shutil.rmtree(output_dir)\n except OSError as ex:\n logger.warning(\"Failed to delete directory after archiving: %s\", ex)","def untar(archive):\n log.info('Unpacking archive \"%s\".' % archive)\n tar = module.params['tar']\n tar_extra_options = shlex.split(module.params['tar_extra_options'])\n if not tar:\n tar = module.get_bin_path('tar', required=True)\n if archive.endswith('.gz'):\n uncompress = 'z'\n elif archive.endswith('.bz2'):\n uncompress = 'j'\n else:\n raise ValueError('Unsupported compression type: %s' % archive)\n options = ''.join(['x', uncompress, 'f'])\n args = [tar, options] + tar_extra_options + [archive]\n rc, out, err = module.run_command(args)\n log.info('untar: rc=%d out=%s err=%s', rc, out, err)\n if rc != 0:\n raise ValueError('tar command failed: %d' % rc)","def _extract_archive(path: str, extracted_dir_path: str) -> str:\n logging.info('extracting %s to %s', path, extracted_dir_path)\n with tarfile.open(path) as tar:\n tar.extractall(path=extracted_dir_path)\n extracted_items = os.listdir(extracted_dir_path)\n if len(extracted_items) != 1:\n raise ValueError(\n 'archive at {} did not contain a single directory'.format(path))\n return os.path.join(extracted_dir_path, extracted_items[0])","def __extract_tgz(self):\n tar_file = tarfile.open(self.archive)\n try:\n extract_dir = tempfile.mkdtemp()\n archive_binaries_dir = self.__create_extraction_dir(\n tar_file.getnames(), extract_dir, tar_file.extract)\n finally:\n tar_file.close()\n return archive_binaries_dir, extract_dir","def extract_files(self) -> list:\n pass","def archive(filepath,archive_dir='archive'):\n\n # Make sure we have a directory to archive to\n try:\n mkdir(archive_dir)\n except:\n print(\"Error making archive directory\")\n return\n\n try:\n (dir, filename) = os.path.split(filepath)\n outfile = os.path.join(dir,archive_dir,filename)+'.gz'\n with open(filename, 'rb') as f_in, gzip.open(outfile, 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)\n except Exception as e:\n print(\"Error archiving \",filepath)\n print(e)\n else:\n try:\n os.remove(filepath)\n except:\n print(\"Error removing \",filepath)","def readArchiveFiles(self) -> 'ChartVersionInfo':\n if self._archiveFiles is not None:\n return self\n archiveFiles = {}\n try:\n with self.fileOpen() as tar_file:\n for tarinfo in tar_file.getmembers():\n if tarinfo.isreg():\n parsename = pathlib.PurePosixPath(tarinfo.name)\n if parsename.is_absolute():\n raise InputOutputError('All files in chart archive must be relative')\n basename = str(pathlib.PurePosixPath(*parsename.parts[1:]))\n if basename in ['Chart.yaml', 'Chart.lock', 'values.yaml', 'values.schema.json', 'requirements.yaml']:\n file = tar_file.extractfile(tarinfo.name)\n if file is None:\n raise InputOutputError('Could not read file \"{}\" from archive'.format(tarinfo.name))\n archiveFiles[basename] = file.read().decode('utf-8')\n except tarfile.TarError as e:\n raise InputOutputError(str(e)) from e\n self._archiveFiles = archiveFiles\n return self","def extract(self):\n if self.files:\n return dict((f, self.read_file(f)) for f in self.files)\n else:\n raise RuntimeError(\"Can't extract whole archive without listfile.\")","def _decompress_tarball(*, in_fileobj, out_fileobj):\n with tarfile.open(fileobj=in_fileobj, mode=\"r\") as it, tarfile.open(\n fileobj=out_fileobj, mode=\"w|\"\n ) as ot:\n for member in it.getmembers():\n extracted = it.extractfile(member)\n ot.addfile(member, extracted)","def extractAll(self, directory):\r\n if self._archive == None:\r\n raise StandardError(\"Archive was not open\")\r\n\r\n self._archive.extractall(directory)","def add_files(self, *paths, **kw):\n write_p = self._pointer\n\n block_size = ffi.write_get_bytes_per_block(write_p)\n if block_size <= 0:\n block_size = 10240 # pragma: no cover\n\n with new_archive_entry() as entry_p:\n entry = ArchiveEntry(None, entry_p)\n for path in paths:\n with new_archive_read_disk(path, **kw) as read_p:\n while 1:\n r = read_next_header2(read_p, entry_p)\n if r == ARCHIVE_EOF:\n break\n entry.pathname = entry.pathname.lstrip('/')\n read_disk_descend(read_p)\n write_header(write_p, entry_p)\n if entry.isreg:\n with open(entry_sourcepath(entry_p), 'rb') as f:\n while 1:\n data = f.read(block_size)\n if not data:\n break\n write_data(write_p, data, len(data))\n write_finish_entry(write_p)\n entry_clear(entry_p)","def main():\r\n parser = CommonArgParser(__file__)\r\n parser.add_argument('src_dir', help='Source directory')\r\n parser.add_argument(\r\n 'out_dir',\r\n default='.',\r\n help=\"\"\"The directory the files to be extracted.\r\n (Default: Current directoty\"\"\")\r\n args = parser.parse_all()\r\n for f in next_file(args.src_dir, ['*.tgz', '*.tar.gz']):\r\n untgz(f, args.out_dir)","def test(self, archive, files):\n self.log.info(\"Opening archive %s for testing.\" % (archive))\n tmpdir = tempfile.mkdtemp(dir='/tmp/')\n tar = tarfile.open(archive, 'r:gz')\n tar.extractall(tmpdir);\n tar.close()\n\n mtime = {}\n for file in files:\n mtime[file] = os.path.getmtime(file)\n # compare each file to its archived copy\n self.log.debug(\"Comparing files %s and %s\" % (file, tmpdir))\n diffdir = filecmp.dircmp(file, os.path.join(tmpdir, file));\n diffdir.report_full_closure();\n status = {}\n for i in ('left_only', 'right_only', 'diff_files'):\n if len(diffdir.__dict__[i]) > 0:\n status[i] = len(diffdir.__dict__[i])\n if len(status) > 0:\n raise RuntimeError (\"Archive contents do not match source files.\")\n return mtime","def find_archives(self):\n pattern = re.compile(r'^[0-9A-F]{40}\\.tar$', re.IGNORECASE)\n for entry in self.context.list_entries(self.cache_directory):\n if pattern.match(entry):\n yield os.path.join(self.cache_directory, entry)","def _zip_archive(extracted_source, exclude_files=None, **_):\n ctx.logger.debug(\"Zipping source {source}\".format(source=extracted_source))\n exclude_files = exclude_files or []\n ctx.logger.debug('Excluding files {l}'.format(l=exclude_files))\n with tempfile.NamedTemporaryFile(suffix=\".zip\",\n delete=False) as updated_zip:\n updated_zip.close()\n with zipfile.ZipFile(updated_zip.name,\n mode='w',\n compression=zipfile.ZIP_DEFLATED) as output_file:\n for dir_name, subdirs, filenames in os.walk(extracted_source):\n # Make sure that the files that we don't want\n # to include (e.g. plugins directory) will not be archived.\n exclude_dirs(dir_name, subdirs, exclude_files)\n for filename in filenames:\n # Extra layer of validation on the excluded files.\n if not exclude_file(dir_name, filename, exclude_files):\n # Create the path as we want to archive it to the\n # archivee.\n file_to_add = os.path.join(dir_name, filename)\n # The name of the file in the archive.\n if file_storage_breaker(file_to_add):\n continue\n arc_name = file_to_add[len(extracted_source)+1:]\n output_file.write(file_to_add, arcname=arc_name)\n archive_file_path = updated_zip.name\n return archive_file_path","def GetExtraFiles(self, extra_archive_paths, source_file_name):\n extra_files_list = []\n extra_path_list = extra_archive_paths.split(',')\n for path in extra_path_list:\n path = path.strip()\n source_file = os.path.join(self._src_dir, path, source_file_name)\n if os.path.exists(source_file):\n new_files_list = open(source_file).readlines()\n extra_files_list.extend(new_files_list)\n\n extra_files_list = [e.strip() for e in extra_files_list]\n extra_files_list = archive_utils.ExpandWildcards(self._build_dir,\n extra_files_list)\n return extra_files_list","async def unarchive_dir(\n archive_to_extract: Path,\n destination_folder: Path,\n *,\n max_workers: int = _MAX_UNARCHIVING_WORKER_COUNT,\n progress_bar: ProgressBarData | None = None,\n log_cb: Callable[[str], Awaitable[None]] | None = None,\n) -> set[Path]:\n if not progress_bar:\n progress_bar = ProgressBarData(steps=1)\n async with AsyncExitStack() as zip_stack:\n zip_file_handler = zip_stack.enter_context(\n zipfile.ZipFile( # pylint: disable=consider-using-with\n archive_to_extract,\n mode=\"r\",\n )\n )\n zip_stack.enter_context(logging_redirect_tqdm())\n process_pool = zip_stack.enter_context(\n non_blocking_process_pool_executor(max_workers=max_workers)\n )\n\n # running in process poll is not ideal for concurrency issues\n # to avoid race conditions all subdirectories where files will be extracted need to exist\n # creating them before the extraction is under way avoids the issue\n # the following avoids race conditions while unzippin in parallel\n _ensure_destination_subdirectories_exist(\n zip_file_handler=zip_file_handler,\n destination_folder=destination_folder,\n )\n\n futures: list[asyncio.Future] = [\n asyncio.get_event_loop().run_in_executor(\n process_pool,\n # ---------\n _zipfile_single_file_extract_worker,\n archive_to_extract,\n zip_entry,\n destination_folder,\n zip_entry.is_dir(),\n )\n for zip_entry in zip_file_handler.infolist()\n ]\n\n try:\n extracted_paths: list[Path] = []\n total_file_size = sum(\n zip_entry.file_size for zip_entry in zip_file_handler.infolist()\n )\n async with AsyncExitStack() as progress_stack:\n sub_prog = await progress_stack.enter_async_context(\n progress_bar.sub_progress(steps=total_file_size)\n )\n tqdm_progress = progress_stack.enter_context(\n tqdm.tqdm(\n desc=f\"decompressing {archive_to_extract} -> {destination_folder} [{len(futures)} file{'s' if len(futures) > 1 else ''}\"\n f\"/{_human_readable_size(archive_to_extract.stat().st_size)}]\\n\",\n total=total_file_size,\n **_TQDM_MULTI_FILES_OPTIONS,\n )\n )\n for future in asyncio.as_completed(futures):\n extracted_path = await future\n extracted_file_size = extracted_path.stat().st_size\n if tqdm_progress.update(extracted_file_size) and log_cb:\n with log_catch(log, reraise=False):\n await log_cb(f\"{tqdm_progress}\")\n await sub_prog.update(extracted_file_size)\n extracted_paths.append(extracted_path)\n\n except Exception as err:\n for f in futures:\n f.cancel()\n\n # wait until all tasks are cancelled\n await asyncio.wait(\n futures, timeout=2 * _MIN, return_when=asyncio.ALL_COMPLETED\n )\n\n # now we can cleanup\n if destination_folder.exists() and destination_folder.is_dir():\n await remove_directory(destination_folder, ignore_errors=True)\n\n raise ArchiveError(\n f\"Failed unarchiving {archive_to_extract} -> {destination_folder} due to {type(err)}.\"\n f\"Details: {err}\"\n ) from err\n\n # NOTE: extracted_paths includes all tree leafs, which might include files and empty folders\n return {\n p\n for p in extracted_paths\n if p.is_file() or (p.is_dir() and not any(p.glob(\"*\")))\n }","def download_and_extract(path, url, input_filename, target_filename):\n logging.info('Downloading and extracting data to: %s' % path)\n # Check if extracted files already exist in path\n input_file = find_file(path, input_filename)\n target_file = find_file(path, target_filename)\n if input_file and target_file:\n logging.info(\"Already downloaded and extracted %s.\" % url)\n return input_file, target_file\n\n # Download archive file if it doesn't already exist.\n compressed_file = download_from_url(path, url)\n\n # Extract compressed files\n logging.info(\"Extracting %s.\" % compressed_file)\n with tarfile.open(compressed_file, \"r:gz\") as corpus_tar:\n corpus_tar.extractall(path)\n\n # Return filepaths of the requested files.\n input_file = find_file(path, input_filename)\n target_file = find_file(path, target_filename)\n\n if input_file and target_file:\n return input_file, target_file\n\n raise OSError(\"Download/extraction failed for url %s to path %s\" %\n (url, path))","def extract_all(tarobj):\n for member in tarobj.getmembers():\n tarobj.extract(member)","def extract_data(archive: ZipFile, dir_name: str) -> Data:\n with archive.open(f\"{dir_name}/caption.txt\", \"r\") as f:\n captions = f.readlines()\n data = []\n for line in captions:\n tmp = line.decode().strip().split()\n img_name = tmp[0]\n formula = tmp[1:]\n with archive.open(f\"{dir_name}/{img_name}.bmp\", \"r\") as f:\n # move image to memory immediately, avoid lazy loading, which will lead to None pointer error in loading\n img = Image.open(f).copy()\n data.append((img_name, img, formula))\n\n print(f\"Extract data from: {dir_name}, with data size: {len(data)}\")\n\n return data","def unpackArchive(source, filter = None, encoding = None):\n \n primaryArchiveFile = open(source, \"rb\")\n header = readHeader(primaryArchiveFile)\n version, dataOffset, archiveFileCount, fileTableLength, endianness, fileCount = header\n \n # open all other archive files\n archiveFiles = [primaryArchiveFile]\n sourceRoot, sourceExt = os.path.splitext(source)\n for i in range(1, archiveFileCount):\n path = \"%s_%d%s\" % (sourceRoot, i, sourceExt)\n archiveFiles.append(open(path, \"rb\"))\n \n fileTable = readFileTable(primaryArchiveFile, header)\n for fileRecord in fileTable:\n path, offset, size, compressedSize, archiveFileIndex = fileRecord\n \n if callable(filter) and not filter(fileRecord): continue\n \n if archiveFileIndex == 0:\n offset += dataOffset\n \n archiveFile = archiveFiles[archiveFileIndex]\n archiveFile.seek(offset)\n \n if compressedSize != 0:\n fileData = zlib.decompress(archiveFile.read(compressedSize))\n else:\n fileData = archiveFile.read(size)\n \n if encoding is not None:\n fileData = fileData.decode(encoding)\n \n print('Extracted file \"%s\" (%u bytes)' % (path, size))\n yield fileRecord, fileData\n \n for f in archiveFiles:\n f.close()","def _extract(self, file_path):\n self._log.debug(\"Extracting file {!r}\".format(\n os.path.basename(file_path)\n ))\n tar = tarfile.open(file_path, \"r:gz\")\n tar.extractall(os.path.dirname(file_path))\n tar.close()","def archive_logs():\n logging.info('Archive start...')\n\n for log_dir in filter(dir_filter, os.listdir('logs')):\n path = 'logs/{}'.format(log_dir)\n archive_files = filter(lambda x: '.log.' in x, os.listdir(path))\n zip_file_name = '{}/{}.zip'.format(\n path,\n str(datetime.now())\n .replace(' ', '_').replace('.', '_').replace(':', '_'))\n zip_file = zipfile.ZipFile(\n zip_file_name, mode='w', compression=zipfile.ZIP_DEFLATED)\n for f in archive_files:\n log_file = '{}/{}'.format(path, f)\n zip_file.write(log_file)\n os.remove(log_file)\n\n logging.info('Archive end.')","def archive(self, files, name):\n self.log.debug(\"Putting files into archive: %s\" % \"\\n\".join(files))\n tar_name = \"%s%s\" % (name, self.extension)\n if os.path.exists(tar_name):\n raise RuntimeError (\"Tried to create an archive that already exists: %s\" % tar_name) \n else:\n self.log.info(\"Creating a new archive %s\" % tar_name)\n tar = tarfile.open(tar_name, 'w:gz');\n for name in files:\n tar.add(name)\n print '%s'% (name)\n tar.close()\n return tar_name","def files_in_archive(fd: BinaryIO) -> Iterable[int]:\n\n _check_next_bytes(fd, ARCHIVE_MAGIC, 'archive magic number')\n\n while True:\n # In some archives, the first file ends with an additional \\n. If that\n # is present, skip it.\n if fd.read(1) != b'\\n':\n fd.seek(-1, 1)\n\n # Each file in an archive is prefixed with an ASCII header:\n #\n # 16 B - file identifier (text)\n # 12 B - file modification timestamp (decimal)\n # 6 B - owner ID (decimal)\n # 6 B - group ID (decimal)\n # 8 B - file mode (octal)\n # 10 B - file size in bytes (decimal)\n # 2 B - ending characters (`\\n)\n #\n # Skip the unused portions of the file header, then read the size.\n fd.seek(16 + 12 + 6 + 6 + 8, 1)\n size_str = fd.read(10)\n if not size_str:\n return\n\n try:\n size = int(size_str, 10)\n except ValueError as exc:\n raise FileDecodeError(\n 'Archive file sizes must be decimal integers') from exc\n\n _check_next_bytes(fd, b'`\\n', 'archive file header ending')\n offset = fd.tell() # Store offset in case the caller reads the file.\n\n yield size\n\n fd.seek(offset + size)","def handle_tar(file_path, extension, extracted_path, destination_directory):\n tar = tarfile.open(file_path, extension)\n # remove files if they already exist\n if os.path.exists(extracted_path):\n shutil.rmtree(extracted_path)\n tar.extractall(path=destination_directory)\n tar.close()","def import_archive(archive, content_type=None):\n if content_type == \"text/xml\":\n import_report(archive.read())\n elif content_type in [\"application/gzip\", \"application/octet-stream\"]:\n with gzip.GzipFile(mode=\"r\", fileobj=archive) as zfile:\n import_report(zfile.read())\n else:\n with zipfile.ZipFile(archive, \"r\") as zfile:\n for fname in zfile.namelist():\n import_report(zfile.read(fname))","def main(args):\n\n for dir in args.dirs:\n # prepdir = mdssprep.Directory(dir,exclude=['file_*3*','file_2??'],include=['file_*5*'],maxarchivesize=mdssprep.one_meg*200.,minsize=mdssprep.one_meg*100.)\n prepdir = mdssprep.Directory(dir)\n prepdir.archive(dryrun=False)","def _ExtractFiles(self, tgz_path: str, path_to_collect: str) -> str:\n local_path = ''\n if not os.path.exists(tgz_path):\n self.logger.error(f'File not found {tgz_path}')\n return local_path\n\n tempdir = tempfile.mkdtemp()\n with tarfile.open(tgz_path) as file:\n members = self._FilterTarMembers(file, path_to_collect)\n file.extractall(path=tempdir, members=members)\n\n local_path = os.path.join(tempdir, path_to_collect.lstrip('/'))\n return local_path","def _unpack_archive(self):\n with zipfile.ZipFile(self._archive_full_path, 'r') as zip_ref:\n zip_ref.extractall(self._storage_path)\n\n _logger.debug('Archive has been unpacked.')","async def archive_contents(self, *, dirs=True, files=True):\n if self.archive_files is None:\n self.archive_dirs, self.archive_files = \\\n await self.archiver.list_archive(self.archive)\n\n if not dirs and not files:\n # if both are false, that's dumb. set both true.\n dirs = files = True\n\n if dirs:\n for f in self.archive_dirs:\n yield f\n if files:\n for f in self.archive_files:\n yield f\n\n # if dirs and not files:\n # return self.archive_dirs\n # if files and not dirs:\n # return self.archive_files\n\n # otherwise return concat of both (even if `dirs` and `files`\n # are both false...because that's dumb)\n # return self.archive_dirs + self.archive_files","def get_archive(katfilenames):\n\timport requests\n\n\tfile_refs = []\n\tfor filename in katfilenames:\n\t\tif filename.startswith('s3'):\n\t\t\tres = requests.post(S3_URL, headers=S3_HEAD, data='{\"s3_ref\":\"%s\",\"ref_key\":\"Nope\"}'%(filename,))\n\t\t\turl = res.json()['url']\n\t\t\tres1 = requests.get(url)\n\t\t\toutfile = filename.split('/')[-1]\n\t\t\topen(outfile, 'wb').write(res1.content)\n\t\t\tfile_refs.append(outfile)\n\t\telse:\n\t\t\tfile_refs.append(filename)\n\treturn file_refs","def unpack(file_path, extraction_path, remove):\n print(file_path)\n Archive(file_path).extractall(extraction_path, auto_create_dir=True)\n # remove original compressed file???\n if remove is True:\n os.remove(file_path)","def cleanup(self, archive, files):\n mtime = self.test(archive, files)\n backup_home = os.path.join(self.download_dir, '-')\n if not os.path.exists(backup_home):\n os.makedirs(backup_home)\n backup_dir = tempfile.mkdtemp('', datetime.utcnow().strftime(\"%Y-%m-%d_\"), backup_home)\n for file in files:\n os.makedirs(os.path.join(backup_dir, file))\n if os.path.getmtime(file) != mtime[file]:\n raise RuntimeError(\"Failed to cleanup archived data: %s has been modified.\" % file)\n os.rename(file, os.path.join(backup_dir, file))\n self.log.debug(\"Moved %s to %s\" % (file, os.path.join(backup_dir, file)))\n return","def extract_zip(filename, target_dir, logger=None):\n logger = logger or Logger()\n import zipfile\n logger.log(\"Extracting from zip archive %s\" % filename, level=1)\n zip_archive = None\n try:\n zip_archive = zipfile.ZipFile(open(filename, mode='r'))\n member_names = zip_archive.namelist()\n # manually extract files since extractall is only in python 2.6+\n# zip_archive.extractall(target_dir)\n for f in member_names:\n if f.endswith('/'):\n dst = \"%s/%s\" % (target_dir, f)\n mkdir_p(dst)\n for f in member_names:\n if not f.endswith('/'):\n path = \"%s/%s\" % (target_dir, f)\n with open(path, 'wb') as dest_file:\n dest_file.write(zip_archive.read(f))\n return member_names\n finally:\n if zip_archive is not None:\n zip_archive.close()","def cat_files(files, output):\n for file in files:\n with open(file, 'r') as fd:\n shutil.copyfileobj(fd, output)","def cat_files(files, output):\n for file in files:\n with open(file, 'r') as fd:\n shutil.copyfileobj(fd, output)","def zipfiles (downloadable, name):\n\n print \"compressing files. almost done.\"\n import zipfile\n for book in downloadable:\n if (os.path.exists(os.path.join(name, book[1]))):\n files = os.listdir(os.path.join(name, book[1]))\n cbz = zipfile.ZipFile(os.path.join(name, name + '-' + book[1] + '.cbz'), 'w')\n for file in files:\n cbz.write(os.path.join(name, book[1],file))\n cbz.close()","def __extract_zip(self):\n archive_binaries_dir = None\n zip_file = zipfile.ZipFile(self.archive)\n try:\n extract_dir = tempfile.mkdtemp()\n archive_binaries_dir = self.__create_extraction_dir(\n zip_file.namelist(), extract_dir, zip_file.extract)\n finally:\n zip_file.close()\n return archive_binaries_dir, extract_dir","def extractZipFiles(rootDir, zipDir):\n for root, dirs, files in os.walk(zipDir, topdown=False):\n for name in files:\n \n zipFiles = os.path.join(root, name)\n \n #Check file extension here\n if \".zip\" not in zipFiles:\n continue\n \n else:\n zipPath = zipfile.ZipFile(zipFiles, 'r')\n #print(zipPath) \n \n filesInZip = zipPath.namelist()\n i = 0 \n for i in range(len(filesInZip)):\n #print(filesInZip[i])\n #print(zipPath.getinfo(filesInZip[i]))\n \n if \".mp3\" in filesInZip[i]:\n zipPath.extract(filesInZip[i], rootDir)\n print(\"{0} extracted to {1}\".format(filesInZip[i], rootDir))\n\n elif \".m4a\" in filesInZip[i]:\n zipPath.extract(filesInZip[i], rootDir)\n print(\"{0} extracted to {1}\".format(filesInZip[i], rootDir))\n\n elif \".mp4\" in filesInZip[i]:\n zipPath.extract(filesInZip[i], rootDir)\n print(\"{0} extracted to {1}\".format(filesInZip[i], rootDir))\n\n elif \".png\" in filesInZip[i]:\n zipPath.extract(filesInZip[i], rootDir)\n print(\"{0} extracted to {1}\".format(filesInZip[i], rootDir))\n\n elif \".jpg\" in filesInZip[i]:\n zipPath.extract(filesInZip[i], rootDir)\n print(\"{0} extracted to {1}\".format(filesInZip[i], rootDir))\n \n elif \".pdf\" in filesInZip[i]:\n zipPath.extract(filesInZip[i], rootDir)\n print(\"{0} extracted to {1}\".format(filesInZip[i], rootDir))\n\n else:\n print(\"No media found in zip file {0}\".format(name))\n \n zipPath.close()","def write_zip_content(content, out_path):\n textract_ext = ('.doc', '.docx', '.epub', '.gif', '.htm', '.html', '.odt', '.pdf', '.rtf', '.txt')\n z = zipfile.ZipFile(BytesIO(content))\n unzipped_file_list = z.filelist\n if not unzipped_file_list:\n # if the archive's corrupted, this list is empty\n return\n try:\n z.extractall(out_path)\n except RuntimeError:\n # occurs on password protected archives\n return\n file_list = []\n for f in unzipped_file_list:\n try:\n file_name = f.filename\n if not file_name.endswith('/'):\n file_out_path = os.path.join(out_path, file_name)\n if file_out_path.endswith(textract_ext):\n file_list.append(file_out_path)\n else:\n # capturing as non-machine\n file_list.append(file_out_path)\n except AttributeError:\n pass\n file_list = [os.path.join(out_path, os.path.basename(f)) for f in file_list]\n\n return file_list","def unpack_dir(indir, outdir, bands=None, clouds=None):\r\n archives = glob.glob(indir + '*.tar.gz')\r\n count = len(archives)\r\n for idx, archive in enumerate(archives):\r\n # Determine the outpath directory name for the unpacked landsat archive\r\n unpackDir = outdir + os.path.splitext(os.path.split(\r\n os.path.splitext(archive)[0])[1])[0]\r\n\r\n # Check if the directory already exists and make it if it doesn't\r\n if not os.path.exists(unpackDir):\r\n os.makedirs(unpackDir)\r\n\r\n # Unpack the current archive.\r\n unpack_landsat(archive, unpackDir, bands=bands,clouds=clouds)\r\n\r\n # Let the user know how progress is going.\r\n print(archive + ' unpacked (' + str(idx + 1) + ' of ' + str(count) + ')')","def untar(filepath, outfoldername='.', compression='r', deletesource=False):\n import tarfile\n\n with tarfile.open(filepath, compression) as tfile:\n filelist = tfile.getnames()\n tfile.extractall(path=outfoldername)\n\n if deletesource:\n try:\n os.remove(filepath)\n except:\n raise Exception(\"Could not delete tar archive {0}.\".format(filepath))\n\n return filelist","def files_list(cls, url, apath, ffilter=[]):\n files = []\n\n if apath not in cls._archives.keys():\n cls._download(url, apath)\n\n _files = inspect(apath)\n\n for f in _files:\n if is_matched(f, ffilter):\n files.append(f)\n\n return files","def concatenate_files(self, files):\n entries = []\n for f in files:\n tree = ETree.parse(f)\n\n root = tree.getroot()\n entries = root.findall(tags[\"entry\"])\n\n for entry in entries:\n yield entry","def contents(archive_id):\n files = config.index.files(archive_id=archive_id)\n print_files(files)","def zip_repo(src_path, dest_path):\n tar = tarfile.open(dest_path, \"w:gz\")\n for file_name in glob.glob(os.path.join(src_path, \"*\")):\n tar.add(file_name, os.path.basename(file_name))\n\n tar.close()","def get_all_compressed_files_in_directory(directory: str):\n\n all_files_and_folders = os.listdir(directory)\n\n only_compressed_files = []\n for file in all_files_and_folders:\n if '.zip' in file or '.7z' in file:\n only_compressed_files.append(file)\n ...\n\n return only_compressed_files","def unpackToProject(self,archive,project,progress=None):\n progress = progress or bolt.Progress()\n files = self.sortFiles([x[0] for x in self.fileSizeCrcs])\n if not files: return 0\n #--Clear Project\n destDir = dirs['installers'].join(project)\n if destDir.exists(): destDir.rmtree(safety='Installers')\n #--Extract\n progress(0,project.s+_(\"\\nExtracting files...\"))\n self.unpackToTemp(archive,files,SubProgress(progress,0,0.9))\n #--Move\n progress(0.9,project.s+_(\"\\nMoving files...\"))\n count = 0\n tempDir = self.tempDir\n for file in files:\n srcFull = tempDir.join(file)\n destFull = destDir.join(file)\n if srcFull.exists():\n srcFull.moveTo(destFull)\n count += 1\n self.clearTemp()\n return count","def archives(self, **kwargs):\n return self.session.listArchives(**kwargs)","def select_archive(self, recursive=True): # pragma: no cover\n return self.select_by_ext(self._archive_ext, recursive)","def unpack_archive(\n filepath: types.PathLike, *, extract_dir: Optional[types.PathLike] = None\n) -> types.PathLike:\n filepath = utils.to_path(filepath).resolve()\n if not extract_dir:\n extract_dir = str(filepath.parent)\n filepath = str(filepath)\n os.makedirs(extract_dir, exist_ok=True)\n is_zipfile = zipfile.is_zipfile(filepath)\n is_tarfile = tarfile.is_tarfile(filepath)\n if not is_zipfile and not is_tarfile:\n LOGGER.debug(\"'%s' is not an archive\", filepath)\n return extract_dir\n else:\n LOGGER.info(\"extracting data from archive file '%s'\", filepath)\n shutil.unpack_archive(filepath, extract_dir=extract_dir, format=None)\n # we want to rename the unpacked directory to a consistent value\n # unfortunately, shutil doesn't pass this back to us\n # so, we get the root path of all the constituent members\n if is_zipfile:\n with zipfile.ZipFile(filepath, mode=\"r\") as zf:\n members = zf.namelist()\n else:\n with tarfile.open(filepath, mode=\"r\") as tf:\n members = tf.getnames()\n src_basename = os.path.commonpath(members)\n dest_basename = os.path.basename(filepath)\n if src_basename:\n while True:\n tmp, _ = os.path.splitext(dest_basename)\n if tmp == dest_basename:\n break\n else:\n dest_basename = tmp\n if src_basename != dest_basename:\n return shutil.move(\n os.path.join(extract_dir, src_basename),\n os.path.join(extract_dir, dest_basename),\n )\n else:\n return os.path.join(extract_dir, src_basename)\n else:\n return extract_dir"],"string":"[\n \"def extract(apath, ffilter=[]):\\n\\n files = []\\n\\n def extract_recursive(curr_apath):\\n \\\"\\\"\\\"Look into archive recursively to extract files considering ffilter\\\"\\\"\\\"\\n\\n handler = resolve_format(curr_apath)\\n unpacker = HandlersFactory.get_handler(handler)\\n _files = unpacker.files_list(curr_apath)\\n\\n for f in _files:\\n if is_matched(f, ffilter=ffilter):\\n _fpath = unpacker.extract(curr_apath, f)\\n files.append(_fpath)\\n if is_archive(f):\\n _apath = unpacker.extract(curr_apath, f)\\n extract_recursive(_apath)\\n\\n extract_recursive(apath)\\n return files\",\n \"def extract_tars(file_pattern, path_in, path_out):\\n for f in glob.glob(os.path.join(path_in, file_pattern)):\\n shutil.unpack_archive(f, path_out)\",\n \"def extract_one(self, archive: Path, dest: Path):\\n if dest.exists():\\n shutil.rmtree(dest)\\n\\n dest.mkdir(parents=True)\\n\\n if self.should_use_libarchive_c:\\n import libarchive\\n\\n old_cwd = os.getcwd()\\n os.chdir(str(dest))\\n try:\\n libarchive.extract_file(str(archive))\\n finally:\\n os.chdir(old_cwd)\\n return\\n\\n if archive.name.endswith(EXTENSION_ZIP):\\n with zipfile.ZipFile(archive) as zf:\\n zf.extractall(dest)\\n elif archive.name.endswith(EXTENSION_TAR):\\n mode = \\\"r:bz2\\\" if archive.name.endswith(\\\".bz2\\\") else \\\"r:gz\\\"\\n with tarfile.open(archive, mode) as tf:\\n self.safe_extract_all(tf, dest)\\n else:\\n raise ValueError(f\\\"Unrecognized archive format {archive.name}\\\")\\n\\n for path in [dest, *dest.rglob(\\\"*\\\")]:\\n path.chmod(MOD_DIRECTORY if path.is_dir() else MOD_FILE)\",\n \"def extract_all(fn,dst=\\\".\\\"):\\r\\n if tarfile.is_tarfile(fn): \\r\\n with tarfile.open(fn,'r') as tf:\\r\\n tf.extractall(dst)\\r\\n tf.close()\\r\\n elif zipfile.is_zipfile(fn):\\r\\n with zipfile.ZipFile(fn, 'r') as zf:\\r\\n zf.extractall(dst)\\r\\n zf.close()\\r\\n else:\\r\\n print( \\\"Please provide a tar archive file or zip file\\\" )\",\n \"def extract(self, archive_path: str, extracted_path: str) -> None:\\n if not os.listdir(archive_path):\\n self.log.warning(\\n \\\"No files found in directory: {}\\\".format(archive_path))\\n return\\n\\n for root, _, archive_files in os.walk(archive_path):\\n if not archive_files:\\n continue\\n\\n extract_to = os.path.normpath(os.path.join(\\n extracted_path,\\n os.path.relpath(root, archive_path)\\n ))\\n if not os.path.isdir(extract_to):\\n os.makedirs(extract_to)\\n\\n for zfile in archive_files:\\n zfile = os.path.join(root, zfile)\\n filename, ext = os.path.splitext(os.path.basename(zfile))\\n # unzip (tree) each archive file in archive_path\\n if ext in self.zip_ext:\\n # double splitext for .tar.gz\\n fname, ext = os.path.splitext(os.path.basename(filename))\\n if ext == '.tar':\\n filename = fname\\n self.log.info(\\\"Extracting from: {}\\\".format(zfile))\\n self.log.info(\\\" Extracting to: {}\\\".format(\\n os.path.join(extract_to, filename)))\\n unzip(\\n zfile,\\n extract_to,\\n zip_ext=self.zip_ext,\\n create_own_folder=True,\\n tree=True\\n )\\n\\n # move each non-archive file in archive_path\\n else:\\n dest = os.path.join(extract_to, os.path.basename(zfile))\\n self.log.info(\\\"Copying from: {}\\\".format(zfile))\\n self.log.info(\\\" Copying to: {}\\\".format(dest))\\n shutil.copy(zfile, dest)\",\n \"def archive_files(archive_fileprefix, flist, zip_type, reldir, prefix=\\\"\\\"):\\n def archive_filter(tinfo):\\n fdir, fbase = os.path.split(tinfo.name)\\n archpath = os.path.join(prefix, os.path.relpath(tinfo.name, reldir))\\n tinfo.name = archpath\\n return tinfo\\n write_type = 'w:'+zip_type\\n\\n if zip_type:\\n archive_filename = '{}.tar.{}'.format(archive_fileprefix, zip_type)\\n else:\\n archive_filename = '{}.tar'.format(archive_fileprefix)\\n\\n with tarfile.open(archive_filename, write_type) as out_file:\\n for f in flist:\\n out_file.add(f, filter=archive_filter)\",\n \"def unpack(archive: Union[Path, str],\\n cwd: Optional[Path] = None,\\n files: Optional[List[Union[Path, str]]] = ()):\\n archive = Path(archive)\\n if cwd is None:\\n cwd = Path.cwd()\\n if files:\\n files = ['--'] + list(files)\\n else:\\n files = []\\n\\n # Try to make symlink usage easier in Windows.\\n extra_env = {\\n 'MSYS': 'winsymlinks:nativestrict',\\n }\\n\\n logging.info('Unpacking %s', archive.name)\\n # We use relpath here to help out tar on platforms where it doesn't like\\n # paths with colons in them (e.g. Windows). We have to construct the full\\n # before running through relpath as relative archives will implicitly be\\n # checked against os.getcwd rather than the explicit cwd.\\n src = os.path.relpath(cwd / archive, cwd)\\n run(['tar', '--no-same-owner', '-xf', src] + files, cwd=cwd,\\n extra_env=extra_env)\",\n \"def extractall(self, *args, **kwargs):\\n self.zipfile.extractall(*args, **kwargs)\",\n \"def unpack_archive(self, archive_name):\\n archive = zipfile.ZipFile(\\n os.path.join(\\n self.current_path,\\n os.path.split(self.exe_file)[0],\\n archive_name\\n )\\n )\\n\\n self.extraction_path = os.getcwd()\\n\\n archive.extractall(self.extraction_path)\\n\\n self.rename_main_script()\\n\\n archive_pyc_files = []\\n\\n for path, dirs, files in os.walk(self.extraction_path):\\n for f in files:\\n archive_pyc_files.append(os.path.join(path, f))\\n\\n return archive_pyc_files\",\n \"def unpackArchiveToFiles(source, target = None, filter = None):\\n if target is None:\\n target, _ = os.path.split(source)\\n \\n for fileRecord, fileData in unpackArchive(source, filter):\\n path, offset, size, compressedSize, archiveFileIndex = fileRecord\\n \\n outPath = os.path.join(target, path)\\n outHead, outTail = os.path.split(outPath)\\n os.makedirs(outHead, exist_ok = True)\\n outFile = open(outPath, \\\"wb\\\")\\n outFile.write(fileData)\\n outFile.close()\",\n \"def extract(archive_path, images_dir, test_zip=False):\\n log(\\\"TRACE\\\", \\\"Attempting to extracted files from {}\\\".format(archive_path))\\n with zipfile.ZipFile(archive_path) as images_zip:\\n # Check that the Zip file is valid, in which case `testzip()` returns\\n # None. If it's bad, that function will return a list of bad files\\n try:\\n if test_zip and images_zip.testzip():\\n log(\\\"ERROR\\\", \\\"Could not extract the following invalid Zip file:\\\"\\n \\\" {}\\\".format(archive_path))\\n return []\\n except OSError:\\n log(\\\"ERROR\\\", \\\"Could not extract the following invalid Zip file:\\\"\\n \\\" {}\\\".format(archive_path))\\n return []\\n images_zip.extractall(images_dir)\\n archive_namelist = images_zip.namelist()\\n log(\\\"TRACE\\\", \\\"Extracted files: {}\\\".format(archive_namelist))\\n return archive_namelist\",\n \"def _extract_archive(file_path, path='.', archive_format='auto'):\\n if archive_format is None:\\n return False\\n if archive_format == 'auto':\\n archive_format = ['tar', 'zip']\\n if isinstance(archive_format, str):\\n archive_format = [archive_format]\\n\\n file_path = path_to_string(file_path)\\n path = path_to_string(path)\\n\\n for archive_type in archive_format:\\n if archive_type == 'tar':\\n open_fn = tarfile.open\\n is_match_fn = tarfile.is_tarfile\\n if archive_type == 'zip':\\n open_fn = zipfile.ZipFile\\n is_match_fn = zipfile.is_zipfile\\n\\n if is_match_fn(file_path):\\n with open_fn(file_path) as archive:\\n try:\\n archive.extractall(path)\\n except (tarfile.TarError, RuntimeError, KeyboardInterrupt):\\n if os.path.exists(path):\\n if os.path.isfile(path):\\n os.remove(path)\\n else:\\n shutil.rmtree(path)\\n raise\\n return True\\n return False\",\n \"def extractFiles(self, archivePath, extractedFiles, filterList = None, ignoreList = None, isExtractingToCurrentDirectory = False, outputMessage = None):\\r\\n archiveNameWithoutExtension = os.path.splitext(os.path.split(archivePath)[1])[0]\\r\\n archivePathWithoutName = os.path.split(archivePath)[0]\\r\\n\\r\\n if isExtractingToCurrentDirectory:\\r\\n directoryToExtractTo = os.path.realpath(os.path.join(archivePathWithoutName, archiveNameWithoutExtension))\\r\\n else:\\r\\n directoryToExtractTo = os.path.realpath(os.path.join(self.tempDirectory, archiveNameWithoutExtension))\\r\\n \\r\\n try:\\r\\n with zipfile.ZipFile(archivePath, 'r') as zip:\\r\\n for name in zip.namelist():\\r\\n if EtFile.isIgnoredFile(name, filterList, ignoreList):\\r\\n continue\\r\\n\\r\\n pathToExtractedFile = os.path.realpath(os.path.join(directoryToExtractTo, name))\\r\\n if not pathToExtractedFile.startswith(directoryToExtractTo):\\r\\n # Files inside of zip archives can be maliciously named to cause writing to unexpected locations. All versions\\r\\n # of python prior to 2.7.4 are vulnerable to this sort of attack. Therefore, we must manually guarantee\\r\\n # that all writes are to our temporary directory.\\r\\n raise Exception(\\\"Security warning: Blocked directory traversal when extracting: '{}'\\\".format(name))\\r\\n\\r\\n zip.extract(name, directoryToExtractTo)\\r\\n \\r\\n if os.path.splitext(pathToExtractedFile)[1].lower() == \\\".zip\\\":\\r\\n self.extractFiles(pathToExtractedFile, extractedFiles, filterList, ignoreList, True, outputMessage)\\r\\n else:\\r\\n extractedFiles.append(pathToExtractedFile)\\r\\n except zipfile.BadZipfile:\\r\\n outputMessage(\\\"BadZipfile: \\\" + archivePath)\",\n \"def _extract_archive(file_path, path='.', archive_format='auto'):\\n if archive_format is None:\\n return False\\n if archive_format is 'auto':\\n archive_format = ['tar', 'zip']\\n if isinstance(archive_format, six.string_types):\\n archive_format = [archive_format]\\n\\n for archive_type in archive_format:\\n if archive_type is 'tar':\\n open_fn = tarfile.open\\n is_match_fn = tarfile.is_tarfile\\n if archive_type is 'zip':\\n open_fn = zipfile.ZipFile\\n is_match_fn = zipfile.is_zipfile\\n\\n if is_match_fn(file_path):\\n with open_fn(file_path) as archive:\\n # check weather extracted or not\\n extracted = True\\n for fname in archive.getnames():\\n if not os.path.exists(os.path.join(path, fname)):\\n extracted = False\\n if not extracted:\\n try:\\n archive.extractall(path)\\n print('extracted to', path)\\n except (tarfile.TarError, RuntimeError,\\n KeyboardInterrupt):\\n if os.path.exists(path):\\n if os.path.isfile(path):\\n os.remove(path)\\n else:\\n shutil.rmtree(path)\\n raise\\n return True\\n return False\",\n \"def _extract_archive(file_path, path='.', archive_format='auto'):\\n if archive_format is None:\\n return False\\n if archive_format == 'auto':\\n archive_format = ['tar', 'zip']\\n if isinstance(archive_format, six.string_types):\\n archive_format = [archive_format]\\n\\n for archive_type in archive_format:\\n if archive_type == 'tar':\\n open_fn = tarfile.open\\n is_match_fn = tarfile.is_tarfile\\n if archive_type == 'zip':\\n open_fn = zipfile.ZipFile\\n is_match_fn = zipfile.is_zipfile\\n\\n if is_match_fn(file_path):\\n with open_fn(file_path) as archive:\\n try:\\n archive.extractall(path)\\n except (tarfile.TarError, RuntimeError, KeyboardInterrupt):\\n if os.path.exists(path):\\n if os.path.isfile(path):\\n os.remove(path)\\n else:\\n shutil.rmtree(path)\\n raise\\n return True\\n return False\",\n \"def _extract_archive(file_path, path=\\\".\\\", archive_format=\\\"auto\\\"):\\n if archive_format is None:\\n return False\\n if archive_format == \\\"auto\\\":\\n archive_format = [\\\"tar\\\", \\\"zip\\\"]\\n if isinstance(archive_format, six.string_types):\\n archive_format = [archive_format]\\n\\n for archive_type in archive_format:\\n if archive_type == \\\"tar\\\":\\n open_fn = tarfile.open\\n is_match_fn = tarfile.is_tarfile\\n if archive_type == \\\"zip\\\":\\n open_fn = zipfile.ZipFile\\n is_match_fn = zipfile.is_zipfile\\n\\n if is_match_fn(file_path):\\n with open_fn(file_path) as archive:\\n try:\\n archive.extractall(path)\\n except (tarfile.TarError, RuntimeError, KeyboardInterrupt):\\n if os.path.exists(path):\\n if os.path.isfile(path):\\n os.remove(path)\\n else:\\n shutil.rmtree(path)\\n raise\\n return True\\n return False\",\n \"def extract_web_archive(cls, url, apath, ffilter=[]):\\n\\n if apath not in cls._archives.keys():\\n download(url, apath)\\n\\n _files = extract(apath, ffilter=ffilter)\\n\\n return _files\",\n \"def safetar_extractall(tarf, *args, **kwargs):\\r\\n return tarf.extractall(members=safemembers(tarf), *args, **kwargs)\",\n \"def extract_web_archive(url, apath, ffilter=[]):\\n\\n download(url, apath)\\n output_files = extract(apath, ffilter=ffilter)\\n\\n return output_files\",\n \"def load_zip_archive(archive_file, \\n file_list=None, \\n suffix_list=['jpeg', 'jpg', 'png'],\\n as_float=False):\\n if type(file_list) in [str]:\\n file_list = [file_list]\\n\\n if type(suffix_list) in [str]:\\n suffix_list = [suffix_list]\\n if suffix_list and type(suffix_list) not in [set]:\\n suffix_list = set(suffix_list)\\n\\n imgs = []\\n with ZipFile(archive_file, 'r') as zfa:\\n for f_info in zfa.infolist():\\n if f_info.is_dir():\\n continue\\n\\n if suffix_list:\\n i = f_info.filename.rfind('.')\\n suffix = f_info.filename[i+1:].lower() if i >= 0 else ''\\n if suffix not in suffix_list:\\n continue\\n\\n if file_list:\\n use_f = False\\n for fl in file_list:\\n if re.match(fl, f_info.filename):\\n use_f = True\\n break\\n if not use_f:\\n continue\\n\\n imgs.append((load_image(zfa.open(f_info)), f_info.filename))\\n return imgs\",\n \"def unzip_archive(archive):\\n tmpdir = os.path.join(tempfile.gettempdir(),\\n os.path.basename(archive))\\n assert tmpdir != archive # That wouldn't work out\\n\\n if os.path.exists(tmpdir):\\n # files are already extracted\\n pass\\n else:\\n if tarfile.is_tarfile(archive):\\n print 'Extracting tarfile ...'\\n with tarfile.open(archive) as tf:\\n tf.extractall(path=tmpdir)\\n elif zipfile.is_zipfile(archive):\\n print 'Extracting zipfile ...'\\n with zipfile.ZipFile(archive) as zf:\\n zf.extractall(path=tmpdir)\\n else:\\n raise ValueError('Unknown file type for %s' % os.path.basename(archive))\\n return tmpdir\",\n \"def _extract_multi_vol_zip(src, dst):\\n cat_zip_path = os.path.join(dst, os.path.basename(src))\\n _cat_multi_vol_zip(src, cat_zip_path)\\n _extract_zip(cat_zip_path, dst)\\n os.remove(cat_zip_path)\",\n \"def extract_recursive(curr_apath):\\n\\n handler = resolve_format(curr_apath)\\n unpacker = HandlersFactory.get_handler(handler)\\n _files = unpacker.files_list(curr_apath)\\n\\n for f in _files:\\n if is_matched(f, ffilter=ffilter):\\n _fpath = unpacker.extract(curr_apath, f)\\n files.append(_fpath)\\n if is_archive(f):\\n _apath = unpacker.extract(curr_apath, f)\\n extract_recursive(_apath)\",\n \"def git_archive_all(path, archive_file_name):\\n import os\\n import tarfile\\n\\n def ls_files(prefix=''):\\n \\\"\\\"\\\"\\n Does a `git ls-files` on every git repository (eg: submodules)\\n found in the working git repository and returns a list with all the\\n filenames returned by each `git ls-files`\\n\\n --full-name Forces paths to be output relative to the project top\\n directory\\n --exclude-standard adds standard git exclusions\\n (.git/info/exclude, .gitignore, ...)\\n \\\"\\\"\\\"\\n cmd = 'git ls-files --full-name --exclude-standard'\\n raw_files = local(cmd, capture=True)\\n files = []\\n\\n for filename in raw_files.split('\\\\n'):\\n if (os.path.isdir(filename) and\\n os.path.exists(os.path.join(filename, '.git'))):\\n os.chdir(filename)\\n files.extend(ls_files(prefix=filename))\\n else:\\n files.append(os.path.join(prefix, filename))\\n\\n return files\\n\\n cwd = os.getcwd()\\n os.chdir(path)\\n files = ls_files()\\n os.chdir(path)\\n project_tar = tarfile.open(archive_file_name, 'w:gz')\\n\\n for filename in files:\\n project_tar.add(filename)\\n\\n project_tar.close()\\n os.chdir(cwd)\\n\\n print(green('Archive created at %s/%s' % (path, archive_file_name)))\",\n \"def pack(archive: Union[Path, str],\\n paths: List[Union[Path, str]],\\n cwd: Optional[Path] = None,\\n exclude: Optional[List[Union[Path, str]]] = ()):\\n archive = Path(archive)\\n if cwd is None:\\n cwd = Path.cwd()\\n if archive.suffix == '.xz':\\n archive = archive.with_suffix('')\\n\\n # Make sure all the paths have sane permissions.\\n def walk(path):\\n if path.is_symlink():\\n return\\n elif path.is_dir():\\n # All dirs should be 755.\\n mode = path.stat().st_mode & 0o777\\n if mode != 0o755:\\n path.chmod(0o755)\\n\\n for subpath in path.glob('*'):\\n walk(subpath)\\n elif path.is_file():\\n # All scripts should be 755 while other files should be 644.\\n mode = path.stat().st_mode & 0o777\\n if mode in (0o755, 0o644):\\n return\\n if mode & 0o111:\\n path.chmod(0o755)\\n else:\\n path.chmod(0o644)\\n else:\\n raise ValueError(f'{path}: unknown file type')\\n\\n logging.info('Forcing sane permissions on inputs')\\n for path in paths:\\n walk(cwd / path)\\n\\n logging.info('Creating %s tarball', archive.name)\\n # We use relpath here to help out tar on platforms where it doesn't like\\n # paths with colons in them (e.g. Windows). We have to construct the full\\n # before running through relpath as relative archives will implicitly be\\n # checked against os.getcwd rather than the explicit cwd.\\n tar = os.path.relpath(cwd / archive, cwd)\\n run(['tar', '--owner=0', '--group=0', '-cf', tar] +\\n [f'--exclude={x}' for x in exclude] + ['--'] + paths, cwd=cwd)\\n\\n logging.info('Compressing tarball')\\n run(['xz', '-f', '-T0', '-9', tar], cwd=cwd)\",\n \"def extract(self, step_name, archive_file, output, mode='safe',\\n include_files=()):\\n assert mode in ('safe', 'unsafe'), 'Unknown mode %r' % (mode,)\\n\\n step_result = self.m.python(\\n step_name,\\n self.resource('extract.py'),\\n [\\n '--json-input', self.m.json.input({\\n 'output': str(output),\\n 'archive_file': str(archive_file),\\n 'safe_mode': mode == 'safe',\\n 'include_files': list(include_files),\\n }),\\n '--json-output', self.m.json.output(),\\n ],\\n step_test_data=lambda: self.m.json.test_api.output({\\n 'extracted': {\\n 'filecount': 1337,\\n 'bytes': 0xbadc0ffee,\\n },\\n }))\\n self.m.path.mock_add_paths(output)\\n j = step_result.json.output\\n if j.get('extracted', {}).get('filecount'):\\n stat = j['extracted']\\n step_result.presentation.step_text += (\\n '<br/>extracted %s files - %.02f MB' % (\\n stat['filecount'], stat['bytes'] / (1000.0**2)))\\n if j.get('skipped', {}).get('filecount'):\\n stat = j['skipped']\\n step_result.presentation.step_text += (\\n '<br/>SKIPPED %s files - %.02f MB' % (\\n stat['filecount'], stat['bytes'] / (1000.0**2)))\\n step_result.presentation.logs['skipped files'] = stat['names']\\n step_result.presentation.status = self.m.step.FAILURE\\n ex = self.m.step.StepFailure(step_name)\\n ex.archive_skipped_files = stat['names']\\n raise ex\",\n \"def extract_files(self, *filenames):\\n for filename in filenames:\\n data = self.read_file(filename)\\n f = open(filename, 'wb')\\n f.write(data or b'')\\n f.close()\",\n \"def _extract_zip(src, dst):\\n # check if src is a valid .zip\\n assert zipfile.is_zipfile(src), \\\"{} is not a valid .zip file.\\\".format(src)\\n\\n zip_file = zipfile.ZipFile(src, \\\"r\\\")\\n for file in zip_file.namelist():\\n zip_file.extract(file, dst)\",\n \"def extract_sources(tarsources=[], zipsources=[]):\\n for source in tarsources:\\n cmd = [\\\"tar\\\", \\\"-xvf\\\", source, \\\"-C\\\", WHEEL_BUILD_DIR]\\n subprocess.check_call(cmd)\\n\\n for source in zipsources:\\n cmd = [\\\"unzip\\\", source, \\\"-d\\\", WHEEL_BUILD_DIR]\\n subprocess.check_call(cmd)\",\n \"def _extract_all_gz_in_dir(directory):\\n for file in os.listdir(directory):\\n if file.endswith(\\\".gz\\\"):\\n gz_fname = os.path.join(directory, file)\\n _extract_gz(gz_fname, os.path.dirname(gz_fname))\\n os.remove(gz_fname)\",\n \"def extract_tarball(fname, outfile=None, concat=True) -> Union[str, None]:\\n fnames = []\\n # Extract files to temporary directory\\n tmp_dir = mkdtemp(dir=os.path.dirname(outfile))\\n with tarfile.open(fname) as tar:\\n tar.extractall(path=tmp_dir)\\n for root, _, files in os.walk(tmp_dir):\\n fnames += [os.path.join(root, fname) for fname in files]\\n\\n if len(fnames) > 1 and not concat:\\n raise ValueError(\\\"tarball contains multiple files, but concat not specified!\\\")\\n\\n # Concatenate (also works woth one file)\\n with open(outfile, \\\"w\\\") as out:\\n for infile in fnames:\\n for line in open(infile):\\n out.write(line)\\n\\n rm_rf(tmp_dir)\\n\\n return outfile\",\n \"def _unzip_files(self) -> None:\\n for file in self.input_path.iterdir():\\n if is_zipfile(file):\\n with ZipFile(file, mode=\\\"r\\\") as archive:\\n archive.extractall(path=self.temp_path)\",\n \"def extract(file, fileFormat):\\n\\tspeech.speak(\\\"Extracting files in \\\" + file + \\\".\\\")\\n\\tpatoolib.extract_archive(file)\",\n \"def extract(self, paths=None):\\n\\n all_files = self._get_package_files()\\n if paths is None:\\n extracted_files = all_files.values()\\n else:\\n extracted_files = [all_files[path] for path in paths]\\n\\n # filter already extracted file\\n extracted_files = [pf for pf in extracted_files if not os.path.isfile(self.project.storage.fspath(pf.extract_path))]\\n\\n # group files by package\\n files_by_package = defaultdict(list)\\n for pf in extracted_files:\\n files_by_package[pf.package].append(pf)\\n\\n package_files_path = f\\\"{self.path}/packages/files\\\"\\n\\n for package, files in files_by_package.items():\\n with self.project.storage.stream(f\\\"{package_files_path}/{package}\\\") as reader:\\n # sort files by offset to extract while streaming the bin file\\n for pkgfile in sorted(files, key=lambda f: f.offset):\\n logger.debug(f\\\"extracting {pkgfile.path}\\\")\\n reader.skip_to(pkgfile.offset)\\n fspath = self.project.storage.fspath(pkgfile.extract_path)\\n with write_file_or_remove(fspath) as fout:\\n if pkgfile.compressed:\\n zobj = zlib.decompressobj(zlib.MAX_WBITS | 32)\\n def writer(data):\\n return fout.write(zobj.decompress(data))\\n reader.copy(writer, pkgfile.size)\\n fout.write(zobj.flush())\\n else:\\n reader.copy(fout.write, pkgfile.size)\",\n \"def inspect(apath):\\n\\n files = []\\n\\n def inspect_into(curr_apath):\\n handler = resolve_format(curr_apath)\\n unpacker = HandlersFactory.get_handler(handler)\\n _files = unpacker.files_list(curr_apath)\\n for f in _files:\\n # go into nested archive or compressed file\\n if is_archive(f):\\n _apath = unpacker.extract(curr_apath, f)\\n inspect_into(_apath)\\n\\n else:\\n files.append(f)\\n\\n inspect_into(apath)\\n return files\",\n \"def unpackToTemp(self,archive,fileNames,progress=None):\\n if not fileNames: raise ArgumentError(_(\\\"No files to extract for %s.\\\") % archive.s)\\n progress = progress or bolt.Progress()\\n progress.state,progress.full = 0,len(fileNames)\\n #--Dump file list\\n out = self.tempList.open('w')\\n out.write('\\\\n'.join(fileNames).encode('utf8'))\\n out.close()\\n #--Extract files\\n self.clearTemp()\\n apath = dirs['installers'].join(archive)\\n command = '7z.exe x \\\"%s\\\" -y -o%s @%s' % (apath.s, self.tempDir.s, self.tempList.s)\\n ins = os.popen(command,'r')\\n reExtracting = re.compile('Extracting\\\\s+(.+)')\\n extracted = []\\n for line in ins:\\n maExtracting = reExtracting.match(line)\\n if maExtracting: \\n extracted.append(maExtracting.group(1).strip())\\n progress.plus()\\n result = ins.close()\\n if result:\\n raise StateError(_(\\\"Extraction failed.\\\"))\\n #ensure that no file is read only\\n for thedir, subdirs, files in os.walk(self.tempDir.s):\\n for f in files:\\n os.chmod(os.path.join(thedir, f),stat.S_IWRITE)\\n #--Done\\n self.tempList.remove()\",\n \"def _unpack_archive(self, dir, filters):\\n ext = os.path.splitext(self.path)[1]\\n if ext in [\\\".zip\\\", \\\".xpi\\\"]:\\n if filters:\\n raise GbpError(\\\"Can only filter tar archives: %s\\\", (ext, self.path))\\n self._unpack_zip(dir)\\n else:\\n self._unpack_tar(dir, filters)\",\n \"def _cat_multi_vol_zip(src, dst):\\n concat_cmd = \\\"zip -s 0 {} --out {}\\\".format(src, dst)\\n os.system(concat_cmd)\",\n \"def Zip(args):\\n parser = argparse.ArgumentParser(description=Zip.__doc__)\\n parser.add_argument(\\n '-r', dest='recursive', action='store_true',\\n default=False,\\n help='recurse into directories')\\n parser.add_argument(\\n '-q', dest='quiet', action='store_true',\\n default=False,\\n help='quiet operation')\\n parser.add_argument('zipfile')\\n parser.add_argument('filenames', nargs='+')\\n options = parser.parse_args(args)\\n\\n src_files = []\\n for filename in options.filenames:\\n globbed_src_args = glob.glob(filename)\\n if not globbed_src_args:\\n if not options.quiet:\\n print('zip warning: name not matched: %s' % filename)\\n\\n for src_file in globbed_src_args:\\n src_file = os.path.normpath(src_file)\\n src_files.append(src_file)\\n if options.recursive and os.path.isdir(src_file):\\n for root, dirs, files in os.walk(src_file):\\n for dirname in dirs:\\n src_files.append(os.path.join(root, dirname))\\n for filename in files:\\n src_files.append(os.path.join(root, filename))\\n\\n # zip_data represents a list of the data to be written or appended to the\\n # zip_stream. It is a list of tuples:\\n # (OS file path, zip path/zip file info, and file data)\\n # In all cases one of the |os path| or the |file data| will be None.\\n # |os path| is None when there is no OS file to write to the archive (i.e.\\n # the file data already existed in the archive). |file data| is None when the\\n # file is new (never existed in the archive) or being updated.\\n zip_data = []\\n new_files_to_add = [OSMakeZipPath(src_file) for src_file in src_files]\\n zip_path_to_os_path_dict = dict((new_files_to_add[i], src_files[i])\\n for i in range(len(src_files)))\\n write_mode = 'a'\\n if os.path.exists(options.zipfile):\\n with zipfile.ZipFile(options.zipfile, 'r') as zip_stream:\\n try:\\n files_to_update = set(new_files_to_add).intersection(\\n set(zip_stream.namelist()))\\n if files_to_update:\\n # As far as I can tell, there is no way to update a zip entry using\\n # zipfile; the best you can do is rewrite the archive.\\n # Iterate through the zipfile to maintain file order.\\n write_mode = 'w'\\n for zip_path in zip_stream.namelist():\\n if zip_path in files_to_update:\\n os_path = zip_path_to_os_path_dict[zip_path]\\n zip_data.append((os_path, zip_path, None))\\n new_files_to_add.remove(zip_path)\\n else:\\n file_bytes = zip_stream.read(zip_path)\\n file_info = zip_stream.getinfo(zip_path)\\n zip_data.append((None, file_info, file_bytes))\\n except IOError:\\n pass\\n\\n for zip_path in new_files_to_add:\\n zip_data.append((zip_path_to_os_path_dict[zip_path], zip_path, None))\\n\\n if not zip_data:\\n print('zip error: Nothing to do! (%s)' % options.zipfile)\\n return 1\\n\\n with zipfile.ZipFile(options.zipfile, write_mode,\\n zipfile.ZIP_DEFLATED) as zip_stream:\\n for os_path, file_info_or_zip_path, file_bytes in zip_data:\\n if isinstance(file_info_or_zip_path, zipfile.ZipInfo):\\n zip_path = file_info_or_zip_path.filename\\n else:\\n zip_path = file_info_or_zip_path\\n\\n if os_path:\\n st = os.stat(os_path)\\n if stat.S_ISDIR(st.st_mode):\\n # Python 2.6 on the buildbots doesn't support writing directories to\\n # zip files. This was resolved in a later version of Python 2.6.\\n # We'll work around it by writing an empty file with the correct\\n # path. (This is basically what later versions do anyway.)\\n zip_info = zipfile.ZipInfo()\\n zip_info.filename = zip_path\\n zip_info.date_time = time.localtime(st.st_mtime)[0:6]\\n zip_info.compress_type = zip_stream.compression\\n zip_info.flag_bits = 0x00\\n zip_info.external_attr = (st[0] & 0xFFFF) << 16\\n zip_info.CRC = 0\\n zip_info.compress_size = 0\\n zip_info.file_size = 0\\n zip_stream.writestr(zip_info, '')\\n else:\\n zip_stream.write(os_path, zip_path)\\n else:\\n zip_stream.writestr(file_info_or_zip_path, file_bytes)\\n\\n if not options.quiet:\\n if zip_path in new_files_to_add:\\n operation = 'adding'\\n else:\\n operation = 'updating'\\n zip_info = zip_stream.getinfo(zip_path)\\n if (zip_info.compress_type == zipfile.ZIP_STORED or\\n zip_info.file_size == 0):\\n print(' %s: %s (stored 0%%)' % (operation, zip_path))\\n elif zip_info.compress_type == zipfile.ZIP_DEFLATED:\\n print(' %s: %s (deflated %d%%)' % (operation, zip_path,\\n 100 - zip_info.compress_size * 100 / zip_info.file_size))\\n\\n return 0\",\n \"def _zipfile_single_file_extract_worker(\\n zip_file_path: Path,\\n file_in_archive: zipfile.ZipInfo,\\n destination_folder: Path,\\n is_dir: bool,\\n) -> Path:\\n with _FastZipFileReader(zip_file_path) as zf:\\n # assemble destination and ensure it exits\\n destination_path = destination_folder / file_in_archive.filename\\n\\n if is_dir:\\n destination_path.mkdir(parents=True, exist_ok=True)\\n return destination_path\\n desc = f\\\"decompressing {zip_file_path}:{file_in_archive.filename} -> {destination_path}\\\\n\\\"\\n with zf.open(name=file_in_archive) as zip_fp, destination_path.open(\\n \\\"wb\\\"\\n ) as dest_fp, tqdm_logging_redirect(\\n total=file_in_archive.file_size,\\n desc=desc,\\n **(\\n _TQDM_FILE_OPTIONS\\n | dict(miniters=_compute_tqdm_miniters(file_in_archive.file_size))\\n ),\\n ) as pbar:\\n while chunk := zip_fp.read(_CHUNK_SIZE):\\n dest_fp.write(chunk)\\n pbar.update(len(chunk))\\n return destination_path\",\n \"def extract_file(source_path, destination_path):\\n extender_tar = ['tar.gz', 'tar', 'gz']\\n extender_zip = ['zip']\\n\\n extend = source_path.split('.')[-1]\\n if extend in extender_tar:\\n extract_tar(source_path, destination_path)\\n elif extend in extender_zip:\\n extract_zip(source_path, destination_path)\",\n \"def extract_zip(\\n fname: str, outfile: Optional[str] = None, concat: bool = False\\n) -> Union[str, None]:\\n if not outfile:\\n outfile = fname[:-4]\\n\\n with ZipFile(fname, \\\"r\\\") as fzip, TemporaryDirectory() as tmpdir:\\n fzip.extractall(path=tmpdir)\\n fnames = glob(f\\\"{tmpdir}/*\\\")\\n\\n if len(fnames) > 1 and not concat:\\n raise ValueError(\\n \\\"Downloaded zip file contains multiple files, but concat is not specified!\\\"\\n )\\n\\n # Concatenate (also works with one file)\\n with open(outfile, \\\"w\\\") as out:\\n for infile in fnames:\\n for line in open(infile):\\n out.write(line)\\n\\n os.unlink(fname)\\n\\n return outfile\",\n \"def mass_extract(source_directory, target_directory):\\n\\n import os\\n import ZipFile\\n\\n source_directory = raw_input(\\\"Where are the zips? \\\")\\n target_directory = raw_input(\\\"To where do you want to extract the files? \\\")\\n \\n if not os.path.exists(source_directory):\\n print \\\"Sorry, that folder doesn't seem to exist.\\\"\\n source_directory = raw_input(\\\"Where are the zips? \\\")\\n\\n if not os.path.exists(target_directory):\\n os.mkdir(target_directory)\\n \\n for path, directory, filename in os.walk(source_directory):\\n zip_file = ZipFile.ZipFile(filenames)\\n ZipFile.extract(zip_file, target_directory)\\n zip_file.close()\\n\\n print \\\"Done.\\\"\",\n \"async def extract(self, destination, entries=None, callback=None):\\n # :param srcdestpairs: A list of 2-tuples where the first item\\n # is the source path within the archive of a file to install,\\n # and the second item is the path (relative to the mod\\n # installation directory) where the source should be extracted.\\n\\n # TODO: ignore \\\"._\\\"-prefixed mac-cruft files\\n loop = asyncio.get_event_loop()\\n c=0\\n # noinspection PyTypeChecker\\n async for extracted in self.archiver.extract(\\n archive=self.archive,\\n destination=destination,\\n specific_entries=entries,\\n # callback=callback\\n ):\\n c+=1\\n if callback:\\n loop.call_soon_threadsafe(callback, extracted, c)\\n self.LOGGER << f\\\"{c} files extracted\\\"\\n\\n # srcdestpairs = srcdestpairs,\",\n \"def extract_tar_file(archive_path, output_dir, relative_to, extractors=None):\\n if extractors is None:\\n extractors = DEFAULT_EXTRACTORS\\n\\n current_platform = get_running_platform()\\n if current_platform == PlatformEnum.WINDOWS:\\n # Try to use 7-zip first\\n sevenzip_cmd = extractors.get(ExtractorEnum.SEVENZIP)\\n if sevenzip_cmd == USE_REGISTRY:\\n sevenzip_cmd = str(_find_7z_by_registry())\\n sevenzip_bin = _find_extractor_by_cmd(sevenzip_cmd)\\n if sevenzip_bin is not None:\\n _extract_tar_with_7z(sevenzip_bin, archive_path, output_dir, relative_to)\\n return\\n\\n # Use WinRAR if 7-zip is not found\\n winrar_cmd = extractors.get(ExtractorEnum.WINRAR)\\n if winrar_cmd == USE_REGISTRY:\\n winrar_cmd = str(_find_winrar_by_registry())\\n winrar_bin = _find_extractor_by_cmd(winrar_cmd)\\n if winrar_bin is not None:\\n _extract_tar_with_winrar(winrar_bin, archive_path, output_dir, relative_to)\\n return\\n get_logger().warning(\\n 'Neither 7-zip nor WinRAR were found. Falling back to Python extractor...')\\n elif current_platform == PlatformEnum.UNIX:\\n # NOTE: 7-zip isn't an option because it doesn't preserve file permissions\\n tar_bin = _find_extractor_by_cmd(extractors.get(ExtractorEnum.TAR))\\n if not tar_bin is None:\\n _extract_tar_with_tar(tar_bin, archive_path, output_dir, relative_to)\\n return\\n else:\\n # This is not a normal code path, so make it clear.\\n raise NotImplementedError(current_platform)\\n # Fallback to Python-based extractor on all platforms\\n _extract_tar_with_python(archive_path, output_dir, relative_to)\",\n \"def archive_folders(args, directory_list):\\n # Archive each of the subfolders\\n # If we haven't selected archive then we return immediately.\\n if not args.archive:\\n return\\n\\n # Otherwise a simple tar command should do\\n tar_commands = []\\n for directory in directory_list:\\n tar_commands.append(\\\"tar -cf - %s --remove-files | pigz -9 -p 8 > %s.tar.gz\\\" %\\n (directory, directory))\\n\\n # Multi-thread our tar command\\n processes = (subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n for cmd in tar_commands)\\n\\n # We use the islice command to split our commands into five smaller lists.\\n running_processes = list(itertools.islice(processes, args.num_threads))\\n\\n while running_processes:\\n for i, process in enumerate(running_processes):\\n if process.poll() is not None: # Means that the process is complete!\\n stdout, stderr = process.communicate() # Get the output of the completed process\\n if not stderr == \\\"\\\":\\n print stderr\\n running_processes[i] = next(processes, None)\\n # Run the next number in the list.\\n if running_processes[i] is None: # No more commands waiting to be processed.\\n del running_processes[i] # Not a valid process.\\n break\",\n \"def compress_files(time_stamp, files_to_be_appended):\\n process = subprocess.run([\\\"tar\\\", \\\"-czf\\\", f\\\"connect-log.{time_stamp}.tar.gz\\\", files_to_be_appended[0],\\n files_to_be_appended[1],\\n files_to_be_appended[2],\\n files_to_be_appended[3], files_to_be_appended[4]], capture_output=True)\",\n \"def extract_source(source_archive, target):\\r\\n with tarfile.open(source_archive) as tar_file:\\r\\n safetar_extractall(tar_file, target)\",\n \"def archive_files(output_dir, output_dir_name):\\n\\n file_name = output_dir + \\\".tar.gz\\\"\\n\\n logger.info(\\\"Archiving files into %s\\\", file_name)\\n with tarfile.open(file_name, \\\"w|gz\\\") as tar:\\n tar.add(output_dir, arcname=output_dir_name)\\n logger.info(\\\"Archived files into %s\\\", file_name)\\n\\n try:\\n shutil.rmtree(output_dir)\\n except OSError as ex:\\n logger.warning(\\\"Failed to delete directory after archiving: %s\\\", ex)\",\n \"def untar(archive):\\n log.info('Unpacking archive \\\"%s\\\".' % archive)\\n tar = module.params['tar']\\n tar_extra_options = shlex.split(module.params['tar_extra_options'])\\n if not tar:\\n tar = module.get_bin_path('tar', required=True)\\n if archive.endswith('.gz'):\\n uncompress = 'z'\\n elif archive.endswith('.bz2'):\\n uncompress = 'j'\\n else:\\n raise ValueError('Unsupported compression type: %s' % archive)\\n options = ''.join(['x', uncompress, 'f'])\\n args = [tar, options] + tar_extra_options + [archive]\\n rc, out, err = module.run_command(args)\\n log.info('untar: rc=%d out=%s err=%s', rc, out, err)\\n if rc != 0:\\n raise ValueError('tar command failed: %d' % rc)\",\n \"def _extract_archive(path: str, extracted_dir_path: str) -> str:\\n logging.info('extracting %s to %s', path, extracted_dir_path)\\n with tarfile.open(path) as tar:\\n tar.extractall(path=extracted_dir_path)\\n extracted_items = os.listdir(extracted_dir_path)\\n if len(extracted_items) != 1:\\n raise ValueError(\\n 'archive at {} did not contain a single directory'.format(path))\\n return os.path.join(extracted_dir_path, extracted_items[0])\",\n \"def __extract_tgz(self):\\n tar_file = tarfile.open(self.archive)\\n try:\\n extract_dir = tempfile.mkdtemp()\\n archive_binaries_dir = self.__create_extraction_dir(\\n tar_file.getnames(), extract_dir, tar_file.extract)\\n finally:\\n tar_file.close()\\n return archive_binaries_dir, extract_dir\",\n \"def extract_files(self) -> list:\\n pass\",\n \"def archive(filepath,archive_dir='archive'):\\n\\n # Make sure we have a directory to archive to\\n try:\\n mkdir(archive_dir)\\n except:\\n print(\\\"Error making archive directory\\\")\\n return\\n\\n try:\\n (dir, filename) = os.path.split(filepath)\\n outfile = os.path.join(dir,archive_dir,filename)+'.gz'\\n with open(filename, 'rb') as f_in, gzip.open(outfile, 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n except Exception as e:\\n print(\\\"Error archiving \\\",filepath)\\n print(e)\\n else:\\n try:\\n os.remove(filepath)\\n except:\\n print(\\\"Error removing \\\",filepath)\",\n \"def readArchiveFiles(self) -> 'ChartVersionInfo':\\n if self._archiveFiles is not None:\\n return self\\n archiveFiles = {}\\n try:\\n with self.fileOpen() as tar_file:\\n for tarinfo in tar_file.getmembers():\\n if tarinfo.isreg():\\n parsename = pathlib.PurePosixPath(tarinfo.name)\\n if parsename.is_absolute():\\n raise InputOutputError('All files in chart archive must be relative')\\n basename = str(pathlib.PurePosixPath(*parsename.parts[1:]))\\n if basename in ['Chart.yaml', 'Chart.lock', 'values.yaml', 'values.schema.json', 'requirements.yaml']:\\n file = tar_file.extractfile(tarinfo.name)\\n if file is None:\\n raise InputOutputError('Could not read file \\\"{}\\\" from archive'.format(tarinfo.name))\\n archiveFiles[basename] = file.read().decode('utf-8')\\n except tarfile.TarError as e:\\n raise InputOutputError(str(e)) from e\\n self._archiveFiles = archiveFiles\\n return self\",\n \"def extract(self):\\n if self.files:\\n return dict((f, self.read_file(f)) for f in self.files)\\n else:\\n raise RuntimeError(\\\"Can't extract whole archive without listfile.\\\")\",\n \"def _decompress_tarball(*, in_fileobj, out_fileobj):\\n with tarfile.open(fileobj=in_fileobj, mode=\\\"r\\\") as it, tarfile.open(\\n fileobj=out_fileobj, mode=\\\"w|\\\"\\n ) as ot:\\n for member in it.getmembers():\\n extracted = it.extractfile(member)\\n ot.addfile(member, extracted)\",\n \"def extractAll(self, directory):\\r\\n if self._archive == None:\\r\\n raise StandardError(\\\"Archive was not open\\\")\\r\\n\\r\\n self._archive.extractall(directory)\",\n \"def add_files(self, *paths, **kw):\\n write_p = self._pointer\\n\\n block_size = ffi.write_get_bytes_per_block(write_p)\\n if block_size <= 0:\\n block_size = 10240 # pragma: no cover\\n\\n with new_archive_entry() as entry_p:\\n entry = ArchiveEntry(None, entry_p)\\n for path in paths:\\n with new_archive_read_disk(path, **kw) as read_p:\\n while 1:\\n r = read_next_header2(read_p, entry_p)\\n if r == ARCHIVE_EOF:\\n break\\n entry.pathname = entry.pathname.lstrip('/')\\n read_disk_descend(read_p)\\n write_header(write_p, entry_p)\\n if entry.isreg:\\n with open(entry_sourcepath(entry_p), 'rb') as f:\\n while 1:\\n data = f.read(block_size)\\n if not data:\\n break\\n write_data(write_p, data, len(data))\\n write_finish_entry(write_p)\\n entry_clear(entry_p)\",\n \"def main():\\r\\n parser = CommonArgParser(__file__)\\r\\n parser.add_argument('src_dir', help='Source directory')\\r\\n parser.add_argument(\\r\\n 'out_dir',\\r\\n default='.',\\r\\n help=\\\"\\\"\\\"The directory the files to be extracted.\\r\\n (Default: Current directoty\\\"\\\"\\\")\\r\\n args = parser.parse_all()\\r\\n for f in next_file(args.src_dir, ['*.tgz', '*.tar.gz']):\\r\\n untgz(f, args.out_dir)\",\n \"def test(self, archive, files):\\n self.log.info(\\\"Opening archive %s for testing.\\\" % (archive))\\n tmpdir = tempfile.mkdtemp(dir='/tmp/')\\n tar = tarfile.open(archive, 'r:gz')\\n tar.extractall(tmpdir);\\n tar.close()\\n\\n mtime = {}\\n for file in files:\\n mtime[file] = os.path.getmtime(file)\\n # compare each file to its archived copy\\n self.log.debug(\\\"Comparing files %s and %s\\\" % (file, tmpdir))\\n diffdir = filecmp.dircmp(file, os.path.join(tmpdir, file));\\n diffdir.report_full_closure();\\n status = {}\\n for i in ('left_only', 'right_only', 'diff_files'):\\n if len(diffdir.__dict__[i]) > 0:\\n status[i] = len(diffdir.__dict__[i])\\n if len(status) > 0:\\n raise RuntimeError (\\\"Archive contents do not match source files.\\\")\\n return mtime\",\n \"def find_archives(self):\\n pattern = re.compile(r'^[0-9A-F]{40}\\\\.tar$', re.IGNORECASE)\\n for entry in self.context.list_entries(self.cache_directory):\\n if pattern.match(entry):\\n yield os.path.join(self.cache_directory, entry)\",\n \"def _zip_archive(extracted_source, exclude_files=None, **_):\\n ctx.logger.debug(\\\"Zipping source {source}\\\".format(source=extracted_source))\\n exclude_files = exclude_files or []\\n ctx.logger.debug('Excluding files {l}'.format(l=exclude_files))\\n with tempfile.NamedTemporaryFile(suffix=\\\".zip\\\",\\n delete=False) as updated_zip:\\n updated_zip.close()\\n with zipfile.ZipFile(updated_zip.name,\\n mode='w',\\n compression=zipfile.ZIP_DEFLATED) as output_file:\\n for dir_name, subdirs, filenames in os.walk(extracted_source):\\n # Make sure that the files that we don't want\\n # to include (e.g. plugins directory) will not be archived.\\n exclude_dirs(dir_name, subdirs, exclude_files)\\n for filename in filenames:\\n # Extra layer of validation on the excluded files.\\n if not exclude_file(dir_name, filename, exclude_files):\\n # Create the path as we want to archive it to the\\n # archivee.\\n file_to_add = os.path.join(dir_name, filename)\\n # The name of the file in the archive.\\n if file_storage_breaker(file_to_add):\\n continue\\n arc_name = file_to_add[len(extracted_source)+1:]\\n output_file.write(file_to_add, arcname=arc_name)\\n archive_file_path = updated_zip.name\\n return archive_file_path\",\n \"def GetExtraFiles(self, extra_archive_paths, source_file_name):\\n extra_files_list = []\\n extra_path_list = extra_archive_paths.split(',')\\n for path in extra_path_list:\\n path = path.strip()\\n source_file = os.path.join(self._src_dir, path, source_file_name)\\n if os.path.exists(source_file):\\n new_files_list = open(source_file).readlines()\\n extra_files_list.extend(new_files_list)\\n\\n extra_files_list = [e.strip() for e in extra_files_list]\\n extra_files_list = archive_utils.ExpandWildcards(self._build_dir,\\n extra_files_list)\\n return extra_files_list\",\n \"async def unarchive_dir(\\n archive_to_extract: Path,\\n destination_folder: Path,\\n *,\\n max_workers: int = _MAX_UNARCHIVING_WORKER_COUNT,\\n progress_bar: ProgressBarData | None = None,\\n log_cb: Callable[[str], Awaitable[None]] | None = None,\\n) -> set[Path]:\\n if not progress_bar:\\n progress_bar = ProgressBarData(steps=1)\\n async with AsyncExitStack() as zip_stack:\\n zip_file_handler = zip_stack.enter_context(\\n zipfile.ZipFile( # pylint: disable=consider-using-with\\n archive_to_extract,\\n mode=\\\"r\\\",\\n )\\n )\\n zip_stack.enter_context(logging_redirect_tqdm())\\n process_pool = zip_stack.enter_context(\\n non_blocking_process_pool_executor(max_workers=max_workers)\\n )\\n\\n # running in process poll is not ideal for concurrency issues\\n # to avoid race conditions all subdirectories where files will be extracted need to exist\\n # creating them before the extraction is under way avoids the issue\\n # the following avoids race conditions while unzippin in parallel\\n _ensure_destination_subdirectories_exist(\\n zip_file_handler=zip_file_handler,\\n destination_folder=destination_folder,\\n )\\n\\n futures: list[asyncio.Future] = [\\n asyncio.get_event_loop().run_in_executor(\\n process_pool,\\n # ---------\\n _zipfile_single_file_extract_worker,\\n archive_to_extract,\\n zip_entry,\\n destination_folder,\\n zip_entry.is_dir(),\\n )\\n for zip_entry in zip_file_handler.infolist()\\n ]\\n\\n try:\\n extracted_paths: list[Path] = []\\n total_file_size = sum(\\n zip_entry.file_size for zip_entry in zip_file_handler.infolist()\\n )\\n async with AsyncExitStack() as progress_stack:\\n sub_prog = await progress_stack.enter_async_context(\\n progress_bar.sub_progress(steps=total_file_size)\\n )\\n tqdm_progress = progress_stack.enter_context(\\n tqdm.tqdm(\\n desc=f\\\"decompressing {archive_to_extract} -> {destination_folder} [{len(futures)} file{'s' if len(futures) > 1 else ''}\\\"\\n f\\\"/{_human_readable_size(archive_to_extract.stat().st_size)}]\\\\n\\\",\\n total=total_file_size,\\n **_TQDM_MULTI_FILES_OPTIONS,\\n )\\n )\\n for future in asyncio.as_completed(futures):\\n extracted_path = await future\\n extracted_file_size = extracted_path.stat().st_size\\n if tqdm_progress.update(extracted_file_size) and log_cb:\\n with log_catch(log, reraise=False):\\n await log_cb(f\\\"{tqdm_progress}\\\")\\n await sub_prog.update(extracted_file_size)\\n extracted_paths.append(extracted_path)\\n\\n except Exception as err:\\n for f in futures:\\n f.cancel()\\n\\n # wait until all tasks are cancelled\\n await asyncio.wait(\\n futures, timeout=2 * _MIN, return_when=asyncio.ALL_COMPLETED\\n )\\n\\n # now we can cleanup\\n if destination_folder.exists() and destination_folder.is_dir():\\n await remove_directory(destination_folder, ignore_errors=True)\\n\\n raise ArchiveError(\\n f\\\"Failed unarchiving {archive_to_extract} -> {destination_folder} due to {type(err)}.\\\"\\n f\\\"Details: {err}\\\"\\n ) from err\\n\\n # NOTE: extracted_paths includes all tree leafs, which might include files and empty folders\\n return {\\n p\\n for p in extracted_paths\\n if p.is_file() or (p.is_dir() and not any(p.glob(\\\"*\\\")))\\n }\",\n \"def download_and_extract(path, url, input_filename, target_filename):\\n logging.info('Downloading and extracting data to: %s' % path)\\n # Check if extracted files already exist in path\\n input_file = find_file(path, input_filename)\\n target_file = find_file(path, target_filename)\\n if input_file and target_file:\\n logging.info(\\\"Already downloaded and extracted %s.\\\" % url)\\n return input_file, target_file\\n\\n # Download archive file if it doesn't already exist.\\n compressed_file = download_from_url(path, url)\\n\\n # Extract compressed files\\n logging.info(\\\"Extracting %s.\\\" % compressed_file)\\n with tarfile.open(compressed_file, \\\"r:gz\\\") as corpus_tar:\\n corpus_tar.extractall(path)\\n\\n # Return filepaths of the requested files.\\n input_file = find_file(path, input_filename)\\n target_file = find_file(path, target_filename)\\n\\n if input_file and target_file:\\n return input_file, target_file\\n\\n raise OSError(\\\"Download/extraction failed for url %s to path %s\\\" %\\n (url, path))\",\n \"def extract_all(tarobj):\\n for member in tarobj.getmembers():\\n tarobj.extract(member)\",\n \"def extract_data(archive: ZipFile, dir_name: str) -> Data:\\n with archive.open(f\\\"{dir_name}/caption.txt\\\", \\\"r\\\") as f:\\n captions = f.readlines()\\n data = []\\n for line in captions:\\n tmp = line.decode().strip().split()\\n img_name = tmp[0]\\n formula = tmp[1:]\\n with archive.open(f\\\"{dir_name}/{img_name}.bmp\\\", \\\"r\\\") as f:\\n # move image to memory immediately, avoid lazy loading, which will lead to None pointer error in loading\\n img = Image.open(f).copy()\\n data.append((img_name, img, formula))\\n\\n print(f\\\"Extract data from: {dir_name}, with data size: {len(data)}\\\")\\n\\n return data\",\n \"def unpackArchive(source, filter = None, encoding = None):\\n \\n primaryArchiveFile = open(source, \\\"rb\\\")\\n header = readHeader(primaryArchiveFile)\\n version, dataOffset, archiveFileCount, fileTableLength, endianness, fileCount = header\\n \\n # open all other archive files\\n archiveFiles = [primaryArchiveFile]\\n sourceRoot, sourceExt = os.path.splitext(source)\\n for i in range(1, archiveFileCount):\\n path = \\\"%s_%d%s\\\" % (sourceRoot, i, sourceExt)\\n archiveFiles.append(open(path, \\\"rb\\\"))\\n \\n fileTable = readFileTable(primaryArchiveFile, header)\\n for fileRecord in fileTable:\\n path, offset, size, compressedSize, archiveFileIndex = fileRecord\\n \\n if callable(filter) and not filter(fileRecord): continue\\n \\n if archiveFileIndex == 0:\\n offset += dataOffset\\n \\n archiveFile = archiveFiles[archiveFileIndex]\\n archiveFile.seek(offset)\\n \\n if compressedSize != 0:\\n fileData = zlib.decompress(archiveFile.read(compressedSize))\\n else:\\n fileData = archiveFile.read(size)\\n \\n if encoding is not None:\\n fileData = fileData.decode(encoding)\\n \\n print('Extracted file \\\"%s\\\" (%u bytes)' % (path, size))\\n yield fileRecord, fileData\\n \\n for f in archiveFiles:\\n f.close()\",\n \"def _extract(self, file_path):\\n self._log.debug(\\\"Extracting file {!r}\\\".format(\\n os.path.basename(file_path)\\n ))\\n tar = tarfile.open(file_path, \\\"r:gz\\\")\\n tar.extractall(os.path.dirname(file_path))\\n tar.close()\",\n \"def archive_logs():\\n logging.info('Archive start...')\\n\\n for log_dir in filter(dir_filter, os.listdir('logs')):\\n path = 'logs/{}'.format(log_dir)\\n archive_files = filter(lambda x: '.log.' in x, os.listdir(path))\\n zip_file_name = '{}/{}.zip'.format(\\n path,\\n str(datetime.now())\\n .replace(' ', '_').replace('.', '_').replace(':', '_'))\\n zip_file = zipfile.ZipFile(\\n zip_file_name, mode='w', compression=zipfile.ZIP_DEFLATED)\\n for f in archive_files:\\n log_file = '{}/{}'.format(path, f)\\n zip_file.write(log_file)\\n os.remove(log_file)\\n\\n logging.info('Archive end.')\",\n \"def archive(self, files, name):\\n self.log.debug(\\\"Putting files into archive: %s\\\" % \\\"\\\\n\\\".join(files))\\n tar_name = \\\"%s%s\\\" % (name, self.extension)\\n if os.path.exists(tar_name):\\n raise RuntimeError (\\\"Tried to create an archive that already exists: %s\\\" % tar_name) \\n else:\\n self.log.info(\\\"Creating a new archive %s\\\" % tar_name)\\n tar = tarfile.open(tar_name, 'w:gz');\\n for name in files:\\n tar.add(name)\\n print '%s'% (name)\\n tar.close()\\n return tar_name\",\n \"def files_in_archive(fd: BinaryIO) -> Iterable[int]:\\n\\n _check_next_bytes(fd, ARCHIVE_MAGIC, 'archive magic number')\\n\\n while True:\\n # In some archives, the first file ends with an additional \\\\n. If that\\n # is present, skip it.\\n if fd.read(1) != b'\\\\n':\\n fd.seek(-1, 1)\\n\\n # Each file in an archive is prefixed with an ASCII header:\\n #\\n # 16 B - file identifier (text)\\n # 12 B - file modification timestamp (decimal)\\n # 6 B - owner ID (decimal)\\n # 6 B - group ID (decimal)\\n # 8 B - file mode (octal)\\n # 10 B - file size in bytes (decimal)\\n # 2 B - ending characters (`\\\\n)\\n #\\n # Skip the unused portions of the file header, then read the size.\\n fd.seek(16 + 12 + 6 + 6 + 8, 1)\\n size_str = fd.read(10)\\n if not size_str:\\n return\\n\\n try:\\n size = int(size_str, 10)\\n except ValueError as exc:\\n raise FileDecodeError(\\n 'Archive file sizes must be decimal integers') from exc\\n\\n _check_next_bytes(fd, b'`\\\\n', 'archive file header ending')\\n offset = fd.tell() # Store offset in case the caller reads the file.\\n\\n yield size\\n\\n fd.seek(offset + size)\",\n \"def handle_tar(file_path, extension, extracted_path, destination_directory):\\n tar = tarfile.open(file_path, extension)\\n # remove files if they already exist\\n if os.path.exists(extracted_path):\\n shutil.rmtree(extracted_path)\\n tar.extractall(path=destination_directory)\\n tar.close()\",\n \"def import_archive(archive, content_type=None):\\n if content_type == \\\"text/xml\\\":\\n import_report(archive.read())\\n elif content_type in [\\\"application/gzip\\\", \\\"application/octet-stream\\\"]:\\n with gzip.GzipFile(mode=\\\"r\\\", fileobj=archive) as zfile:\\n import_report(zfile.read())\\n else:\\n with zipfile.ZipFile(archive, \\\"r\\\") as zfile:\\n for fname in zfile.namelist():\\n import_report(zfile.read(fname))\",\n \"def main(args):\\n\\n for dir in args.dirs:\\n # prepdir = mdssprep.Directory(dir,exclude=['file_*3*','file_2??'],include=['file_*5*'],maxarchivesize=mdssprep.one_meg*200.,minsize=mdssprep.one_meg*100.)\\n prepdir = mdssprep.Directory(dir)\\n prepdir.archive(dryrun=False)\",\n \"def _ExtractFiles(self, tgz_path: str, path_to_collect: str) -> str:\\n local_path = ''\\n if not os.path.exists(tgz_path):\\n self.logger.error(f'File not found {tgz_path}')\\n return local_path\\n\\n tempdir = tempfile.mkdtemp()\\n with tarfile.open(tgz_path) as file:\\n members = self._FilterTarMembers(file, path_to_collect)\\n file.extractall(path=tempdir, members=members)\\n\\n local_path = os.path.join(tempdir, path_to_collect.lstrip('/'))\\n return local_path\",\n \"def _unpack_archive(self):\\n with zipfile.ZipFile(self._archive_full_path, 'r') as zip_ref:\\n zip_ref.extractall(self._storage_path)\\n\\n _logger.debug('Archive has been unpacked.')\",\n \"async def archive_contents(self, *, dirs=True, files=True):\\n if self.archive_files is None:\\n self.archive_dirs, self.archive_files = \\\\\\n await self.archiver.list_archive(self.archive)\\n\\n if not dirs and not files:\\n # if both are false, that's dumb. set both true.\\n dirs = files = True\\n\\n if dirs:\\n for f in self.archive_dirs:\\n yield f\\n if files:\\n for f in self.archive_files:\\n yield f\\n\\n # if dirs and not files:\\n # return self.archive_dirs\\n # if files and not dirs:\\n # return self.archive_files\\n\\n # otherwise return concat of both (even if `dirs` and `files`\\n # are both false...because that's dumb)\\n # return self.archive_dirs + self.archive_files\",\n \"def get_archive(katfilenames):\\n\\timport requests\\n\\n\\tfile_refs = []\\n\\tfor filename in katfilenames:\\n\\t\\tif filename.startswith('s3'):\\n\\t\\t\\tres = requests.post(S3_URL, headers=S3_HEAD, data='{\\\"s3_ref\\\":\\\"%s\\\",\\\"ref_key\\\":\\\"Nope\\\"}'%(filename,))\\n\\t\\t\\turl = res.json()['url']\\n\\t\\t\\tres1 = requests.get(url)\\n\\t\\t\\toutfile = filename.split('/')[-1]\\n\\t\\t\\topen(outfile, 'wb').write(res1.content)\\n\\t\\t\\tfile_refs.append(outfile)\\n\\t\\telse:\\n\\t\\t\\tfile_refs.append(filename)\\n\\treturn file_refs\",\n \"def unpack(file_path, extraction_path, remove):\\n print(file_path)\\n Archive(file_path).extractall(extraction_path, auto_create_dir=True)\\n # remove original compressed file???\\n if remove is True:\\n os.remove(file_path)\",\n \"def cleanup(self, archive, files):\\n mtime = self.test(archive, files)\\n backup_home = os.path.join(self.download_dir, '-')\\n if not os.path.exists(backup_home):\\n os.makedirs(backup_home)\\n backup_dir = tempfile.mkdtemp('', datetime.utcnow().strftime(\\\"%Y-%m-%d_\\\"), backup_home)\\n for file in files:\\n os.makedirs(os.path.join(backup_dir, file))\\n if os.path.getmtime(file) != mtime[file]:\\n raise RuntimeError(\\\"Failed to cleanup archived data: %s has been modified.\\\" % file)\\n os.rename(file, os.path.join(backup_dir, file))\\n self.log.debug(\\\"Moved %s to %s\\\" % (file, os.path.join(backup_dir, file)))\\n return\",\n \"def extract_zip(filename, target_dir, logger=None):\\n logger = logger or Logger()\\n import zipfile\\n logger.log(\\\"Extracting from zip archive %s\\\" % filename, level=1)\\n zip_archive = None\\n try:\\n zip_archive = zipfile.ZipFile(open(filename, mode='r'))\\n member_names = zip_archive.namelist()\\n # manually extract files since extractall is only in python 2.6+\\n# zip_archive.extractall(target_dir)\\n for f in member_names:\\n if f.endswith('/'):\\n dst = \\\"%s/%s\\\" % (target_dir, f)\\n mkdir_p(dst)\\n for f in member_names:\\n if not f.endswith('/'):\\n path = \\\"%s/%s\\\" % (target_dir, f)\\n with open(path, 'wb') as dest_file:\\n dest_file.write(zip_archive.read(f))\\n return member_names\\n finally:\\n if zip_archive is not None:\\n zip_archive.close()\",\n \"def cat_files(files, output):\\n for file in files:\\n with open(file, 'r') as fd:\\n shutil.copyfileobj(fd, output)\",\n \"def cat_files(files, output):\\n for file in files:\\n with open(file, 'r') as fd:\\n shutil.copyfileobj(fd, output)\",\n \"def zipfiles (downloadable, name):\\n\\n print \\\"compressing files. almost done.\\\"\\n import zipfile\\n for book in downloadable:\\n if (os.path.exists(os.path.join(name, book[1]))):\\n files = os.listdir(os.path.join(name, book[1]))\\n cbz = zipfile.ZipFile(os.path.join(name, name + '-' + book[1] + '.cbz'), 'w')\\n for file in files:\\n cbz.write(os.path.join(name, book[1],file))\\n cbz.close()\",\n \"def __extract_zip(self):\\n archive_binaries_dir = None\\n zip_file = zipfile.ZipFile(self.archive)\\n try:\\n extract_dir = tempfile.mkdtemp()\\n archive_binaries_dir = self.__create_extraction_dir(\\n zip_file.namelist(), extract_dir, zip_file.extract)\\n finally:\\n zip_file.close()\\n return archive_binaries_dir, extract_dir\",\n \"def extractZipFiles(rootDir, zipDir):\\n for root, dirs, files in os.walk(zipDir, topdown=False):\\n for name in files:\\n \\n zipFiles = os.path.join(root, name)\\n \\n #Check file extension here\\n if \\\".zip\\\" not in zipFiles:\\n continue\\n \\n else:\\n zipPath = zipfile.ZipFile(zipFiles, 'r')\\n #print(zipPath) \\n \\n filesInZip = zipPath.namelist()\\n i = 0 \\n for i in range(len(filesInZip)):\\n #print(filesInZip[i])\\n #print(zipPath.getinfo(filesInZip[i]))\\n \\n if \\\".mp3\\\" in filesInZip[i]:\\n zipPath.extract(filesInZip[i], rootDir)\\n print(\\\"{0} extracted to {1}\\\".format(filesInZip[i], rootDir))\\n\\n elif \\\".m4a\\\" in filesInZip[i]:\\n zipPath.extract(filesInZip[i], rootDir)\\n print(\\\"{0} extracted to {1}\\\".format(filesInZip[i], rootDir))\\n\\n elif \\\".mp4\\\" in filesInZip[i]:\\n zipPath.extract(filesInZip[i], rootDir)\\n print(\\\"{0} extracted to {1}\\\".format(filesInZip[i], rootDir))\\n\\n elif \\\".png\\\" in filesInZip[i]:\\n zipPath.extract(filesInZip[i], rootDir)\\n print(\\\"{0} extracted to {1}\\\".format(filesInZip[i], rootDir))\\n\\n elif \\\".jpg\\\" in filesInZip[i]:\\n zipPath.extract(filesInZip[i], rootDir)\\n print(\\\"{0} extracted to {1}\\\".format(filesInZip[i], rootDir))\\n \\n elif \\\".pdf\\\" in filesInZip[i]:\\n zipPath.extract(filesInZip[i], rootDir)\\n print(\\\"{0} extracted to {1}\\\".format(filesInZip[i], rootDir))\\n\\n else:\\n print(\\\"No media found in zip file {0}\\\".format(name))\\n \\n zipPath.close()\",\n \"def write_zip_content(content, out_path):\\n textract_ext = ('.doc', '.docx', '.epub', '.gif', '.htm', '.html', '.odt', '.pdf', '.rtf', '.txt')\\n z = zipfile.ZipFile(BytesIO(content))\\n unzipped_file_list = z.filelist\\n if not unzipped_file_list:\\n # if the archive's corrupted, this list is empty\\n return\\n try:\\n z.extractall(out_path)\\n except RuntimeError:\\n # occurs on password protected archives\\n return\\n file_list = []\\n for f in unzipped_file_list:\\n try:\\n file_name = f.filename\\n if not file_name.endswith('/'):\\n file_out_path = os.path.join(out_path, file_name)\\n if file_out_path.endswith(textract_ext):\\n file_list.append(file_out_path)\\n else:\\n # capturing as non-machine\\n file_list.append(file_out_path)\\n except AttributeError:\\n pass\\n file_list = [os.path.join(out_path, os.path.basename(f)) for f in file_list]\\n\\n return file_list\",\n \"def unpack_dir(indir, outdir, bands=None, clouds=None):\\r\\n archives = glob.glob(indir + '*.tar.gz')\\r\\n count = len(archives)\\r\\n for idx, archive in enumerate(archives):\\r\\n # Determine the outpath directory name for the unpacked landsat archive\\r\\n unpackDir = outdir + os.path.splitext(os.path.split(\\r\\n os.path.splitext(archive)[0])[1])[0]\\r\\n\\r\\n # Check if the directory already exists and make it if it doesn't\\r\\n if not os.path.exists(unpackDir):\\r\\n os.makedirs(unpackDir)\\r\\n\\r\\n # Unpack the current archive.\\r\\n unpack_landsat(archive, unpackDir, bands=bands,clouds=clouds)\\r\\n\\r\\n # Let the user know how progress is going.\\r\\n print(archive + ' unpacked (' + str(idx + 1) + ' of ' + str(count) + ')')\",\n \"def untar(filepath, outfoldername='.', compression='r', deletesource=False):\\n import tarfile\\n\\n with tarfile.open(filepath, compression) as tfile:\\n filelist = tfile.getnames()\\n tfile.extractall(path=outfoldername)\\n\\n if deletesource:\\n try:\\n os.remove(filepath)\\n except:\\n raise Exception(\\\"Could not delete tar archive {0}.\\\".format(filepath))\\n\\n return filelist\",\n \"def files_list(cls, url, apath, ffilter=[]):\\n files = []\\n\\n if apath not in cls._archives.keys():\\n cls._download(url, apath)\\n\\n _files = inspect(apath)\\n\\n for f in _files:\\n if is_matched(f, ffilter):\\n files.append(f)\\n\\n return files\",\n \"def concatenate_files(self, files):\\n entries = []\\n for f in files:\\n tree = ETree.parse(f)\\n\\n root = tree.getroot()\\n entries = root.findall(tags[\\\"entry\\\"])\\n\\n for entry in entries:\\n yield entry\",\n \"def contents(archive_id):\\n files = config.index.files(archive_id=archive_id)\\n print_files(files)\",\n \"def zip_repo(src_path, dest_path):\\n tar = tarfile.open(dest_path, \\\"w:gz\\\")\\n for file_name in glob.glob(os.path.join(src_path, \\\"*\\\")):\\n tar.add(file_name, os.path.basename(file_name))\\n\\n tar.close()\",\n \"def get_all_compressed_files_in_directory(directory: str):\\n\\n all_files_and_folders = os.listdir(directory)\\n\\n only_compressed_files = []\\n for file in all_files_and_folders:\\n if '.zip' in file or '.7z' in file:\\n only_compressed_files.append(file)\\n ...\\n\\n return only_compressed_files\",\n \"def unpackToProject(self,archive,project,progress=None):\\n progress = progress or bolt.Progress()\\n files = self.sortFiles([x[0] for x in self.fileSizeCrcs])\\n if not files: return 0\\n #--Clear Project\\n destDir = dirs['installers'].join(project)\\n if destDir.exists(): destDir.rmtree(safety='Installers')\\n #--Extract\\n progress(0,project.s+_(\\\"\\\\nExtracting files...\\\"))\\n self.unpackToTemp(archive,files,SubProgress(progress,0,0.9))\\n #--Move\\n progress(0.9,project.s+_(\\\"\\\\nMoving files...\\\"))\\n count = 0\\n tempDir = self.tempDir\\n for file in files:\\n srcFull = tempDir.join(file)\\n destFull = destDir.join(file)\\n if srcFull.exists():\\n srcFull.moveTo(destFull)\\n count += 1\\n self.clearTemp()\\n return count\",\n \"def archives(self, **kwargs):\\n return self.session.listArchives(**kwargs)\",\n \"def select_archive(self, recursive=True): # pragma: no cover\\n return self.select_by_ext(self._archive_ext, recursive)\",\n \"def unpack_archive(\\n filepath: types.PathLike, *, extract_dir: Optional[types.PathLike] = None\\n) -> types.PathLike:\\n filepath = utils.to_path(filepath).resolve()\\n if not extract_dir:\\n extract_dir = str(filepath.parent)\\n filepath = str(filepath)\\n os.makedirs(extract_dir, exist_ok=True)\\n is_zipfile = zipfile.is_zipfile(filepath)\\n is_tarfile = tarfile.is_tarfile(filepath)\\n if not is_zipfile and not is_tarfile:\\n LOGGER.debug(\\\"'%s' is not an archive\\\", filepath)\\n return extract_dir\\n else:\\n LOGGER.info(\\\"extracting data from archive file '%s'\\\", filepath)\\n shutil.unpack_archive(filepath, extract_dir=extract_dir, format=None)\\n # we want to rename the unpacked directory to a consistent value\\n # unfortunately, shutil doesn't pass this back to us\\n # so, we get the root path of all the constituent members\\n if is_zipfile:\\n with zipfile.ZipFile(filepath, mode=\\\"r\\\") as zf:\\n members = zf.namelist()\\n else:\\n with tarfile.open(filepath, mode=\\\"r\\\") as tf:\\n members = tf.getnames()\\n src_basename = os.path.commonpath(members)\\n dest_basename = os.path.basename(filepath)\\n if src_basename:\\n while True:\\n tmp, _ = os.path.splitext(dest_basename)\\n if tmp == dest_basename:\\n break\\n else:\\n dest_basename = tmp\\n if src_basename != dest_basename:\\n return shutil.move(\\n os.path.join(extract_dir, src_basename),\\n os.path.join(extract_dir, dest_basename),\\n )\\n else:\\n return os.path.join(extract_dir, src_basename)\\n else:\\n return extract_dir\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6960922","0.65000236","0.64723575","0.64007777","0.6359527","0.63576806","0.6291074","0.6273226","0.6227048","0.62031776","0.6190727","0.6112076","0.60922587","0.6081641","0.60304374","0.60125357","0.6003538","0.5969804","0.5898257","0.58356404","0.5832472","0.58100605","0.57368803","0.57018596","0.56539375","0.5651845","0.56438607","0.5607478","0.55948794","0.5575305","0.5564723","0.55627817","0.55620486","0.5548441","0.55471516","0.55166936","0.55066663","0.54869133","0.5473711","0.54717106","0.5456434","0.54512167","0.5427918","0.5423086","0.5405914","0.5394956","0.53932583","0.5350311","0.5336592","0.53202003","0.53185636","0.5313352","0.53121895","0.5307205","0.5305964","0.53047407","0.52942187","0.5290513","0.5284128","0.526297","0.52545327","0.5252843","0.52421623","0.5237956","0.52370375","0.52307326","0.52229005","0.5221822","0.5215897","0.5208515","0.52035296","0.5201619","0.5198399","0.51951975","0.51922333","0.51851374","0.5175878","0.51732147","0.51494783","0.5142489","0.51193607","0.5106536","0.5093769","0.50888306","0.50888306","0.5086288","0.50785834","0.5073548","0.5071256","0.5054267","0.503106","0.5023932","0.50083554","0.49946508","0.4967344","0.49581522","0.4945165","0.49405932","0.49300644","0.4927416"],"string":"[\n \"0.6960922\",\n \"0.65000236\",\n \"0.64723575\",\n \"0.64007777\",\n \"0.6359527\",\n \"0.63576806\",\n \"0.6291074\",\n \"0.6273226\",\n \"0.6227048\",\n \"0.62031776\",\n \"0.6190727\",\n \"0.6112076\",\n \"0.60922587\",\n \"0.6081641\",\n \"0.60304374\",\n \"0.60125357\",\n \"0.6003538\",\n \"0.5969804\",\n \"0.5898257\",\n \"0.58356404\",\n \"0.5832472\",\n \"0.58100605\",\n \"0.57368803\",\n \"0.57018596\",\n \"0.56539375\",\n \"0.5651845\",\n \"0.56438607\",\n \"0.5607478\",\n \"0.55948794\",\n \"0.5575305\",\n \"0.5564723\",\n \"0.55627817\",\n \"0.55620486\",\n \"0.5548441\",\n \"0.55471516\",\n \"0.55166936\",\n \"0.55066663\",\n \"0.54869133\",\n \"0.5473711\",\n \"0.54717106\",\n \"0.5456434\",\n \"0.54512167\",\n \"0.5427918\",\n \"0.5423086\",\n \"0.5405914\",\n \"0.5394956\",\n \"0.53932583\",\n \"0.5350311\",\n \"0.5336592\",\n \"0.53202003\",\n \"0.53185636\",\n \"0.5313352\",\n \"0.53121895\",\n \"0.5307205\",\n \"0.5305964\",\n \"0.53047407\",\n \"0.52942187\",\n \"0.5290513\",\n \"0.5284128\",\n \"0.526297\",\n \"0.52545327\",\n \"0.5252843\",\n \"0.52421623\",\n \"0.5237956\",\n \"0.52370375\",\n \"0.52307326\",\n \"0.52229005\",\n \"0.5221822\",\n \"0.5215897\",\n \"0.5208515\",\n \"0.52035296\",\n \"0.5201619\",\n \"0.5198399\",\n \"0.51951975\",\n \"0.51922333\",\n \"0.51851374\",\n \"0.5175878\",\n \"0.51732147\",\n \"0.51494783\",\n \"0.5142489\",\n \"0.51193607\",\n \"0.5106536\",\n \"0.5093769\",\n \"0.50888306\",\n \"0.50888306\",\n \"0.5086288\",\n \"0.50785834\",\n \"0.5073548\",\n \"0.5071256\",\n \"0.5054267\",\n \"0.503106\",\n \"0.5023932\",\n \"0.50083554\",\n \"0.49946508\",\n \"0.4967344\",\n \"0.49581522\",\n \"0.4945165\",\n \"0.49405932\",\n \"0.49300644\",\n \"0.4927416\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62739277"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":83184,"cells":{"query":{"kind":"string","value":"Convert tar of multiple FASTAs to one file."},"document":{"kind":"string","value":"def extract_tarball(fname, outfile=None, concat=True) -> Union[str, None]:\n fnames = []\n # Extract files to temporary directory\n tmp_dir = mkdtemp(dir=os.path.dirname(outfile))\n with tarfile.open(fname) as tar:\n tar.extractall(path=tmp_dir)\n for root, _, files in os.walk(tmp_dir):\n fnames += [os.path.join(root, fname) for fname in files]\n\n if len(fnames) > 1 and not concat:\n raise ValueError(\"tarball contains multiple files, but concat not specified!\")\n\n # Concatenate (also works woth one file)\n with open(outfile, \"w\") as out:\n for infile in fnames:\n for line in open(infile):\n out.write(line)\n\n rm_rf(tmp_dir)\n\n return outfile"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def create_tar(self):\n with tarfile.open(self.tgzfile, \"w:gz\") as tar_handle:\n for root, _, files in os.walk(self.dirname):\n for file in files:\n tar_handle.add(os.path.join(root, file))","def combine_fasta_files(fastas_paths, out_file):\n with open(out_file, 'w') as out:\n for filename in fastas_paths:\n for seq_record in SeqIO.parse(filename, \"fasta\"):\n out.write('>' + str(seq_record.id) + '\\n' + str(seq_record.seq) + '\\n')","def tarList(files, display = False):\n\tfrom os.path import commonprefix, split, normpath, relpath\n\tfrom tarfile import open as openTar\n\t\n\ttarFile = BytesIO()\n\ttarArchive = openTar(fileobj=tarFile, mode=\"w\")\n\tprefix = split(normpath(commonprefix(files)))[0]\n\tfor i in files:\n\t\ttry:\n\t\t\tif display:\n\t\t\t\tprint (\"Add %s\"%relpath(i,prefix))\n\t\t\ttarArchive.add(i,relpath(i,prefix))\n\t\texcept IOError:\n\t\t\tprint ('! Failed to add \"%s\"'%i)\n\ttarArchive.close()\n\treturn tarFile.getvalue()","def pack_tar(output_filename, sources, type='gz'):\n if type == 'tgz':\n type = 'gz'\n elif type == 'tar':\n type = ''\n tar_ds = tarfile.open(output_filename, 'w:' + type)\n if not isinstance(sources, (list, tuple)) and \\\n isinstance(sources, str):\n sources = [sources]\n for source in sources:\n tar_ds.add(source, arcname=os.path.basename(source))\n tar_ds.close()","def _decompress_tarball(*, in_fileobj, out_fileobj):\n with tarfile.open(fileobj=in_fileobj, mode=\"r\") as it, tarfile.open(\n fileobj=out_fileobj, mode=\"w|\"\n ) as ot:\n for member in it.getmembers():\n extracted = it.extractfile(member)\n ot.addfile(member, extracted)","def extract_tars(file_pattern, path_in, path_out):\n for f in glob.glob(os.path.join(path_in, file_pattern)):\n shutil.unpack_archive(f, path_out)","def tar_file_and_group(data):\n for sample in data:\n assert \"stream\" in sample\n stream = tarfile.open(fileobj=sample[\"stream\"], mode=\"r|*\")\n prev_prefix = None\n example = {}\n valid = True\n for tarinfo in stream:\n name = tarinfo.name\n pos = name.rfind(\".\")\n assert pos > 0\n prefix, postfix = name[:pos], name[pos + 1 :]\n if prev_prefix is not None and prefix != prev_prefix:\n example[\"key\"] = prev_prefix\n if valid:\n yield example\n example = {}\n valid = True\n with stream.extractfile(tarinfo) as file_obj:\n try:\n if postfix == \"txt\":\n example[\"txt\"] = file_obj.read().decode(\"utf8\").strip()\n elif postfix in AUDIO_FORMAT_SETS:\n waveform, sample_rate = torchaudio.load(file_obj)\n example[\"wav\"] = waveform\n example[\"sample_rate\"] = sample_rate\n else:\n example[postfix] = file_obj.read()\n except Exception as ex:\n valid = False\n logging.warning(\"error to parse {}\".format(name))\n prev_prefix = prefix\n if prev_prefix is not None:\n example[\"key\"] = prev_prefix\n yield example\n stream.close()\n if \"process\" in sample:\n sample[\"process\"].communicate()\n sample[\"stream\"].close()","def compress_files(time_stamp, files_to_be_appended):\n process = subprocess.run([\"tar\", \"-czf\", f\"connect-log.{time_stamp}.tar.gz\", files_to_be_appended[0],\n files_to_be_appended[1],\n files_to_be_appended[2],\n files_to_be_appended[3], files_to_be_appended[4]], capture_output=True)","def safetar_extractall(tarf, *args, **kwargs):\r\n return tarf.extractall(members=safemembers(tarf), *args, **kwargs)","async def create_tarball(output_path: str) -> bytes:\n file_paths = []\n for root, _, filenames in os.walk(output_path):\n for filename in filenames:\n file_path = os.path.join(root, filename)\n log.info(f'Adding {file_path} to tarball.')\n file_paths.append(file_path)\n\n with ByteStream() as stream:\n with tarfile.TarFile.open(fileobj=stream, mode='w:gz',\n compresslevel=1) as tar:\n for file_path in file_paths:\n tar_info = tar.gettarinfo(name=file_path)\n tar.addfile(tar_info)\n # Yield the header for the tarinfo file.\n yield stream.pop()\n\n with open(file_path, 'rb') as in_fp:\n # Read the input file in chunks of stream.block_size bytes.\n while True:\n data = in_fp.read(stream.block_size)\n if len(data) > 0:\n # Write the data to the buffer.\n tar.fileobj.write(data)\n # Yield a compressed file chunk so the client can receive it.\n yield stream.pop()\n # Write padding if necessary.\n if len(data) < stream.block_size:\n blocks, remainder = divmod(tar_info.size, tarfile.BLOCKSIZE)\n if remainder > 0:\n tar.fileobj.write(tarfile.NUL * (tarfile.BLOCKSIZE - remainder))\n yield stream.pop()\n blocks += 1\n tar.offset += blocks * tarfile.BLOCKSIZE\n break\n\n # Yield end-of-archive marker.\n yield stream.pop()","def put_files(container, files):\n ts = io.BytesIO()\n t = tarfile.TarFile(mode='w', fileobj=ts)\n for ft in files:\n fp = None\n fc = None\n fm = None\n if len(ft) == 3:\n fp, fc, fm = ft\n else:\n fp, fc = ft\n fs = io.BytesIO()\n fs.write(fc)\n fs.seek(0)\n fi = tarfile.TarInfo(name=fp)\n fi.size = len(fs.getvalue())\n if fm:\n fi.mode = fm\n t.addfile(tarinfo=fi, fileobj=fs)\n t.close()\n ts.seek(0)\n return dockerClient.put_archive(container=container, path=\"/\", data=ts)","def archive_files(archive_fileprefix, flist, zip_type, reldir, prefix=\"\"):\n def archive_filter(tinfo):\n fdir, fbase = os.path.split(tinfo.name)\n archpath = os.path.join(prefix, os.path.relpath(tinfo.name, reldir))\n tinfo.name = archpath\n return tinfo\n write_type = 'w:'+zip_type\n\n if zip_type:\n archive_filename = '{}.tar.{}'.format(archive_fileprefix, zip_type)\n else:\n archive_filename = '{}.tar'.format(archive_fileprefix)\n\n with tarfile.open(archive_filename, write_type) as out_file:\n for f in flist:\n out_file.add(f, filter=archive_filter)","def extractTar(tar_file):\r\n\r\n tfile = tarfile.open(tar_file, 'r')\r\n tar_members = tfile.getmembers()\r\n for tar_member in tar_members:\r\n tar_member.name = os.path.basename(tar_member.name) # Strip out the path and keep just the file name\r\n tfile.extract(tar_member, path=\"tempdata/\")\r\n tfile.close()\r\n print \"Finished extracting tar file\"\r\n return","def archive(self, files, name):\n self.log.debug(\"Putting files into archive: %s\" % \"\\n\".join(files))\n tar_name = \"%s%s\" % (name, self.extension)\n if os.path.exists(tar_name):\n raise RuntimeError (\"Tried to create an archive that already exists: %s\" % tar_name) \n else:\n self.log.info(\"Creating a new archive %s\" % tar_name)\n tar = tarfile.open(tar_name, 'w:gz');\n for name in files:\n tar.add(name)\n print '%s'% (name)\n tar.close()\n return tar_name","def gz_tar(full_prefix):\n tarfile = os.path.join(outputdir, full_prefix + '.tar')\n try:\n with open(tarfile, 'rb') as f_in, gzip.open(tarfile + '.gz', 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)\n os.remove(tarfile)\n except Exception as e:\n log.error(\"Tarfile {0} was not generated. Module(s) run collected no info?\".format(tarfile))\n log.error(e)\n\n return tarfile + '.gz'","def merge_ncRNA_fastas():\n\tmerge_cmnd = \"cat %s %s %s > %s\" % (rRNA_fasta_file, fasta_outfile, tRNA_fasta_outfile, ncRNA_output_fasta)\n\tprint merge_cmnd\n\tos.system(merge_cmnd)\n\n\tindex_cmnd = \"samtools faidx %s\" % (ncRNA_output_fasta)\n\tprint index_cmnd\n\tos.system(index_cmnd)","def __extract_tgz(self):\n tar_file = tarfile.open(self.archive)\n try:\n extract_dir = tempfile.mkdtemp()\n archive_binaries_dir = self.__create_extraction_dir(\n tar_file.getnames(), extract_dir, tar_file.extract)\n finally:\n tar_file.close()\n return archive_binaries_dir, extract_dir","def write_tarball(args, tarfilename, archivefiles=[]):\n if not archivefiles:\n return None\n \n manifest_filename, manifest_uuid = render_manifest(args, archivefiles)\n try:\n with tarfile.open(tarfilename, f\"{FILE_FLAG}:gz\") as tarball:\n file_count = 0\n for fname in archivefiles:\n LOG.debug(f\"Adding {fname} to {tarfilename}: \")\n if fname.endswith(\".csv\"):\n upload_name = f\"{manifest_uuid}_openshift_usage_report.{file_count}.csv\"\n tarball.add(fname, arcname=upload_name)\n file_count += 1\n tarball.add(manifest_filename, arcname=\"manifest.json\")\n except FileExistsError as exc:\n LOG.critical(exc)\n sys.exit(2)\n LOG.info(f\"Wrote: {tarfilename}\")\n return f\"{tarfilename}\"","def write_seqs_fasta(out_fp_seqs_fasta: str, out_fp_seqs_qza: str,\n tsv_pd: pd.DataFrame, tsv_fp: str = '') -> str:\n with open(out_fp_seqs_fasta, 'w') as fas_o:\n for seq in tsv_pd.index:\n fas_o.write('>%s\\n%s\\n' % (seq.strip(), seq.strip()))\n cmd = '# Write features as fasta file:\\n'\n cmd += '# - Features from: %s\\n' % tsv_fp\n cmd += '# Snippet:\\n'\n cmd += '# ```:\\n'\n cmd += \"# with open(fasta_out, 'w') as o:\\n\"\n cmd += \"# for seq in tsv_pd.index:\\n\"\n cmd += \"# o.write('>%s\\\\n%s\\\\n' % (seq.strip(), seq.strip()))\\n\"\n cmd += '# ```:\\n'\n cmd += run_import(\n out_fp_seqs_fasta, out_fp_seqs_qza, 'FeatureData[Sequence]')\n return cmd","def make_fastq_multi(in_fasta, quals, out_fp,\r\n label_transform=split_lib_transform):\r\n mkdir(out_fp)\r\n seen_libs = defaultdict(list)\r\n for rec, label in iter_fastq(in_fasta, quals, label_transform):\r\n lib_id, seq_id = label.rsplit('_', 1)\r\n seen_libs[lib_id].append(rec)\r\n for lib, recs in seen_libs.items():\r\n if lib is None: # skip the seqs we couldn't assign to a library\r\n continue\r\n outfile = open(out_fp + '/' + lib + '.fastq', 'w')\r\n outfile.write('\\n'.join(recs))\r\n outfile.close()","def _cat_multi_vol_zip(src, dst):\n concat_cmd = \"zip -s 0 {} --out {}\".format(src, dst)\n os.system(concat_cmd)","def tar_file(self, name, contents, mtime=None):\n length = len(contents)\n tar_data = self.tar_file_header(name, length, mtime=mtime)\n tar_data += contents\n tar_data += self.tar_file_padding(length)\n return tar_data","def _build_collection_tar(\n b_collection_path, # type: bytes\n b_tar_path, # type: bytes\n collection_manifest, # type: CollectionManifestType\n file_manifest, # type: FilesManifestType\n): # type: (...) -> str\n files_manifest_json = to_bytes(json.dumps(file_manifest, indent=True), errors='surrogate_or_strict')\n collection_manifest['file_manifest_file']['chksum_sha256'] = secure_hash_s(files_manifest_json, hash_func=sha256)\n collection_manifest_json = to_bytes(json.dumps(collection_manifest, indent=True), errors='surrogate_or_strict')\n\n with _tempdir() as b_temp_path:\n b_tar_filepath = os.path.join(b_temp_path, os.path.basename(b_tar_path))\n\n with tarfile.open(b_tar_filepath, mode='w:gz') as tar_file:\n # Add the MANIFEST.json and FILES.json file to the archive\n for name, b in [(MANIFEST_FILENAME, collection_manifest_json), ('FILES.json', files_manifest_json)]:\n b_io = BytesIO(b)\n tar_info = tarfile.TarInfo(name)\n tar_info.size = len(b)\n tar_info.mtime = int(time.time())\n tar_info.mode = 0o0644\n tar_file.addfile(tarinfo=tar_info, fileobj=b_io)\n\n for file_info in file_manifest['files']: # type: ignore[union-attr]\n if file_info['name'] == '.':\n continue\n\n # arcname expects a native string, cannot be bytes\n filename = to_native(file_info['name'], errors='surrogate_or_strict')\n b_src_path = os.path.join(b_collection_path, to_bytes(filename, errors='surrogate_or_strict'))\n\n def reset_stat(tarinfo):\n if tarinfo.type != tarfile.SYMTYPE:\n existing_is_exec = tarinfo.mode & stat.S_IXUSR\n tarinfo.mode = 0o0755 if existing_is_exec or tarinfo.isdir() else 0o0644\n tarinfo.uid = tarinfo.gid = 0\n tarinfo.uname = tarinfo.gname = ''\n\n return tarinfo\n\n if os.path.islink(b_src_path):\n b_link_target = os.path.realpath(b_src_path)\n if _is_child_path(b_link_target, b_collection_path):\n b_rel_path = os.path.relpath(b_link_target, start=os.path.dirname(b_src_path))\n\n tar_info = tarfile.TarInfo(filename)\n tar_info.type = tarfile.SYMTYPE\n tar_info.linkname = to_native(b_rel_path, errors='surrogate_or_strict')\n tar_info = reset_stat(tar_info)\n tar_file.addfile(tarinfo=tar_info)\n\n continue\n\n # Dealing with a normal file, just add it by name.\n tar_file.add(\n to_native(os.path.realpath(b_src_path)),\n arcname=filename,\n recursive=False,\n filter=reset_stat,\n )\n\n shutil.copy(to_native(b_tar_filepath), to_native(b_tar_path))\n collection_name = \"%s.%s\" % (collection_manifest['collection_info']['namespace'],\n collection_manifest['collection_info']['name'])\n tar_path = to_text(b_tar_path)\n display.display(u'Created collection for %s at %s' % (collection_name, tar_path))\n return tar_path","def cat_files(files, output):\n for file in files:\n with open(file, 'r') as fd:\n shutil.copyfileobj(fd, output)","def cat_files(files, output):\n for file in files:\n with open(file, 'r') as fd:\n shutil.copyfileobj(fd, output)","def zip_files(file_list, output_path):\n bname = os.path.basename # for efficiency\n with zipfile.ZipFile(output_path, mode='w') as zf:\n # adding all fasta files\n for file_name in file_list:\n zf.write(file_name, bname(file_name))\n return output_path","def Parse_folder_to_multi_faa(target_dir,faa_filename):\n os.chdir(target_dir)\n output_handle = open(faa_filename, \"w\")\n for gbk_filename in FileGen(target_dir):\n with open(gbk_filename, \"r\") as input_handle:\n for seq_record in SeqIO.parse(input_handle, \"genbank\") :\n print(\"Dealing with GenBank record %s\" % seq_record.id)\n for seq_feature in seq_record.features :\n if seq_feature.type==\"CDS\" :\n assert len(seq_feature.qualifiers['translation'])==1\n try:\n name = seq_feature.qualifiers['locus_tag'][0]\n except KeyError:\n name = seq_feature.qualifiers['product'][0]\n output_handle.write(\">%s from %s\\n%s\\n\" % (\n name,\n gbk_filename.split(\"/\")[-1],\n seq_feature.qualifiers['translation'][0])) \n output_handle.close()","def tar(self, out=sys.stdout, config=None, *args, **kw):\r\n if config is not None:\r\n config = self.manifest.config_schema.validate(config)\r\n if self.manifest.get(\"templates\"):\r\n templates_dir = self.copy(templates=True)\r\n for template in self.find(templates=True):\r\n EJSTemplate(templates_dir + template).apply(templates_dir + template, config)\r\n tar = tarfile.open(\"\", mode=\"w|\", fileobj=out)\r\n templates = self.manifest.get(\"templates\")\r\n for path in self.find(*args, **kw):\r\n if config and path in templates:\r\n real_path = templates_dir + path\r\n EJSTemplate(real_path).apply(real_path, config)\r\n else:\r\n real_path = self.unchroot_path(path)\r\n tar.add(real_path, path, recursive=False)\r\n tar.close()","def extract_all(tarobj):\n for member in tarobj.getmembers():\n tarobj.extract(member)","def _write_to_tar(self, dtype_out_time):\n # When submitted in parallel and the directory does not exist yet\n # multiple processes may try to create a new directory; this leads\n # to an OSError for all processes that tried to make the\n # directory, but were later than the first.\n try:\n os.makedirs(self.dir_tar_out)\n except OSError:\n pass\n # tarfile 'append' mode won't overwrite the old file, which we want.\n # So open in 'read' mode, extract the file, and then delete it.\n # But 'read' mode throws OSError if file doesn't exist: make it first.\n utils.io.dmget([self.path_tar_out])\n with tarfile.open(self.path_tar_out, 'a') as tar:\n pass\n with tarfile.open(self.path_tar_out, 'r') as tar:\n old_data_path = os.path.join(self.dir_tar_out,\n self.file_name[dtype_out_time])\n try:\n tar.extract(self.file_name[dtype_out_time],\n path=old_data_path)\n except KeyError:\n pass\n else:\n # The os module treats files on archive as non-empty\n # directories, so can't use os.remove or os.rmdir.\n shutil.rmtree(old_data_path)\n retcode = subprocess.call([\n \"tar\", \"--delete\", \"--file={}\".format(self.path_tar_out),\n self.file_name[dtype_out_time]\n ])\n if retcode:\n msg = (\"The 'tar' command to save your aospy output \"\n \"exited with an error. Most likely, this is due \"\n \"to using an old version of 'tar' (especially if \"\n \"you are on a Mac). Consider installing a newer \"\n \"version of 'tar' or disabling tar output by \"\n \"setting `write_to_tar=False` in the \"\n \"`calc_exec_options` argument of \"\n \"`submit_mult_calcs`.\")\n logging.warn(msg)\n with tarfile.open(self.path_tar_out, 'a') as tar:\n tar.add(self.path_out[dtype_out_time],\n arcname=self.file_name[dtype_out_time])","def _make_tar_gz_file(output_filename, source_dir):\n with tarfile.open(output_filename, \"w:gz\") as tar:\n for f in os.listdir(source_dir):\n tar.add(os.path.join(source_dir, f), arcname=f)","def image_to_tgz(image, quiet):\n\n temp_dir = tempfile.mkdtemp()\n tar_file = path.join(temp_dir, path.basename(image) + '.tar')\n tar_gz_file = tar_file + '.gz'\n\n cmd = ['singularity', 'export', '-f', tar_file, image]\n\n if not quiet:\n sys.stderr.write(\"Exporting image to .tar\\n\")\n\n try:\n subprocess.check_call(cmd)\n except (subprocess.CalledProcessError, OSError) as e:\n raise ImageException(\"Error calling Singularity export to create .tar file\\n%s\" % e.message)\n\n cmd = ['gzip', tar_file]\n\n if not quiet:\n sys.stderr.write(\"Compressing to .tar.gz\\n\")\n\n try:\n subprocess.check_call(cmd)\n except subprocess.CalledProcessError as e:\n raise ImageException(\"Error calling gzip export to compress .tar file\\n%s\" % e.message)\n\n return (temp_dir, tar_gz_file)","def extract_all(fn,dst=\".\"):\r\n if tarfile.is_tarfile(fn): \r\n with tarfile.open(fn,'r') as tf:\r\n tf.extractall(dst)\r\n tf.close()\r\n elif zipfile.is_zipfile(fn):\r\n with zipfile.ZipFile(fn, 'r') as zf:\r\n zf.extractall(dst)\r\n zf.close()\r\n else:\r\n print( \"Please provide a tar archive file or zip file\" )","def _tar_with_filter(\n path: Path,\n tar_filter: Callable[[tarfile.TarInfo], Optional[tarfile.TarInfo]],\n) -> io.BytesIO:\n tarstream = io.BytesIO()\n with tarfile.TarFile(fileobj=tarstream, mode='w') as tar:\n tar.add(name=str(path), arcname='/', filter=tar_filter)\n tarstream.seek(0)\n\n return tarstream","def convert_single_to_multi(file_directory):\n all_files = os.listdir(file_directory)\n merged_file = ''\n for file_name in all_files:\n f_single = open(file_directory + '/' + file_name, \"r\")\n data = f_single.read() + '\\n'\n merged_file += data\n date = datetime.datetime.now()\n save_seq_file(('multi_fasta_' + str(date).split(' ')[0]), merged_file, file_directory)","def convert_fastq_to_fastore(fwd_reads, rev_reads, output_prefix, num_threads=multiprocessing.cpu_count()):\n if output_prefix is None:\n output_prefix = os.path.basename(fwd_reads)\n output_prefix = re.sub(FASTQ_PATTERN, '', output_prefix)\n\n cmd = [\n 'fastore_compress.sh', '--lossless',\n '--out', output_prefix,\n '--threads', str(num_threads),\n '--in', fwd_reads\n ]\n if rev_reads is not None:\n cmd.extend(['--pair', rev_reads])\n\n subprocess.check_call(cmd)\n\n return (f'{output_prefix}.cmeta', f'{output_prefix}.cdata')","def _MockTarList(self, files):\n self.rc_mock.AddCmdResult(\n partial_mock.ListRegex('tar -tf'), output='\\n'.join(files))","def make_fastq_single(in_fasta, quals, out_fp,\r\n label_transform=split_lib_transform):\r\n outfile = open(out_fp, 'w')\r\n for rec, seq_id in iter_fastq(in_fasta, quals, label_transform):\r\n outfile.write(rec + '\\n')\r\n outfile.close()","def fasta2MSF():\n path = \"./data/\"\n for file in os.listdir(path):\n if file.endswith(\".fa\") or file.endswith(\".fasta\"):\n os.chdir(path)\n try:\n filecore = file.rstrip(\".fa\")\n except:\n filecore = file.rstrip(\".fasta\")\n fileout = filecore + \".msf2\"\n \n seqret = os.system(\"seqret fasta::\" + file + \\\n \" msf::\" + fileout)\n print seqret\n \n outmsf = filecore + \".msf\"\n out = open(outmsf, \"w\")\n op = open(fileout, \"r\")\n msf = op.readlines()\n op.close()\n for line in msf:\n if line[0] == \"\\n\":\n print >> out, line.rstrip(\"\\n\")\n elif line[0] != \"!\" and line[0] != \"/\" and \\\n line[0] != \"\\n\":\n line = line.replace(\".\", \"-\")\n line = line.replace(\"~\", \"-\")\n print >> out, line.rstrip(\"\\n\") \n else:\n print >> out, line.rstrip(\"\\n\")\n out.close()\n \n # remove the comment if you want to remove the\n # original file\n #os.remove(file)\n \n os.remove(fileout)\n os.chdir(\"../\")\n return","def make_tar(self, package, input_dir, build_dir, add_args=None):\n tar = self.options.tar_command\n\n # Generate the .tar.gz file\n filename = package + '.tar.gz'\n out_file = open(os.path.join(build_dir, filename), \"w\")\n args = [tar, '--format=gnu', '--exclude-vcs', '-C', build_dir]\n if self.config.get('tar', {}).get('ignore', []):\n for patt in self.config['tar']['ignore']:\n args += ['--exclude', patt]\n if add_args:\n args += add_args\n args += ['-c', input_dir]\n logging.debug(\"Creating %s\", filename)\n tar_proc = subprocess.Popen(args, stdout=subprocess.PIPE)\n gzip_proc = subprocess.Popen(['gzip', '-9'], stdin=tar_proc.stdout,\n stdout=out_file)\n\n if tar_proc.wait() != 0 or gzip_proc.wait() != 0:\n logging.error(\"tar/gzip failed, exiting\")\n sys.exit(1)\n out_file.close()\n logging.info('%s written', filename)\n return filename","def untar(file_path, target_dir=None, gzipped=True, verbose=False):\n return posix.untar(file_path, target_dir, gzipped, verbose)","def untar(tar_path, cleanup=False):\n tfile = tarfile.open(tar_path, 'r')\n tfile.extractall(os.path.dirname(tar_path))\n tfile.close()\n if cleanup:\n os.remove(tar_path)","def get_two_type(raw_file, tar_file):\n with open(tar_file, 'w') as target:\n with open(raw_file, 'r') as file:\n for line in file:\n items = line.strip().split('\\t')\n if items[2] is '1':\n continue\n elif items[2] is '2':\n items[2] = '1'\n line = '\\t'.join(items)\n target.write(line + '\\n')\n else:\n target.write(line)\n\n print('done!')","def extract_tarball(fileobj, path, callback=None):\n tar_cmd = [\"tar\", \"-zx\", \"--directory=%s\" % path]\n tar_proc = make_subprocess(tar_cmd, stderr=True, stdin=True)\n\n try:\n while True:\n chunk = fileobj.read(CHUNK_SIZE)\n if chunk == '':\n break\n\n if callback:\n callback(chunk)\n\n tar_proc.stdin.write(chunk)\n except Exception:\n try_kill_process(tar_proc)\n raise\n\n finish_subprocess(tar_proc, tar_cmd)","def testTarBundling(self):\n try:\n tP = os.path.join(self.__workPath, \"t0.tar.gz\")\n dirPath = os.path.join(self.__inpDirPath, \"topdir\")\n\n ok = self.__fileU.bundleTarfile(tP, [dirPath], mode=\"w:gz\", recursive=True)\n self.assertTrue(ok)\n\n numBytes = self.__fileU.size(tP)\n self.assertGreaterEqual(numBytes, 250)\n #\n md5 = self.__fileU.hash(tP, hashType=\"md5\")\n self.assertTrue(md5 is not None)\n #\n ok = self.__fileU.unbundleTarfile(tP, dirPath=self.__workPath)\n self.assertTrue(ok)\n #\n tP = os.path.join(self.__workPath, \"t1.tar.gz\")\n dirPathList = [os.path.join(self.__inpDirPath, \"topdir\", \"subdirA\"), os.path.join(self.__inpDirPath, \"topdir\", \"subdirB\")]\n\n ok = self.__fileU.bundleTarfile(tP, dirPathList, mode=\"w:gz\", recursive=True)\n self.assertTrue(ok)\n #\n ok = self.__fileU.unbundleTarfile(tP, dirPath=self.__workPath)\n self.assertTrue(ok)\n\n tP = os.path.join(self.__workPath, \"t2.tar\")\n dirPathList = [os.path.join(self.__inpDirPath, \"topdir\", \"subdirA\"), os.path.join(self.__inpDirPath, \"topdir\", \"subdirB\")]\n\n ok = self.__fileU.bundleTarfile(tP, dirPathList, mode=\"w\", recursive=True)\n self.assertTrue(ok)\n #\n ok = self.__fileU.unbundleTarfile(tP, dirPath=self.__workPath)\n self.assertTrue(ok)\n\n except Exception as e:\n logger.exception(\"Failing with %s\", str(e))\n self.fail()","def get_tar_files(self, loc_id):\n if self.storage_type == 's3':\n conn = boto3.client('s3')\n bucket_name = self.source_path.split('//')[1].split('/')[0]\n prefix = self.source_path.split(bucket_name+'/')[1]+'/'+loc_id\n s3_result = conn.list_objects_v2(Bucket=bucket_name, Prefix=prefix, Delimiter=\"/\")\n if 'Contents' not in s3_result:\n # print(s3_result)\n return []\n\n tar_files = []\n for key in s3_result['Contents']:\n tar_files.append(key['Key'])\n\n else:\n file_path = os.path.join(self.source_path, loc_id)\n tar_files = [os.path.join(file_path, f)\n for f in os.listdir(file_path) if 'tar' in f]\n return tar_files","def create_tarball(fileobj, path, callback=None, compression_level=None):\n tar_cmd = [\"tar\", \"-zc\", \"--directory=%s\" % path, \".\"]\n env = os.environ.copy()\n if compression_level and 1 <= compression_level <= 9:\n env[\"GZIP\"] = \"-%d\" % compression_level\n tar_proc = make_subprocess(tar_cmd, stdout=True, stderr=True, env=env)\n\n try:\n while True:\n chunk = tar_proc.stdout.read(CHUNK_SIZE)\n if chunk == '':\n break\n\n if callback:\n callback(chunk)\n\n if fileobj:\n fileobj.write(chunk)\n except Exception:\n try_kill_process(tar_proc)\n raise\n\n finish_subprocess(tar_proc, tar_cmd)","def to_fastq(self, prefix='', threads=1):\n # Write to uncompressed FASTQ for speed\n fastqs = [\n f'{prefix}_{i+1}.fastq.gz' if prefix else f'{i+1}.fastq.gz'\n for i in range(self.technology.n_files)\n ]\n logger.info(f'Splitting BAM file into FASTQs {\", \".join(fastqs)}')\n logger.warning('All quality scores will be converted to F')\n files = []\n lengths = [0, 0, 0]\n for substring in self.technology.barcode_positions + self.technology.umi_positions:\n lengths[substring.file\n ] = max(lengths[substring.file], substring.stop)\n\n try:\n for fastq in fastqs:\n files.append(open_as_text(fastq, 'w'))\n\n # Count total number only if the bam is local\n parse = urlparse(self.path)\n if not parse.scheme:\n with pysam.AlignmentFile(self.path, 'rb', threads=threads) as f:\n count = f.count(until_eof=True)\n logger.info(f'Detected {count} BAM entries')\n else:\n logger.warning((\n 'Skip counting total BAM entries in remote BAM. '\n 'This means a progress bar can not be displayed.'\n ))\n\n with pysam.AlignmentFile(self.path, 'rb', threads=threads) as f,\\\n tqdm() if parse.scheme else tqdm(total=count) as pbar:\n for item in f.fetch(until_eof=True):\n reads = ['N' * l for l in lengths] # noqa\n barcodes, umis, sequence = BAM.EXTRACT_FUNCTIONS[\n self.technology.name](item) # noqa\n\n # Set sequence.\n reads[self.technology.reads_file.file] = sequence\n\n # Barcode and UMI\n for barcode, substring in zip(\n barcodes, self.technology.barcode_positions):\n bc = reads[substring.file]\n reads[\n substring.file\n ] = f'{bc[:substring.start]}{barcode}{bc[substring.stop:]}'\n for umi, substring in zip(umis,\n self.technology.umi_positions):\n u = reads[substring.file]\n reads[\n substring.file\n ] = f'{u[:substring.start]}{umi}{u[substring.stop:]}'\n\n # Write to each file.\n for file, read in zip(files, reads):\n file.write(f'@{item.query_name}\\n')\n file.write(f'{read.upper()}\\n')\n file.write('+\\n')\n file.write(f'{\"F\" * len(read)}\\n')\n\n pbar.update(1)\n\n finally:\n for file in files:\n file.close()\n\n return fastqs, [\n OrderedTechnology(self.technology, tuple(range(len(fastqs))))\n ]","def _extract_data(inputs):\n filename, split = inputs\n for name, fobj in tfds.download.iter_archive(\n filename, tfds.download.ExtractMethod.TAR_STREAM\n ):\n split_name = name.split(\"_\")\n if len(split_name) > 2 and split_name[2] == split:\n yield [name, fobj.read()]","def getTarBall(self, exe):\n self.tgzNameWithPath = common.work_space.pathForTgz()+self.tgz_name\n if os.path.exists(self.tgzNameWithPath):\n return self.tgzNameWithPath\n\n # Prepare a tar gzipped file with user binaries.\n self.buildTar_(exe)\n\n return string.strip(self.tgzNameWithPath)","def parse_multifasta_file(file, number_of_fastas):\n\n with open(file) as file:\n for i in range(number_of_fastas):\n fasts_seq = ''\n fasta_name = file.readline().strip()[1:]\n end_of_file = False\n end_of_seq = False\n while not end_of_seq and not end_of_file:\n x = file.tell()\n seq = file.readline()\n if not seq:\n end_of_file = True\n elif '>' not in seq:\n fasts_seq = fasts_seq + seq\n else:\n file.seek(x)\n end_of_seq = True\n fasts_seq = re.sub(r'\\n', '', fasts_seq)\n yield fasta_name, fasts_seq","def create_RCSB_fastas(file):\n folder_path = create_folder(file)\n filepath = RAWDATA_PATH + file\n with open(filepath, 'r') as raw_file:\n raw_data = raw_file.read()\n chains = raw_data.split('>')\n cache = []\n for chain in chains[1:]:\n head = chain[:4] # for SCOP\n chain_number = chain[5]\n prefix_pos = 27 # for SCOP\n prefix = chain[:prefix_pos]\n sequence = chain[prefix_pos:]\n sequence = sequence.replace('\\n', '')\n assert prefix[6:] == '|PDBID|CHAIN|SEQUENCE', 'Unknown prefix'\n if chain_number < 'A' or chain_number > 'Z': # invalid chain\n continue\n elif sequence in cache: # same chain\n continue\n if not cache: # new protein\n cache = [head, sequence]\n elif head != cache[0]: # new protein\n protein_sequence = ''\n for cached_sequence in cache[1:]:\n protein_sequence += cached_sequence\n if len(protein_sequence) > 300:\n new_fasta = open('{0}\\{1}.txt'.format(folder_path, head), 'w')\n new_fasta.write('>' + chain[:prefix_pos] + '\\n')\n new_fasta.write(protein_sequence)\n new_fasta.close\n cache = [head, sequence]\n cache.append(sequence)\n new_fasta = open('{0}\\{1}.txt'.format(folder_path, head), 'w')\n new_fasta.write('>' + chain[:prefix_pos] + '\\n')\n for cached_sequence in cache[1:]:\n new_fasta.write(cached_sequence)\n new_fasta.close","def tar(self, folders, tarfile):\n if not folders:\n raise ValueError('folders must be set')\n if not tarfile:\n raise ValueError('tarfile must be set')\n with OpenShell(self._conn) as os:\n if log.isEnabledFor(logging.DEBUG):\n RemoteOperation.run(os, 'tar -cvf %s %s' % (tarfile, ' '.join(folders)))\n else:\n RemoteOperation.run(os, 'tar -cf %s %s' % (tarfile, ' '.join(folders)))","def _outside_tar2(self):\r\n outside_tar = self.unsafe_common_dir / \"unsafe_file.tar.gz\"\r\n with tarfile.open(outside_tar, \"w:gz\") as tar:\r\n tar.addfile(tarfile.TarInfo(str(self.unsafe_common_dir / \"../a_file\")))\r\n\r\n return outside_tar","def _extract_fastas_from_fast5(self):\n\t\tfor id, h5path in fastq_paths[self.version].iteritems():\n\t\t\ttry:\n\t\t\t\ttable = self.hdf5file[h5path % self.group]\n\t\t\t\tfa = formats.Fasta(table['Fastq'][()])\n\t\t\t\tfa.name += \" \" + self.filename\n\t\t\t\tself.fastas[id] = fa\n\t\t\texcept Exception, e:\n\t\t\t\tpass","def convert_multi_to_single(file_directory):\n all_files = os.listdir(file_directory)\n for file_name in all_files:\n f_multi = open(file_directory + '/' + file_name, \"r\")\n for seq_record in SeqIO.parse(f_multi, \"fasta\"):\n seq_id = seq_record.id\n sequence = str(seq_record.seq)\n save_seq_file(seq_id, sequence, file_directory)","def create_tarballs_from_xml_files_in_folder(xml_dir, download_date=\"2017.11.02\"):\n\n xml_list = glob.glob(os.path.join(xml_dir, \"*.xml\"))\n\n for xml in xml_list:\n xml_renamed = xml[:-4] + \".BLAST.xml\"\n xml_tar_gz = xml[:-4] + \".BLAST.xml.tar.gz\"\n xml_txt = xml[:-4] + \"_details.txt\"\n # xml_txt = xml[:-4] + \".BLAST_details.txt\"\n\n if not os.path.isfile(xml_tar_gz):\n copyfile(xml, xml_renamed)\n acc = os.path.basename(xml).split(\".\")[0]\n sys.stdout.write(\"{}, \".format(acc))\n sys.stdout.flush()\n # create an empty text file with the download date\n date = strftime(\"%Y%m%d\")\n with open(xml_txt, \"w\") as f:\n f.write(\"acc\\t{}\\ndownload_date\\t{}\\ndatabase\\tncbi_nr\\ne_value\\t1\\n\".format(acc, download_date))\n\n with tarfile.open(xml_tar_gz, mode='w:gz') as tar:\n # add the files to the compressed tarfile\n tar.add(xml_renamed, arcname=os.path.basename(xml_renamed))\n tar.add(xml_txt, arcname=os.path.basename(xml_txt))\n\n # delete the original files\n try:\n os.remove(xml_renamed)\n os.remove(xml_txt)\n except:\n sys.stdout.write(\"{} could not be deleted\".format(xml_renamed))","def merge_walkupseq_files(latest_tsca_id):\n paths = glob.glob('walkupseq_files/*sample_info*')\n\n dfs = []\n for f in paths:\n tmp = pd.read_table(f, encoding='latin1')\n dfs.append(tmp)\n\n df = pd.concat(dfs, axis=0)\n df.to_csv('walkupseq_files/walkupseq_all_combined_%s.txt'%latest_tsca_id, sep=\"\\t\", index=None)\n return df","def hdf5_concatenate_core17(job_tuple):\n\n proj_folder, top_folder, db_name, run, clone = job_tuple\n path = os.path.join(proj_folder,\"RUN%d/CLONE%d/\"%(run,clone))\n top = md.load(os.path.join(top_folder,\"%d.pdb\"%run))\n output_filename = os.path.join(proj_folder,\"trajectories/%d_%d.hdf5\"%(run,clone))\n\n glob_input = os.path.join(path, \"results-*.tar.bz2\")\n filenames = glob.glob(glob_input)\n filenames = sorted(filenames, key=keynat)\n\n if len(filenames) <= 0:\n return\n\n trj_file = HDF5TrajectoryFile(output_filename, mode='a')\n\n try:\n trj_file._create_earray(where='/', name='processed_filenames',atom=trj_file.tables.StringAtom(1024), shape=(0,))\n trj_file.topology = top.topology\n except trj_file.tables.NodeError:\n pass\n\n for filename in filenames:\n if six.b(filename) in trj_file._handle.root.processed_filenames: # On Py3, the pytables list of filenames has type byte (e.g. b\"hey\"), so we need to deal with this via six.\n print(\"Already processed %s\" % filename)\n continue\n with enter_temp_directory():\n print(\"Processing %s\" % filename)\n archive = tarfile.open(filename, mode='r:bz2')\n try:\n archive.extract(\"positions.xtc\")\n trj = md.load(\"positions.xtc\", top=top)\n for frame in trj:\n trj_file.write(coordinates=frame.xyz, cell_lengths=frame.unitcell_lengths, cell_angles=frame.unitcell_angles)\n trj_file._handle.root.processed_filenames.append([filename])\n except:\n #something wrong with the current trajectory file. Warn and return immediately\n warnings.warn(\"Problem at %s.Stopping trajectory here\"%filename)\n return\n return","def unzip_and_untar(item):\n print(\"Unpacking %s\" % item)\n\n f = tarfile.open(item, mode=\"r\")\n f.extractall(path=\"working\")\n f.close()","def createSequenceFile(sequences, tmpDir, filename='seq.fa'):\n seqfile = os.path.join(tmpDir, filename)\n with open(seqfile, 'w') as f:\n for name, sequence in sequences.iteritems():\n f.write(\">{}\\n{}\\n\".format(name, sequence))\n subprocess.call(\"pyfasta flatten {}\".format(seqfile), shell=True)\n return seqfile","def test_write_combined_fasta(self):\r\n\r\n mapping_data = {'%s' % basename(self.fasta1_fp): 'Sample1',\r\n '%s' % basename(self.fasta2_fp): 'Sample2',\r\n '%s' % basename(self.fasta3_fp): 'Sample3'\r\n }\r\n\r\n fasta_fps = [self.fasta2_fp, self.fasta3_fp, self.fasta1_fp]\r\n\r\n write_combined_fasta(mapping_data, fasta_fps, self.output_dir,\r\n counter=100)\r\n\r\n output_fp = open(join(self.output_dir, \"combined_seqs.fna\"), \"U\")\r\n output_lines = [line.strip() for line in output_fp]\r\n\r\n expected_output_lines = ['>Sample2_100 label3 ZZZ', 'AACGYAACGAGA',\r\n '>Sample2_101 label4', 'ACAGAGAGAGGGGAGA',\r\n '>Sample3_102 label5 ;LKJ', 'ACAGGGATTTTTAT',\r\n '>Sample1_103 label1 XXX', 'ACAGATTACGA',\r\n '>Sample1_104 label2 YYY', 'ACATAAAATAGCCGGAG'\r\n ]\r\n\r\n self.assertEqual(output_lines, expected_output_lines)","def gatherfiles(self):\n\t\tfrom subprocess import Popen,PIPE\n\t\timport os\n\t\timport tarfile\n\t\timport glob\n\t\t\n\t\tprint \"=== \",self.nameID,\": Joining all the files in one\"\n\t\t# FIXME: Only there are 1 file, not needed the hadd\n\t\tfinalfile = os.path.join(\"Results\",self.outputfile)\n\t\t# FIXED BUG: just cp when there is only one file, otherwise\n\t\t# there are problems with the TTree\n\t\tif len(self.outputfiles) == 1:\n\t\t\t# Note that when there is only 1 file, always its #task=1\n\t\t\tcommand = [ 'cp', self.outputfiles[1], finalfile ]\n\t\telse:\n\t\t\tcommand = [ 'haddPlus', finalfile ]\n\t\t\tfor f in self.outputfiles.itervalues():\n\t\t\t\tcommand.append( f )\n\t\tp = Popen( command ,stdout=PIPE,stderr=PIPE ).communicate()\n\t\t# Checking if everything was allright\n\t\ttotalevts = self.getevents(finalfile,True)\n\t\tif totalevts != self.nevents:\n\t\t\tmessage = \"\\033[33;1mclustermanager.gatherfiles: WARNING\\033[0m the total file\"\n\t\t\tmessage += \"'\"+finalfile+\"' do not contain all the events:\\n\"\n\t\t\tmessage += \"Total events to be processed:\"+str(self.nevents)+\"\\n\"\n\t\t\tmessage += \"Total events in '\"+finalfile+\"':\"+str(totalevts)+\"\\n\"\n\t\t\tprint message\n\t\t\treturn \n\t\t# If everything was fine, deleting the files \n\t\t# and cleaning the directory\n\t\tfor f in self.outputfiles.itervalues():\n\t\t\tos.remove( f )\n\t\t# Taring and compressing\n\t\tfilestotar = glob.glob(\"./*.*\")\n\t\tfilestotar.append( \".storedmanager\")\n\t\ttar = tarfile.open(os.path.basename(self.cwd)+\".tar.gz\",\"w:gz\")\n\t\tfor f in filestotar:\n\t\t\ttar.add(f)\n\t\ttar.close()\n\t\t# if everything was fine, deleting the files\n\t\tif os.path.exists(os.path.basename(self.cwd)+\".tar.gz\"):\n\t\t\tfor f in filestotar:\n\t\t\t\tos.remove(f)\n\t\telse:\n\t\t\tmessage = \"\\033[33;1mclustermanager.gatherfiles: WARNING\\033[0m I can't manage\\n\"\n\t\t\tmessage += \"to create the backup .tar.gz file\\n\"\n\t\t\tprint message\n\n\t\tprint \"Created \"+finalfile\n\t\tprint \"========= Process Completed =========\"","def unpack_landsat(inpath, outpath, bands=None, clouds=None):\r\n tfile = tarfile.open(inpath,'r:gz')\r\n if bands is None:\r\n #Extract all of the bands.\r\n tfile.extractall(outpath);\r\n else:\r\n #Extract just the bands specified.\r\n\r\n #Get the names of the members of the archive\r\n names = tfile.getnames()\r\n\r\n #Make sure the bands are given as a list\r\n bands = list(bands)\r\n\r\n #Find those elements of the archive that match the bands specified\r\n #\t(plus metadata file)\r\n members = tfile.getmembers()\r\n elements = []\r\n blist = ''.join(str(i) for i in bands)\r\n if clouds:\r\n patternStr = '.*_B[' + blist + ']\\.TIF|.*_MTL.txt|.*_band[' + blist + \\\r\n ']\\.tif|.*_cfmask.*\\.tif|.*\\.xml|.*cloud.*\\.tif'\r\n else:\r\n patternStr = '.*_B[' + blist + ']\\.TIF|.*_MTL.txt|.*_band[' + blist + \\\r\n ']\\.tif|.*_cfmask.*\\.tif|.*\\.xml'\r\n\r\n pattern = re.compile(patternStr)\r\n for i, name in enumerate(names):\r\n if pattern.match(name):\r\n elements.append(members[i])\r\n tfile.extractall(outpath,members = elements)\r\n\r\n '''\r\n Note: the below section was written with the intention of\r\n adding valuable metadata info to the .TIF files themselves.\r\n This theoretically allows easy retreival of key metadata info,\r\n but the method to set new metadata seems unreliable. Appears to\r\n be an open issue, but there may be a solution. For now, assume\r\n this does not work.\r\n\r\n #Now we loop through each output, adding important metadata.\r\n #Fetch metadata and make sure there is only one file.\r\n meta = glob.glob(outpath + '/*_MTL.txt')\r\n if len(meta) > 1:\r\n raise('MORE THAN ONE METADATA FILE FOUND!')\r\n\r\n metadata = read_metadata(meta[0])\r\n\r\n #Add the metadata.\r\n for tif in glob.glob(outpath + '*.TIF'):\r\n #Open the tif file\r\n ras = gdal.Open(tif)\r\n\r\n #Preserve any existing metadata & add important metadata from file\r\n meta = ras.GetMetadata()\r\n meta['SCENE_CENTER_TIME'] = metadata['SCENE_CENTER_TIME']\r\n meta['DATE_ACQUIRED'] = metadata['DATE_ACQUIRED']\r\n meta['LANDSAT_SCENE_ID'] = metadata['LANDSAT_SCENE_ID']\r\n\r\n #Now write the new metadata back to the tif.\r\n ras.SetMetadata(meta)\r\n ras.FlushCache()\r\n ras = None\r\n '''","def untar(conn, tarball, path):\n conn.run(f\"tar xf {tarball} -C {path}\")","def generate_archive_file(location, paths, environment=None, compression=None, archive_format=None):\n if archive_format == 'zip':\n archive = ZipTarWrapper(location.name, 'w', zipfile.ZIP_DEFLATED)\n else:\n write_type = \"w\"\n if compression:\n write_type = \"w|{0}\".format(compression)\n archive = tarfile.open(location.name, write_type)\n\n # Add all the things to the archive\n for path_spec in paths:\n path_spec.add_to_tar(archive, environment)\n\n # Finish the zip\n archive.close()\n\n return archive","def tar_job(self):\n curr_dir = os.getcwd()\n\n os.chdir(self.temp_project_path)\n logging.log(level=logging.INFO, msg=\"Tarring up Filesystem and Environment\")\n tar_name = f\"{self.project_id}_fs\"\n tar_persistor = TarPersistor(base_file_name=tar_name,\n folder=\".\",\n paths_to_tar=os.listdir(),\n extract_path=False)\n _ = tar_persistor.persist()\n\n os.chdir(curr_dir)\n\n tar_path = os.path.join(self.temp_project_path, tar_name) + \".tar\"\n return tar_path","def do_pack():\n\n now = datetime.now()\n # format the name of the file with the timestamps\n now_year = now.year\n now_month = now.month\n now_day = now.day\n now_hour = now.hour\n now_minute = now.minute\n now_second = now.second\n # apply the format\n file_name = 'versions/web_static_{}{}{}{}{}{}.tgz'.format(\n now_year, now_month, now_day, now_hour, now_minute, now_second\n )\n # All archives must be stored in the folder versions\n local('mkdir -p versions')\n # execute locally the compression of the folder\n command = local(\"tar -cvzf \" + file_name + \" ./web_static/\")\n # return the archive path if the archive has been correctly generated\n if command.succeeded:\n return file_name\n else:\n return None","def inBoth(from_files):\n t_nof1 = []\n f_nof1 = []\n array_of_times = []\n for file in from_files:\n item = file.replace('_COMPLETE', '')\n if item in to_files:\n to = os.path.join('/ToNof1/archive', item)\n from_nof1 = os.path.join('/FromNof1', file)\n t_nof1.append(to)\n f_nof1.append(from_nof1)\n\n\n\n with open(\"TAT_From_Nof1.tsv\", 'w') as f:\n i = 0\n myHeader = \"Completed File\\tCompleted Time\\tSent File\\tSent Time\\tDelta\\n\"\n f.write(myHeader)\n while i < len(to_files):\n today = datetime.today()\n\n fName = os.path.basename(f_nof1[i])\n tName = os.path.basename(t_nof1[i])\n\n fTime = getDate(f_nof1[i])\n tTime = getDate(t_nof1[i])\n\n duration = (today - fTime)\n if duration.days < 90:\n delta = fTime - tTime\n seconds = (delta.total_seconds())\n minutes = seconds / 60.0\n hours = minutes / 60.0\n array_of_times.append(hours)\n delta = str(delta)\n fTime = str(fTime)\n tTime = str(tTime)\n myString = (fName + \"\\t\" + fTime + \"\\t\" + tName + \"\\t\" + tTime + \"\\t\" + delta + \"\\n\")\n f.write(myString)","def _fifo_tar(self):\r\n fifop = self.unsafe_common_dir / \"fifo.file\"\r\n fifo_tar = self.unsafe_common_dir / \"fifo.tar.gz\"\r\n os.mkfifo(fifop)\r\n with tarfile.open(fifo_tar, \"w:gz\") as tar:\r\n tar.add(fifop)\r\n\r\n return fifo_tar","def tar_cz_relative(*path):\n file_out = io_BytesIO()\n tar = tarfile_open(mode = \"w:gz\", fileobj = file_out)\n for p in path:\n tar.add(p, arcname='./')\n tar.close()\n return file_out.getvalue()","def do_pack():\n files = 'versions/web_static_{}{}{}{}{}{}.tgz'\\\n .format(T.year, T.month, T.day, T.hour, T.minute, T.second)\n local('mkdir -p versions')\n execute = local(\"tar -cvzf \" + files + \" ./web_static/\")\n if execute.succeeded:\n return files\n return None","def extract_sources(tarsources=[], zipsources=[]):\n for source in tarsources:\n cmd = [\"tar\", \"-xvf\", source, \"-C\", WHEEL_BUILD_DIR]\n subprocess.check_call(cmd)\n\n for source in zipsources:\n cmd = [\"unzip\", source, \"-d\", WHEEL_BUILD_DIR]\n subprocess.check_call(cmd)","def handle_tar(file_path, extension, extracted_path, destination_directory):\n tar = tarfile.open(file_path, extension)\n # remove files if they already exist\n if os.path.exists(extracted_path):\n shutil.rmtree(extracted_path)\n tar.extractall(path=destination_directory)\n tar.close()","def concatenate_multilane_files(files, prompt):\n\n def _concatenate_group(group, first_elem):\n \"\"\"Concatenate all the files on the list and return the target file path.\"\"\"\n target_file_name = re.sub(pattern_lane_num, r\"\\1\", os.path.basename(first_elem))\n target_path = os.path.join(tempfile.gettempdir(), target_file_name)\n\n # Overwriting all files by default\n with open(target_path, \"wb\") as outf:\n for fname in group:\n with open(fname, \"rb\") as inf:\n # TODO: check for newline at the end of file first?\n shutil.copyfileobj(inf, outf)\n return target_path\n\n groups = _find_multilane_groups(files)\n\n if not groups:\n return files\n\n perform_concat = True\n if prompt:\n answer = click.confirm(\n \"This data appears to have been split across multiple sequencing lanes.\\nConcatenate lanes before upload?\",\n default=\"Y\",\n )\n if not answer:\n perform_concat = False\n\n if not perform_concat:\n return files\n\n files = files[:]\n pattern_lane_num = re.compile(r\"[._]L\\d+([._])\")\n\n for group in groups:\n # The groups considered here will already have more than 1 element\n first_elem = group[0]\n if isinstance(first_elem, tuple):\n concat_fwd = _concatenate_group([fwd for fwd, _ in group], first_elem[0])\n concat_rev = _concatenate_group([rev for _, rev in group], first_elem[1])\n files.append((concat_fwd, concat_rev))\n elif isinstance(first_elem, str):\n concat = _concatenate_group(group, first_elem)\n files.append(concat)\n\n for elem in group:\n files.remove(elem)\n\n return files","def expand_alma_sftp_tarball(key, source_obj):\n source_tar = tarfile.open(fileobj=io.BytesIO(source_obj), mode=\"r:gz\")\n if len(source_tar.getmembers()) == 0:\n LOGGER.error(\"S3 Object is empty.\")\n LOGGER.error(key)\n return None\n\n if len(source_tar.getmembers()) > 1:\n LOGGER.error(\"S3 Object has more than 1 member, which is unexpected.\")\n LOGGER.error(key)\n return None\n\n for item in source_tar:\n return source_tar.extractfile(item).read()","def _unpack_tar(self, dir, filters):\n try:\n unpackArchive = gbpc.UnpackTarArchive(self.path, dir, filters)\n unpackArchive()\n except gbpc.CommandExecFailed:\n # unpackArchive already printed an error message\n raise GbpError","def assemble_file(names):\n md5 = hashlib.md5()\n filename = ''.join([name.split('-')[-1] for name in names])\n fpath = os.path.join(FILES_DIR, filename)\n with open(fpath, \"wb\") as dst:\n for name in names:\n for chunk in chunked_reader(os.path.join(DATA_DIR, name)):\n md5.update(chunk)\n dst.write(chunk)\n\n return fpath, md5.digest().hex()","def test_make_fna(self):\r\n fna_fp = os.path.join(self.sff_dir, 'test.fna')\r\n fna_gz_fp = os.path.join(self.gz_sff_dir, 'test_gz.fna')\r\n make_fna(self.sff_fp, fna_fp)\r\n make_fna(self.sff_gz_fp, fna_gz_fp)\r\n self.assertEqual(open(fna_fp).read(), fna_txt)\r\n self.assertEqual(open(fna_gz_fp).read(), fna_txt)","def gzip_files(topDir, afni_file,localizerfile):\n\n print 'GZIPPING FILES...'\n\n command1 = \"gzip %s*BRIK\" % (topDir)\n command2 = \"gzip %s*HEAD\" % (topDir)\n command3 = \"gzip %s%s/pb00*\" % (topDir,afni_file)\n command4 = \"gzip %s%s/errts*\" % (topDir,afni_file)\n command5 = \"gzip %s%s/fitts*\" % (topDir,afni_file)\n command6 = \"gzip %s%s/*al*\" % (topDir,afni_file)\n command7 = \"gzip %s%s/*ns*\" % (topDir,afni_file)\n command8 = \"gzip %s%s/all_runs*\" % (topDir,afni_file)\n command9 = \"gzip %s%s/*mask*\" % (topDir,afni_file)\n command10 = \"gzip %s*nii\" % (topDir)\n command11 = \"gzip %s%s/pb01*\" % (topDir,afni_file)\n command12 = \"gzip %s%s/pb03*\" % (topDir,afni_file)\n command13 = \"gzip %s%s/pb02*\" % (topDir,afni_file)\n\n os.system(command1)\n os.system(command2)\n os.system(command3)\n os.system(command4)\n os.system(command5)\n os.system(command6)\n os.system(command7)\n os.system(command8)\n #os.system(command9)\n os.system(command10)\n os.system(command11)\n try:\n os.system(command12)\n except:\n print 'Could not gzip pb03 files'\n\n if localizerfile == 'facescene_loc':\n os.system(command13)","def _setup_input(self, g):\n tarbytes = io.BytesIO()\n with tempfile.NamedTemporaryFile() as f:\n g.serialize(f.name, format=\"turtle\")\n tar = tarfile.open(name=\"out.tar\", mode=\"w\", fileobj=tarbytes)\n tar.add(f.name, arcname=\"input.ttl\")\n tar.close()\n # seek to beginning so our file is not empty when docker sees it\n tarbytes.seek(0)\n return tarbytes","def extract_files(self, *filenames):\n for filename in filenames:\n data = self.read_file(filename)\n f = open(filename, 'wb')\n f.write(data or b'')\n f.close()","def merge_paired_fastqs(target, outdir):\n left, right = target.get_fastq()\n left_fq = join(outdir, target.system_id + \"_1.fq.gz\")\n right_fq = join(outdir, target.system_id + \"_2.fq.gz\")\n commands = []\n\n if is_gz_file(left[0]):\n commands += [f\"cat {' '.join(left)} > {left_fq}\"]\n commands += [f\"cat {' '.join(right)} > {right_fq}\"]\n else:\n commands += [f\"cat {' '.join(left)} | \" f\"gzip -c > {left_fq}\"]\n commands += [f\"cat {' '.join(right)} | \" f\"gzip -c > {right_fq}\"]\n\n remove = [f\"rm {left_fq} {right_fq}\"]\n\n return (left_fq, right_fq), commands, remove","def main():\n onlyfiles = [f for f in listdir(RAWDATA_PATH) if isfile(join(RAWDATA_PATH, f))]\n for file in onlyfiles:\n create_RCSB_fastas(file)","def _send_tarstream_to_node_and_extract(\n tarstream: io.BytesIO,\n node: Node,\n remote_path: Path,\n sudo: bool,\n) -> None:\n tar_path = Path('/tmp/dcos_e2e_tmp.tar')\n with tempfile.NamedTemporaryFile() as tmp_file:\n tmp_file.write(tarstream.getvalue())\n tmp_file.flush()\n\n node.send_file(\n local_path=Path(tmp_file.name),\n remote_path=tar_path,\n sudo=sudo,\n )\n\n tar_args = ['tar', '-C', str(remote_path), '-xvf', str(tar_path)]\n node.run(args=tar_args, sudo=sudo)\n node.run(args=['rm', str(tar_path)], sudo=sudo)","def compress_files(self):\n archive_file_path = tkinter.filedialog.asksaveasfilename(parent=self,\n defaultextension=\".zip\",\n filetypes=[(\"Zip File\", \"*.zip\")])\n treeview_items = self.files_treeview.get_children()\n if archive_file_path and treeview_items:\n with ZipFile(archive_file_path, \"w\", ZIP_DEFLATED) as archive:\n for row in treeview_items:\n file_path = self.files_treeview.item(row, \"values\")[0]\n file_name = os.path.basename(file_path)\n archive.write(file_path, arcname=file_name)","def export_fasta(self, metadata, analysistype, reportpath, cutoff, program):\n logging.info('Creating FASTA-formatted files of outputs')\n for sample in metadata:\n # Set the name of the FASTA output file\n sample[analysistype].fasta_output = os.path.join(reportpath, '{sn}_{prog}.fasta'.format(sn=sample.name,\n prog=analysistype))\n # Remove the file if it exists. Otherwise, if the samples are processed by the pipeline more than\n # once, the same results will be appended to the file\n try:\n os.remove(sample[analysistype].fasta_output)\n except FileNotFoundError:\n pass\n # Process the sample only if the script could find targets\n if sample[analysistype].blastresults != 'NA' and sample[analysistype].blastresults:\n # Open the FASTA output file in append mode\n with open(sample[analysistype].fasta_output, 'a+') as fasta_output:\n for target in sorted(sample[analysistype].targetnames):\n index = 0\n for hit in sample[analysistype].blastlist:\n if hit['subject_id'] == target:\n # Set the name and percent id to avoid writing out the dictionary[key] multiple times\n if float(hit['percent_match']) >= cutoff:\n # If the 'align' option was not specified, the .dnaseq attribute will be an empty\n # dictionary. Populate this attribute as required\n try:\n # The .dnaseq attribute will not exist for amino-acid based searches\n if program == 'blastn':\n fasta = sample[analysistype].dnaseq[target][index]\n else:\n # The .targetsequence attribute will be sufficient\n fasta = Seq(sample[analysistype].targetsequence[target][index])\n except (KeyError, IndexError):\n # Align the protein (and nucleotide) sequences to the reference\n sample = self.alignprotein(sample=sample,\n analysistype=analysistype,\n target=target,\n program=program,\n index=index,\n hit=hit)\n try:\n if program == 'blastn':\n fasta = sample[analysistype].dnaseq[target][index]\n else:\n fasta = Seq(sample[analysistype].targetsequence[target][index])\n except IndexError:\n fasta = str()\n # Create the SeqRecord of the FASTA sequence\n if fasta:\n try:\n record = SeqRecord(fasta,\n id='{name}_{target}'\n .format(name=sample.name,\n target=target),\n description='')\n # Write the FASTA-formatted record to file\n fasta_output.write(record.format('fasta'))\n except (AttributeError, TypeError):\n pass\n index += 1\n # Return the updated metadata object\n return metadata","def untar(tarfile, outdir):\n tmpdir = tempfile.mkdtemp()\n try:\n untared = _open_archive(tarfile, tmpdir)\n files = [f for f in untared if os.path.isfile(os.path.join(tmpdir, f))]\n dirs = [d for d in untared if os.path.isdir(os.path.join(tmpdir, d))]\n assert len(files) + len(dirs) == len(untared), 'Only files and directories'\n if _files_same(tmpdir, outdir, files) and _dirs_same(tmpdir, outdir, dirs):\n # Nothing new or different in the tarfile.\n return False\n # Some or all of the files / directories are new.\n _move_files(tmpdir, outdir, files)\n _move_dirs(tmpdir, outdir, dirs)\n return True\n finally:\n if os.path.isdir(tmpdir):\n shutil.rmtree(tmpdir)","def test_tb_extract_fastq():\n resource_path = os.path.join(os.path.dirname(__file__), \"data/\")\n fastq_file_1 = resource_path + \"tb.Human.SRR1658573_1.fastq\"\n fastq_file_2 = resource_path + \"tb.Human.SRR1658573_2.fastq\"\n gem_file = resource_path + \"tb.Human.GCA_000001405.22_gem.fasta.gem\"\n\n if not os.path.isfile(gem_file):\n generate_gem()\n\n with gzip.open(gem_file + '.gz', 'rb') as fgz_in:\n with open(gem_file, 'w') as f_out:\n f_out.write(fgz_in.read())\n\n with gzip.open(fastq_file_1 + '.gz', 'rb') as fgz_in:\n with open(fastq_file_1, 'w') as f_out:\n f_out.write(fgz_in.read())\n\n with gzip.open(fastq_file_2 + '.gz', 'rb') as fgz_in:\n with open(fastq_file_2, 'w') as f_out:\n f_out.write(fgz_in.read())\n\n assert os.path.isfile(fastq_file_1) is True\n assert os.path.getsize(fastq_file_1) > 0\n assert os.path.isfile(fastq_file_2) is True\n assert os.path.getsize(fastq_file_2) > 0","def untgz(tgz_filename, out_dir):\r\n logging.info(\"Source: %s\" % tgz_filename)\r\n tgz = TgzHelper(tgz_filename, out_dir)\r\n tgz.extract()","def _symlink_tar(self):\r\n outsidep = self.unsafe_common_dir / \"unsafe_file.txt\"\r\n symlinkp = self.unsafe_common_dir / \"symlink.txt\"\r\n symlink_tar = self.unsafe_common_dir / \"symlink.tar.gz\"\r\n outsidep.symlink(symlinkp)\r\n with tarfile.open(symlink_tar, \"w:gz\") as tar:\r\n tar.add(symlinkp)\r\n\r\n return symlink_tar","def compress_to_tgz(in_path, tgz_fp):\n t = tarfile.open(name = tgz_fp, mode = 'w:gz')\n t.add(in_path, path.basename(in_path))\n t.close()","def dump_cworld_tar(\n cooler_paths,\n out_path,\n):\n\n dataset_name = os.path.splitext(os.path.split(out_path)[1])[0]\n\n with tempfile.TemporaryDirectory() as cworld_tmp_path:\n for cooler_path in cooler_paths:\n res = cooler.Cooler(cooler_path).info[\"bin-size\"]\n os.mkdir(os.path.join(cworld_tmp_path, \"C-\" + str(res)))\n for iced, iced_label in [(True, \"iced\"), (False, \"raw\")]:\n folder_path = os.path.join(cworld_tmp_path, \"C-\" + str(res), iced_label)\n os.mkdir(folder_path)\n\n mat_path = os.path.join(\n folder_path,\n \"{}__C-{}-{}.matrix.gz\".format(dataset_name, res, iced_label),\n )\n\n dump_cworld(\n in_cooler=cooler_path, out=mat_path, iced=iced, iced_unity=False\n )\n\n with tarfile.open(out_path, mode=\"w\") as archive:\n archive.add(cworld_tmp_path, arcname=dataset_name, recursive=True)","def untar(filepath, outfoldername='.', compression='r', deletesource=False):\n import tarfile\n\n with tarfile.open(filepath, compression) as tfile:\n filelist = tfile.getnames()\n tfile.extractall(path=outfoldername)\n\n if deletesource:\n try:\n os.remove(filepath)\n except:\n raise Exception(\"Could not delete tar archive {0}.\".format(filepath))\n\n return filelist","def _process_fileobj(self,\n tar_file_obj: IO[bytes],\n object_node: graph.COSObject) -> None:\n with tarfile.open(fileobj=tar_file_obj) as tar_file:\n gz_file_names = [f.name for f in tar_file.getmembers()\n if f.name.endswith('.gz')]\n for gz_file_name in gz_file_names:\n gz_file_obj = tar_file.extractfile(gz_file_name)\n if gz_file_obj:\n oem_data = self._parse_oem_data(gz_file_obj)\n aso_id = self._get_aso_id_from_file_name(gz_file_name)\n self._save_oem(oem_data, aso_id, object_node)","def debianize( strFilename ):\n \n #~ data = gzip.GzipFile( strFilename ).read();\n #~ print data;\n #~ return;\n \n #~ data = gzip.open( strFilename ).read();\n #~ print data;\n #~ return; \n \n #~ uncompressedData = bz2.BZ2File(strFilename).read()\n #~ print str(uncompressedData)\n #~ return;\n \n #~ file = open( strFilename, 'rb' );\n #~ data = file.read();\n #~ file.close();\n #~ print debug.dumpHexa( data );\n \n #~ ar = tarfile.open(strFilename, 'r:*')\n #~ for item in ar:\n #~ print( str(item) );\n #~ print( \"%s:\" % item.name );\n #~ #print debug.dumpHexa(item.buf);\n #~ #print zlib.decompress(item.buf)\n #~ #print zlib.decompress(ar.extractfile(item).read())\n #~ data = ar.extractfile(item.name).read()\n #~ print data # works !\n #~ ar.close() \n #~ return;\n \n fileLists = [];\n file = open( strFilename );\n data = file.read();\n file.close();\n \n print( \"data len: %d\" % len( data ) );\n\n nDataCompressedOffset = 0; # 132\n\n # works fine on toto.gz\n #~ f = gzip.open(strFilename, 'rb')\n #~ file_content = f.read()\n #~ print file_content\n #~ f.close() \n \n #~ decompressor = bz2.BZ2Decompressor();\n #~ uncompressed = decompressor.decompress(data[nDataCompressedOffset:]);\n \n #~ uncompressed = zlib.decompress(data[nDataCompressedOffset:]);\n \n uncompressed = decompress( data );\n print( \"uncompressed: %s\" % str( uncompressed ) );","def targets_to_files(tinfoil, targets, with_includes=True):\n files = []\n if with_includes:\n cfg_included = tinfoil.config_data.getVar('BBINCLUDED', True).split()\n\n for target in targets:\n filename = tinfoil.get_recipe_file(target)\n files.append(filename)\n\n if with_includes:\n recipe_data = tinfoil.parse_recipe_file(filename)\n recipe_included = recipe_data.getVar('BBINCLUDED', True).split()\n final_included = [f for f in (set(recipe_included) - set(cfg_included)) if not f.endswith('.bbclass')]\n final_included.sort(key=lambda k: k.endswith('.bbappend'))\n\n files.extend(final_included)\n else:\n appends = tinfoil.get_file_appends(filename)\n files.extend(appends)\n\n return list(bbcmd.iter_uniq(bb.cache.virtualfn2realfn(f)[0] for f in files))","def get_archive(katfilenames):\n\timport requests\n\n\tfile_refs = []\n\tfor filename in katfilenames:\n\t\tif filename.startswith('s3'):\n\t\t\tres = requests.post(S3_URL, headers=S3_HEAD, data='{\"s3_ref\":\"%s\",\"ref_key\":\"Nope\"}'%(filename,))\n\t\t\turl = res.json()['url']\n\t\t\tres1 = requests.get(url)\n\t\t\toutfile = filename.split('/')[-1]\n\t\t\topen(outfile, 'wb').write(res1.content)\n\t\t\tfile_refs.append(outfile)\n\t\telse:\n\t\t\tfile_refs.append(filename)\n\treturn file_refs","def align_rasters(ref_raster, tar_raster, output_suffix):\n command = [\"gdalbuildvrt\", \"-te\"]\n hDataset = gdal.Open(ref_raster, gdal.GA_ReadOnly)\n if hDataset is None:\n return False\n adfGeoTransform = hDataset.GetGeoTransform(can_return_null=True)\n\n tif_file=tar_raster\n vrt_file = tif_file.replace('.tif', '.vrt')\n\n if adfGeoTransform is not None:\n dfGeoXUL = adfGeoTransform[0]\n dfGeoYUL = adfGeoTransform[3]\n dfGeoXLR = adfGeoTransform[0] + adfGeoTransform[1] * hDataset.RasterXSize + \\\n adfGeoTransform[2] * hDataset.RasterYSize\n dfGeoYLR = adfGeoTransform[3] + adfGeoTransform[4] * hDataset.RasterXSize + \\\n adfGeoTransform[5] * hDataset.RasterYSize\n xres = str(abs(adfGeoTransform[1]))\n yres = str(abs(adfGeoTransform[5]))\n\n subprocess.call(command + [str(dfGeoXUL), str(dfGeoYLR), str(dfGeoXLR),\n str(dfGeoYUL), \"-q\", \"-tr\", xres, yres,\n vrt_file, tif_file])\n\n output_file = tif_file.replace('.tif', output_suffix)\n\n print('gdal_translate -q {} {}'.format(vrt_file, output_file))\n\n cmd = 'gdal_translate -q {} {}'.format(vrt_file, output_file)\n\n #print(dfGeoXUL, dfGeoYLR, dfGeoXLR, dfGeoYUL, xres, yres)\n\n subprocess.call(cmd, shell=True)\n os.remove(vrt_file)\n\n return True\n\n else:\n\n return False","def tarsum(input_file, hash, output_file):\n tar = tarfile.open(mode=\"r:*\", fileobj=input_file)\n\n chunk_size = 100*1024\n store_digests = {}\n\n for member in tar:\n if not member.isfile():\n continue\n f = tar.extractfile(member)\n h = hashlib.new(hash)\n data = f.read(chunk_size)\n while data:\n h.update(data)\n data = f.read(chunk_size)\n output_file.write(\"%s %s\\n\" % (h.hexdigest(), member.name))"],"string":"[\n \"def create_tar(self):\\n with tarfile.open(self.tgzfile, \\\"w:gz\\\") as tar_handle:\\n for root, _, files in os.walk(self.dirname):\\n for file in files:\\n tar_handle.add(os.path.join(root, file))\",\n \"def combine_fasta_files(fastas_paths, out_file):\\n with open(out_file, 'w') as out:\\n for filename in fastas_paths:\\n for seq_record in SeqIO.parse(filename, \\\"fasta\\\"):\\n out.write('>' + str(seq_record.id) + '\\\\n' + str(seq_record.seq) + '\\\\n')\",\n \"def tarList(files, display = False):\\n\\tfrom os.path import commonprefix, split, normpath, relpath\\n\\tfrom tarfile import open as openTar\\n\\t\\n\\ttarFile = BytesIO()\\n\\ttarArchive = openTar(fileobj=tarFile, mode=\\\"w\\\")\\n\\tprefix = split(normpath(commonprefix(files)))[0]\\n\\tfor i in files:\\n\\t\\ttry:\\n\\t\\t\\tif display:\\n\\t\\t\\t\\tprint (\\\"Add %s\\\"%relpath(i,prefix))\\n\\t\\t\\ttarArchive.add(i,relpath(i,prefix))\\n\\t\\texcept IOError:\\n\\t\\t\\tprint ('! Failed to add \\\"%s\\\"'%i)\\n\\ttarArchive.close()\\n\\treturn tarFile.getvalue()\",\n \"def pack_tar(output_filename, sources, type='gz'):\\n if type == 'tgz':\\n type = 'gz'\\n elif type == 'tar':\\n type = ''\\n tar_ds = tarfile.open(output_filename, 'w:' + type)\\n if not isinstance(sources, (list, tuple)) and \\\\\\n isinstance(sources, str):\\n sources = [sources]\\n for source in sources:\\n tar_ds.add(source, arcname=os.path.basename(source))\\n tar_ds.close()\",\n \"def _decompress_tarball(*, in_fileobj, out_fileobj):\\n with tarfile.open(fileobj=in_fileobj, mode=\\\"r\\\") as it, tarfile.open(\\n fileobj=out_fileobj, mode=\\\"w|\\\"\\n ) as ot:\\n for member in it.getmembers():\\n extracted = it.extractfile(member)\\n ot.addfile(member, extracted)\",\n \"def extract_tars(file_pattern, path_in, path_out):\\n for f in glob.glob(os.path.join(path_in, file_pattern)):\\n shutil.unpack_archive(f, path_out)\",\n \"def tar_file_and_group(data):\\n for sample in data:\\n assert \\\"stream\\\" in sample\\n stream = tarfile.open(fileobj=sample[\\\"stream\\\"], mode=\\\"r|*\\\")\\n prev_prefix = None\\n example = {}\\n valid = True\\n for tarinfo in stream:\\n name = tarinfo.name\\n pos = name.rfind(\\\".\\\")\\n assert pos > 0\\n prefix, postfix = name[:pos], name[pos + 1 :]\\n if prev_prefix is not None and prefix != prev_prefix:\\n example[\\\"key\\\"] = prev_prefix\\n if valid:\\n yield example\\n example = {}\\n valid = True\\n with stream.extractfile(tarinfo) as file_obj:\\n try:\\n if postfix == \\\"txt\\\":\\n example[\\\"txt\\\"] = file_obj.read().decode(\\\"utf8\\\").strip()\\n elif postfix in AUDIO_FORMAT_SETS:\\n waveform, sample_rate = torchaudio.load(file_obj)\\n example[\\\"wav\\\"] = waveform\\n example[\\\"sample_rate\\\"] = sample_rate\\n else:\\n example[postfix] = file_obj.read()\\n except Exception as ex:\\n valid = False\\n logging.warning(\\\"error to parse {}\\\".format(name))\\n prev_prefix = prefix\\n if prev_prefix is not None:\\n example[\\\"key\\\"] = prev_prefix\\n yield example\\n stream.close()\\n if \\\"process\\\" in sample:\\n sample[\\\"process\\\"].communicate()\\n sample[\\\"stream\\\"].close()\",\n \"def compress_files(time_stamp, files_to_be_appended):\\n process = subprocess.run([\\\"tar\\\", \\\"-czf\\\", f\\\"connect-log.{time_stamp}.tar.gz\\\", files_to_be_appended[0],\\n files_to_be_appended[1],\\n files_to_be_appended[2],\\n files_to_be_appended[3], files_to_be_appended[4]], capture_output=True)\",\n \"def safetar_extractall(tarf, *args, **kwargs):\\r\\n return tarf.extractall(members=safemembers(tarf), *args, **kwargs)\",\n \"async def create_tarball(output_path: str) -> bytes:\\n file_paths = []\\n for root, _, filenames in os.walk(output_path):\\n for filename in filenames:\\n file_path = os.path.join(root, filename)\\n log.info(f'Adding {file_path} to tarball.')\\n file_paths.append(file_path)\\n\\n with ByteStream() as stream:\\n with tarfile.TarFile.open(fileobj=stream, mode='w:gz',\\n compresslevel=1) as tar:\\n for file_path in file_paths:\\n tar_info = tar.gettarinfo(name=file_path)\\n tar.addfile(tar_info)\\n # Yield the header for the tarinfo file.\\n yield stream.pop()\\n\\n with open(file_path, 'rb') as in_fp:\\n # Read the input file in chunks of stream.block_size bytes.\\n while True:\\n data = in_fp.read(stream.block_size)\\n if len(data) > 0:\\n # Write the data to the buffer.\\n tar.fileobj.write(data)\\n # Yield a compressed file chunk so the client can receive it.\\n yield stream.pop()\\n # Write padding if necessary.\\n if len(data) < stream.block_size:\\n blocks, remainder = divmod(tar_info.size, tarfile.BLOCKSIZE)\\n if remainder > 0:\\n tar.fileobj.write(tarfile.NUL * (tarfile.BLOCKSIZE - remainder))\\n yield stream.pop()\\n blocks += 1\\n tar.offset += blocks * tarfile.BLOCKSIZE\\n break\\n\\n # Yield end-of-archive marker.\\n yield stream.pop()\",\n \"def put_files(container, files):\\n ts = io.BytesIO()\\n t = tarfile.TarFile(mode='w', fileobj=ts)\\n for ft in files:\\n fp = None\\n fc = None\\n fm = None\\n if len(ft) == 3:\\n fp, fc, fm = ft\\n else:\\n fp, fc = ft\\n fs = io.BytesIO()\\n fs.write(fc)\\n fs.seek(0)\\n fi = tarfile.TarInfo(name=fp)\\n fi.size = len(fs.getvalue())\\n if fm:\\n fi.mode = fm\\n t.addfile(tarinfo=fi, fileobj=fs)\\n t.close()\\n ts.seek(0)\\n return dockerClient.put_archive(container=container, path=\\\"/\\\", data=ts)\",\n \"def archive_files(archive_fileprefix, flist, zip_type, reldir, prefix=\\\"\\\"):\\n def archive_filter(tinfo):\\n fdir, fbase = os.path.split(tinfo.name)\\n archpath = os.path.join(prefix, os.path.relpath(tinfo.name, reldir))\\n tinfo.name = archpath\\n return tinfo\\n write_type = 'w:'+zip_type\\n\\n if zip_type:\\n archive_filename = '{}.tar.{}'.format(archive_fileprefix, zip_type)\\n else:\\n archive_filename = '{}.tar'.format(archive_fileprefix)\\n\\n with tarfile.open(archive_filename, write_type) as out_file:\\n for f in flist:\\n out_file.add(f, filter=archive_filter)\",\n \"def extractTar(tar_file):\\r\\n\\r\\n tfile = tarfile.open(tar_file, 'r')\\r\\n tar_members = tfile.getmembers()\\r\\n for tar_member in tar_members:\\r\\n tar_member.name = os.path.basename(tar_member.name) # Strip out the path and keep just the file name\\r\\n tfile.extract(tar_member, path=\\\"tempdata/\\\")\\r\\n tfile.close()\\r\\n print \\\"Finished extracting tar file\\\"\\r\\n return\",\n \"def archive(self, files, name):\\n self.log.debug(\\\"Putting files into archive: %s\\\" % \\\"\\\\n\\\".join(files))\\n tar_name = \\\"%s%s\\\" % (name, self.extension)\\n if os.path.exists(tar_name):\\n raise RuntimeError (\\\"Tried to create an archive that already exists: %s\\\" % tar_name) \\n else:\\n self.log.info(\\\"Creating a new archive %s\\\" % tar_name)\\n tar = tarfile.open(tar_name, 'w:gz');\\n for name in files:\\n tar.add(name)\\n print '%s'% (name)\\n tar.close()\\n return tar_name\",\n \"def gz_tar(full_prefix):\\n tarfile = os.path.join(outputdir, full_prefix + '.tar')\\n try:\\n with open(tarfile, 'rb') as f_in, gzip.open(tarfile + '.gz', 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n os.remove(tarfile)\\n except Exception as e:\\n log.error(\\\"Tarfile {0} was not generated. Module(s) run collected no info?\\\".format(tarfile))\\n log.error(e)\\n\\n return tarfile + '.gz'\",\n \"def merge_ncRNA_fastas():\\n\\tmerge_cmnd = \\\"cat %s %s %s > %s\\\" % (rRNA_fasta_file, fasta_outfile, tRNA_fasta_outfile, ncRNA_output_fasta)\\n\\tprint merge_cmnd\\n\\tos.system(merge_cmnd)\\n\\n\\tindex_cmnd = \\\"samtools faidx %s\\\" % (ncRNA_output_fasta)\\n\\tprint index_cmnd\\n\\tos.system(index_cmnd)\",\n \"def __extract_tgz(self):\\n tar_file = tarfile.open(self.archive)\\n try:\\n extract_dir = tempfile.mkdtemp()\\n archive_binaries_dir = self.__create_extraction_dir(\\n tar_file.getnames(), extract_dir, tar_file.extract)\\n finally:\\n tar_file.close()\\n return archive_binaries_dir, extract_dir\",\n \"def write_tarball(args, tarfilename, archivefiles=[]):\\n if not archivefiles:\\n return None\\n \\n manifest_filename, manifest_uuid = render_manifest(args, archivefiles)\\n try:\\n with tarfile.open(tarfilename, f\\\"{FILE_FLAG}:gz\\\") as tarball:\\n file_count = 0\\n for fname in archivefiles:\\n LOG.debug(f\\\"Adding {fname} to {tarfilename}: \\\")\\n if fname.endswith(\\\".csv\\\"):\\n upload_name = f\\\"{manifest_uuid}_openshift_usage_report.{file_count}.csv\\\"\\n tarball.add(fname, arcname=upload_name)\\n file_count += 1\\n tarball.add(manifest_filename, arcname=\\\"manifest.json\\\")\\n except FileExistsError as exc:\\n LOG.critical(exc)\\n sys.exit(2)\\n LOG.info(f\\\"Wrote: {tarfilename}\\\")\\n return f\\\"{tarfilename}\\\"\",\n \"def write_seqs_fasta(out_fp_seqs_fasta: str, out_fp_seqs_qza: str,\\n tsv_pd: pd.DataFrame, tsv_fp: str = '') -> str:\\n with open(out_fp_seqs_fasta, 'w') as fas_o:\\n for seq in tsv_pd.index:\\n fas_o.write('>%s\\\\n%s\\\\n' % (seq.strip(), seq.strip()))\\n cmd = '# Write features as fasta file:\\\\n'\\n cmd += '# - Features from: %s\\\\n' % tsv_fp\\n cmd += '# Snippet:\\\\n'\\n cmd += '# ```:\\\\n'\\n cmd += \\\"# with open(fasta_out, 'w') as o:\\\\n\\\"\\n cmd += \\\"# for seq in tsv_pd.index:\\\\n\\\"\\n cmd += \\\"# o.write('>%s\\\\\\\\n%s\\\\\\\\n' % (seq.strip(), seq.strip()))\\\\n\\\"\\n cmd += '# ```:\\\\n'\\n cmd += run_import(\\n out_fp_seqs_fasta, out_fp_seqs_qza, 'FeatureData[Sequence]')\\n return cmd\",\n \"def make_fastq_multi(in_fasta, quals, out_fp,\\r\\n label_transform=split_lib_transform):\\r\\n mkdir(out_fp)\\r\\n seen_libs = defaultdict(list)\\r\\n for rec, label in iter_fastq(in_fasta, quals, label_transform):\\r\\n lib_id, seq_id = label.rsplit('_', 1)\\r\\n seen_libs[lib_id].append(rec)\\r\\n for lib, recs in seen_libs.items():\\r\\n if lib is None: # skip the seqs we couldn't assign to a library\\r\\n continue\\r\\n outfile = open(out_fp + '/' + lib + '.fastq', 'w')\\r\\n outfile.write('\\\\n'.join(recs))\\r\\n outfile.close()\",\n \"def _cat_multi_vol_zip(src, dst):\\n concat_cmd = \\\"zip -s 0 {} --out {}\\\".format(src, dst)\\n os.system(concat_cmd)\",\n \"def tar_file(self, name, contents, mtime=None):\\n length = len(contents)\\n tar_data = self.tar_file_header(name, length, mtime=mtime)\\n tar_data += contents\\n tar_data += self.tar_file_padding(length)\\n return tar_data\",\n \"def _build_collection_tar(\\n b_collection_path, # type: bytes\\n b_tar_path, # type: bytes\\n collection_manifest, # type: CollectionManifestType\\n file_manifest, # type: FilesManifestType\\n): # type: (...) -> str\\n files_manifest_json = to_bytes(json.dumps(file_manifest, indent=True), errors='surrogate_or_strict')\\n collection_manifest['file_manifest_file']['chksum_sha256'] = secure_hash_s(files_manifest_json, hash_func=sha256)\\n collection_manifest_json = to_bytes(json.dumps(collection_manifest, indent=True), errors='surrogate_or_strict')\\n\\n with _tempdir() as b_temp_path:\\n b_tar_filepath = os.path.join(b_temp_path, os.path.basename(b_tar_path))\\n\\n with tarfile.open(b_tar_filepath, mode='w:gz') as tar_file:\\n # Add the MANIFEST.json and FILES.json file to the archive\\n for name, b in [(MANIFEST_FILENAME, collection_manifest_json), ('FILES.json', files_manifest_json)]:\\n b_io = BytesIO(b)\\n tar_info = tarfile.TarInfo(name)\\n tar_info.size = len(b)\\n tar_info.mtime = int(time.time())\\n tar_info.mode = 0o0644\\n tar_file.addfile(tarinfo=tar_info, fileobj=b_io)\\n\\n for file_info in file_manifest['files']: # type: ignore[union-attr]\\n if file_info['name'] == '.':\\n continue\\n\\n # arcname expects a native string, cannot be bytes\\n filename = to_native(file_info['name'], errors='surrogate_or_strict')\\n b_src_path = os.path.join(b_collection_path, to_bytes(filename, errors='surrogate_or_strict'))\\n\\n def reset_stat(tarinfo):\\n if tarinfo.type != tarfile.SYMTYPE:\\n existing_is_exec = tarinfo.mode & stat.S_IXUSR\\n tarinfo.mode = 0o0755 if existing_is_exec or tarinfo.isdir() else 0o0644\\n tarinfo.uid = tarinfo.gid = 0\\n tarinfo.uname = tarinfo.gname = ''\\n\\n return tarinfo\\n\\n if os.path.islink(b_src_path):\\n b_link_target = os.path.realpath(b_src_path)\\n if _is_child_path(b_link_target, b_collection_path):\\n b_rel_path = os.path.relpath(b_link_target, start=os.path.dirname(b_src_path))\\n\\n tar_info = tarfile.TarInfo(filename)\\n tar_info.type = tarfile.SYMTYPE\\n tar_info.linkname = to_native(b_rel_path, errors='surrogate_or_strict')\\n tar_info = reset_stat(tar_info)\\n tar_file.addfile(tarinfo=tar_info)\\n\\n continue\\n\\n # Dealing with a normal file, just add it by name.\\n tar_file.add(\\n to_native(os.path.realpath(b_src_path)),\\n arcname=filename,\\n recursive=False,\\n filter=reset_stat,\\n )\\n\\n shutil.copy(to_native(b_tar_filepath), to_native(b_tar_path))\\n collection_name = \\\"%s.%s\\\" % (collection_manifest['collection_info']['namespace'],\\n collection_manifest['collection_info']['name'])\\n tar_path = to_text(b_tar_path)\\n display.display(u'Created collection for %s at %s' % (collection_name, tar_path))\\n return tar_path\",\n \"def cat_files(files, output):\\n for file in files:\\n with open(file, 'r') as fd:\\n shutil.copyfileobj(fd, output)\",\n \"def cat_files(files, output):\\n for file in files:\\n with open(file, 'r') as fd:\\n shutil.copyfileobj(fd, output)\",\n \"def zip_files(file_list, output_path):\\n bname = os.path.basename # for efficiency\\n with zipfile.ZipFile(output_path, mode='w') as zf:\\n # adding all fasta files\\n for file_name in file_list:\\n zf.write(file_name, bname(file_name))\\n return output_path\",\n \"def Parse_folder_to_multi_faa(target_dir,faa_filename):\\n os.chdir(target_dir)\\n output_handle = open(faa_filename, \\\"w\\\")\\n for gbk_filename in FileGen(target_dir):\\n with open(gbk_filename, \\\"r\\\") as input_handle:\\n for seq_record in SeqIO.parse(input_handle, \\\"genbank\\\") :\\n print(\\\"Dealing with GenBank record %s\\\" % seq_record.id)\\n for seq_feature in seq_record.features :\\n if seq_feature.type==\\\"CDS\\\" :\\n assert len(seq_feature.qualifiers['translation'])==1\\n try:\\n name = seq_feature.qualifiers['locus_tag'][0]\\n except KeyError:\\n name = seq_feature.qualifiers['product'][0]\\n output_handle.write(\\\">%s from %s\\\\n%s\\\\n\\\" % (\\n name,\\n gbk_filename.split(\\\"/\\\")[-1],\\n seq_feature.qualifiers['translation'][0])) \\n output_handle.close()\",\n \"def tar(self, out=sys.stdout, config=None, *args, **kw):\\r\\n if config is not None:\\r\\n config = self.manifest.config_schema.validate(config)\\r\\n if self.manifest.get(\\\"templates\\\"):\\r\\n templates_dir = self.copy(templates=True)\\r\\n for template in self.find(templates=True):\\r\\n EJSTemplate(templates_dir + template).apply(templates_dir + template, config)\\r\\n tar = tarfile.open(\\\"\\\", mode=\\\"w|\\\", fileobj=out)\\r\\n templates = self.manifest.get(\\\"templates\\\")\\r\\n for path in self.find(*args, **kw):\\r\\n if config and path in templates:\\r\\n real_path = templates_dir + path\\r\\n EJSTemplate(real_path).apply(real_path, config)\\r\\n else:\\r\\n real_path = self.unchroot_path(path)\\r\\n tar.add(real_path, path, recursive=False)\\r\\n tar.close()\",\n \"def extract_all(tarobj):\\n for member in tarobj.getmembers():\\n tarobj.extract(member)\",\n \"def _write_to_tar(self, dtype_out_time):\\n # When submitted in parallel and the directory does not exist yet\\n # multiple processes may try to create a new directory; this leads\\n # to an OSError for all processes that tried to make the\\n # directory, but were later than the first.\\n try:\\n os.makedirs(self.dir_tar_out)\\n except OSError:\\n pass\\n # tarfile 'append' mode won't overwrite the old file, which we want.\\n # So open in 'read' mode, extract the file, and then delete it.\\n # But 'read' mode throws OSError if file doesn't exist: make it first.\\n utils.io.dmget([self.path_tar_out])\\n with tarfile.open(self.path_tar_out, 'a') as tar:\\n pass\\n with tarfile.open(self.path_tar_out, 'r') as tar:\\n old_data_path = os.path.join(self.dir_tar_out,\\n self.file_name[dtype_out_time])\\n try:\\n tar.extract(self.file_name[dtype_out_time],\\n path=old_data_path)\\n except KeyError:\\n pass\\n else:\\n # The os module treats files on archive as non-empty\\n # directories, so can't use os.remove or os.rmdir.\\n shutil.rmtree(old_data_path)\\n retcode = subprocess.call([\\n \\\"tar\\\", \\\"--delete\\\", \\\"--file={}\\\".format(self.path_tar_out),\\n self.file_name[dtype_out_time]\\n ])\\n if retcode:\\n msg = (\\\"The 'tar' command to save your aospy output \\\"\\n \\\"exited with an error. Most likely, this is due \\\"\\n \\\"to using an old version of 'tar' (especially if \\\"\\n \\\"you are on a Mac). Consider installing a newer \\\"\\n \\\"version of 'tar' or disabling tar output by \\\"\\n \\\"setting `write_to_tar=False` in the \\\"\\n \\\"`calc_exec_options` argument of \\\"\\n \\\"`submit_mult_calcs`.\\\")\\n logging.warn(msg)\\n with tarfile.open(self.path_tar_out, 'a') as tar:\\n tar.add(self.path_out[dtype_out_time],\\n arcname=self.file_name[dtype_out_time])\",\n \"def _make_tar_gz_file(output_filename, source_dir):\\n with tarfile.open(output_filename, \\\"w:gz\\\") as tar:\\n for f in os.listdir(source_dir):\\n tar.add(os.path.join(source_dir, f), arcname=f)\",\n \"def image_to_tgz(image, quiet):\\n\\n temp_dir = tempfile.mkdtemp()\\n tar_file = path.join(temp_dir, path.basename(image) + '.tar')\\n tar_gz_file = tar_file + '.gz'\\n\\n cmd = ['singularity', 'export', '-f', tar_file, image]\\n\\n if not quiet:\\n sys.stderr.write(\\\"Exporting image to .tar\\\\n\\\")\\n\\n try:\\n subprocess.check_call(cmd)\\n except (subprocess.CalledProcessError, OSError) as e:\\n raise ImageException(\\\"Error calling Singularity export to create .tar file\\\\n%s\\\" % e.message)\\n\\n cmd = ['gzip', tar_file]\\n\\n if not quiet:\\n sys.stderr.write(\\\"Compressing to .tar.gz\\\\n\\\")\\n\\n try:\\n subprocess.check_call(cmd)\\n except subprocess.CalledProcessError as e:\\n raise ImageException(\\\"Error calling gzip export to compress .tar file\\\\n%s\\\" % e.message)\\n\\n return (temp_dir, tar_gz_file)\",\n \"def extract_all(fn,dst=\\\".\\\"):\\r\\n if tarfile.is_tarfile(fn): \\r\\n with tarfile.open(fn,'r') as tf:\\r\\n tf.extractall(dst)\\r\\n tf.close()\\r\\n elif zipfile.is_zipfile(fn):\\r\\n with zipfile.ZipFile(fn, 'r') as zf:\\r\\n zf.extractall(dst)\\r\\n zf.close()\\r\\n else:\\r\\n print( \\\"Please provide a tar archive file or zip file\\\" )\",\n \"def _tar_with_filter(\\n path: Path,\\n tar_filter: Callable[[tarfile.TarInfo], Optional[tarfile.TarInfo]],\\n) -> io.BytesIO:\\n tarstream = io.BytesIO()\\n with tarfile.TarFile(fileobj=tarstream, mode='w') as tar:\\n tar.add(name=str(path), arcname='/', filter=tar_filter)\\n tarstream.seek(0)\\n\\n return tarstream\",\n \"def convert_single_to_multi(file_directory):\\n all_files = os.listdir(file_directory)\\n merged_file = ''\\n for file_name in all_files:\\n f_single = open(file_directory + '/' + file_name, \\\"r\\\")\\n data = f_single.read() + '\\\\n'\\n merged_file += data\\n date = datetime.datetime.now()\\n save_seq_file(('multi_fasta_' + str(date).split(' ')[0]), merged_file, file_directory)\",\n \"def convert_fastq_to_fastore(fwd_reads, rev_reads, output_prefix, num_threads=multiprocessing.cpu_count()):\\n if output_prefix is None:\\n output_prefix = os.path.basename(fwd_reads)\\n output_prefix = re.sub(FASTQ_PATTERN, '', output_prefix)\\n\\n cmd = [\\n 'fastore_compress.sh', '--lossless',\\n '--out', output_prefix,\\n '--threads', str(num_threads),\\n '--in', fwd_reads\\n ]\\n if rev_reads is not None:\\n cmd.extend(['--pair', rev_reads])\\n\\n subprocess.check_call(cmd)\\n\\n return (f'{output_prefix}.cmeta', f'{output_prefix}.cdata')\",\n \"def _MockTarList(self, files):\\n self.rc_mock.AddCmdResult(\\n partial_mock.ListRegex('tar -tf'), output='\\\\n'.join(files))\",\n \"def make_fastq_single(in_fasta, quals, out_fp,\\r\\n label_transform=split_lib_transform):\\r\\n outfile = open(out_fp, 'w')\\r\\n for rec, seq_id in iter_fastq(in_fasta, quals, label_transform):\\r\\n outfile.write(rec + '\\\\n')\\r\\n outfile.close()\",\n \"def fasta2MSF():\\n path = \\\"./data/\\\"\\n for file in os.listdir(path):\\n if file.endswith(\\\".fa\\\") or file.endswith(\\\".fasta\\\"):\\n os.chdir(path)\\n try:\\n filecore = file.rstrip(\\\".fa\\\")\\n except:\\n filecore = file.rstrip(\\\".fasta\\\")\\n fileout = filecore + \\\".msf2\\\"\\n \\n seqret = os.system(\\\"seqret fasta::\\\" + file + \\\\\\n \\\" msf::\\\" + fileout)\\n print seqret\\n \\n outmsf = filecore + \\\".msf\\\"\\n out = open(outmsf, \\\"w\\\")\\n op = open(fileout, \\\"r\\\")\\n msf = op.readlines()\\n op.close()\\n for line in msf:\\n if line[0] == \\\"\\\\n\\\":\\n print >> out, line.rstrip(\\\"\\\\n\\\")\\n elif line[0] != \\\"!\\\" and line[0] != \\\"/\\\" and \\\\\\n line[0] != \\\"\\\\n\\\":\\n line = line.replace(\\\".\\\", \\\"-\\\")\\n line = line.replace(\\\"~\\\", \\\"-\\\")\\n print >> out, line.rstrip(\\\"\\\\n\\\") \\n else:\\n print >> out, line.rstrip(\\\"\\\\n\\\")\\n out.close()\\n \\n # remove the comment if you want to remove the\\n # original file\\n #os.remove(file)\\n \\n os.remove(fileout)\\n os.chdir(\\\"../\\\")\\n return\",\n \"def make_tar(self, package, input_dir, build_dir, add_args=None):\\n tar = self.options.tar_command\\n\\n # Generate the .tar.gz file\\n filename = package + '.tar.gz'\\n out_file = open(os.path.join(build_dir, filename), \\\"w\\\")\\n args = [tar, '--format=gnu', '--exclude-vcs', '-C', build_dir]\\n if self.config.get('tar', {}).get('ignore', []):\\n for patt in self.config['tar']['ignore']:\\n args += ['--exclude', patt]\\n if add_args:\\n args += add_args\\n args += ['-c', input_dir]\\n logging.debug(\\\"Creating %s\\\", filename)\\n tar_proc = subprocess.Popen(args, stdout=subprocess.PIPE)\\n gzip_proc = subprocess.Popen(['gzip', '-9'], stdin=tar_proc.stdout,\\n stdout=out_file)\\n\\n if tar_proc.wait() != 0 or gzip_proc.wait() != 0:\\n logging.error(\\\"tar/gzip failed, exiting\\\")\\n sys.exit(1)\\n out_file.close()\\n logging.info('%s written', filename)\\n return filename\",\n \"def untar(file_path, target_dir=None, gzipped=True, verbose=False):\\n return posix.untar(file_path, target_dir, gzipped, verbose)\",\n \"def untar(tar_path, cleanup=False):\\n tfile = tarfile.open(tar_path, 'r')\\n tfile.extractall(os.path.dirname(tar_path))\\n tfile.close()\\n if cleanup:\\n os.remove(tar_path)\",\n \"def get_two_type(raw_file, tar_file):\\n with open(tar_file, 'w') as target:\\n with open(raw_file, 'r') as file:\\n for line in file:\\n items = line.strip().split('\\\\t')\\n if items[2] is '1':\\n continue\\n elif items[2] is '2':\\n items[2] = '1'\\n line = '\\\\t'.join(items)\\n target.write(line + '\\\\n')\\n else:\\n target.write(line)\\n\\n print('done!')\",\n \"def extract_tarball(fileobj, path, callback=None):\\n tar_cmd = [\\\"tar\\\", \\\"-zx\\\", \\\"--directory=%s\\\" % path]\\n tar_proc = make_subprocess(tar_cmd, stderr=True, stdin=True)\\n\\n try:\\n while True:\\n chunk = fileobj.read(CHUNK_SIZE)\\n if chunk == '':\\n break\\n\\n if callback:\\n callback(chunk)\\n\\n tar_proc.stdin.write(chunk)\\n except Exception:\\n try_kill_process(tar_proc)\\n raise\\n\\n finish_subprocess(tar_proc, tar_cmd)\",\n \"def testTarBundling(self):\\n try:\\n tP = os.path.join(self.__workPath, \\\"t0.tar.gz\\\")\\n dirPath = os.path.join(self.__inpDirPath, \\\"topdir\\\")\\n\\n ok = self.__fileU.bundleTarfile(tP, [dirPath], mode=\\\"w:gz\\\", recursive=True)\\n self.assertTrue(ok)\\n\\n numBytes = self.__fileU.size(tP)\\n self.assertGreaterEqual(numBytes, 250)\\n #\\n md5 = self.__fileU.hash(tP, hashType=\\\"md5\\\")\\n self.assertTrue(md5 is not None)\\n #\\n ok = self.__fileU.unbundleTarfile(tP, dirPath=self.__workPath)\\n self.assertTrue(ok)\\n #\\n tP = os.path.join(self.__workPath, \\\"t1.tar.gz\\\")\\n dirPathList = [os.path.join(self.__inpDirPath, \\\"topdir\\\", \\\"subdirA\\\"), os.path.join(self.__inpDirPath, \\\"topdir\\\", \\\"subdirB\\\")]\\n\\n ok = self.__fileU.bundleTarfile(tP, dirPathList, mode=\\\"w:gz\\\", recursive=True)\\n self.assertTrue(ok)\\n #\\n ok = self.__fileU.unbundleTarfile(tP, dirPath=self.__workPath)\\n self.assertTrue(ok)\\n\\n tP = os.path.join(self.__workPath, \\\"t2.tar\\\")\\n dirPathList = [os.path.join(self.__inpDirPath, \\\"topdir\\\", \\\"subdirA\\\"), os.path.join(self.__inpDirPath, \\\"topdir\\\", \\\"subdirB\\\")]\\n\\n ok = self.__fileU.bundleTarfile(tP, dirPathList, mode=\\\"w\\\", recursive=True)\\n self.assertTrue(ok)\\n #\\n ok = self.__fileU.unbundleTarfile(tP, dirPath=self.__workPath)\\n self.assertTrue(ok)\\n\\n except Exception as e:\\n logger.exception(\\\"Failing with %s\\\", str(e))\\n self.fail()\",\n \"def get_tar_files(self, loc_id):\\n if self.storage_type == 's3':\\n conn = boto3.client('s3')\\n bucket_name = self.source_path.split('//')[1].split('/')[0]\\n prefix = self.source_path.split(bucket_name+'/')[1]+'/'+loc_id\\n s3_result = conn.list_objects_v2(Bucket=bucket_name, Prefix=prefix, Delimiter=\\\"/\\\")\\n if 'Contents' not in s3_result:\\n # print(s3_result)\\n return []\\n\\n tar_files = []\\n for key in s3_result['Contents']:\\n tar_files.append(key['Key'])\\n\\n else:\\n file_path = os.path.join(self.source_path, loc_id)\\n tar_files = [os.path.join(file_path, f)\\n for f in os.listdir(file_path) if 'tar' in f]\\n return tar_files\",\n \"def create_tarball(fileobj, path, callback=None, compression_level=None):\\n tar_cmd = [\\\"tar\\\", \\\"-zc\\\", \\\"--directory=%s\\\" % path, \\\".\\\"]\\n env = os.environ.copy()\\n if compression_level and 1 <= compression_level <= 9:\\n env[\\\"GZIP\\\"] = \\\"-%d\\\" % compression_level\\n tar_proc = make_subprocess(tar_cmd, stdout=True, stderr=True, env=env)\\n\\n try:\\n while True:\\n chunk = tar_proc.stdout.read(CHUNK_SIZE)\\n if chunk == '':\\n break\\n\\n if callback:\\n callback(chunk)\\n\\n if fileobj:\\n fileobj.write(chunk)\\n except Exception:\\n try_kill_process(tar_proc)\\n raise\\n\\n finish_subprocess(tar_proc, tar_cmd)\",\n \"def to_fastq(self, prefix='', threads=1):\\n # Write to uncompressed FASTQ for speed\\n fastqs = [\\n f'{prefix}_{i+1}.fastq.gz' if prefix else f'{i+1}.fastq.gz'\\n for i in range(self.technology.n_files)\\n ]\\n logger.info(f'Splitting BAM file into FASTQs {\\\", \\\".join(fastqs)}')\\n logger.warning('All quality scores will be converted to F')\\n files = []\\n lengths = [0, 0, 0]\\n for substring in self.technology.barcode_positions + self.technology.umi_positions:\\n lengths[substring.file\\n ] = max(lengths[substring.file], substring.stop)\\n\\n try:\\n for fastq in fastqs:\\n files.append(open_as_text(fastq, 'w'))\\n\\n # Count total number only if the bam is local\\n parse = urlparse(self.path)\\n if not parse.scheme:\\n with pysam.AlignmentFile(self.path, 'rb', threads=threads) as f:\\n count = f.count(until_eof=True)\\n logger.info(f'Detected {count} BAM entries')\\n else:\\n logger.warning((\\n 'Skip counting total BAM entries in remote BAM. '\\n 'This means a progress bar can not be displayed.'\\n ))\\n\\n with pysam.AlignmentFile(self.path, 'rb', threads=threads) as f,\\\\\\n tqdm() if parse.scheme else tqdm(total=count) as pbar:\\n for item in f.fetch(until_eof=True):\\n reads = ['N' * l for l in lengths] # noqa\\n barcodes, umis, sequence = BAM.EXTRACT_FUNCTIONS[\\n self.technology.name](item) # noqa\\n\\n # Set sequence.\\n reads[self.technology.reads_file.file] = sequence\\n\\n # Barcode and UMI\\n for barcode, substring in zip(\\n barcodes, self.technology.barcode_positions):\\n bc = reads[substring.file]\\n reads[\\n substring.file\\n ] = f'{bc[:substring.start]}{barcode}{bc[substring.stop:]}'\\n for umi, substring in zip(umis,\\n self.technology.umi_positions):\\n u = reads[substring.file]\\n reads[\\n substring.file\\n ] = f'{u[:substring.start]}{umi}{u[substring.stop:]}'\\n\\n # Write to each file.\\n for file, read in zip(files, reads):\\n file.write(f'@{item.query_name}\\\\n')\\n file.write(f'{read.upper()}\\\\n')\\n file.write('+\\\\n')\\n file.write(f'{\\\"F\\\" * len(read)}\\\\n')\\n\\n pbar.update(1)\\n\\n finally:\\n for file in files:\\n file.close()\\n\\n return fastqs, [\\n OrderedTechnology(self.technology, tuple(range(len(fastqs))))\\n ]\",\n \"def _extract_data(inputs):\\n filename, split = inputs\\n for name, fobj in tfds.download.iter_archive(\\n filename, tfds.download.ExtractMethod.TAR_STREAM\\n ):\\n split_name = name.split(\\\"_\\\")\\n if len(split_name) > 2 and split_name[2] == split:\\n yield [name, fobj.read()]\",\n \"def getTarBall(self, exe):\\n self.tgzNameWithPath = common.work_space.pathForTgz()+self.tgz_name\\n if os.path.exists(self.tgzNameWithPath):\\n return self.tgzNameWithPath\\n\\n # Prepare a tar gzipped file with user binaries.\\n self.buildTar_(exe)\\n\\n return string.strip(self.tgzNameWithPath)\",\n \"def parse_multifasta_file(file, number_of_fastas):\\n\\n with open(file) as file:\\n for i in range(number_of_fastas):\\n fasts_seq = ''\\n fasta_name = file.readline().strip()[1:]\\n end_of_file = False\\n end_of_seq = False\\n while not end_of_seq and not end_of_file:\\n x = file.tell()\\n seq = file.readline()\\n if not seq:\\n end_of_file = True\\n elif '>' not in seq:\\n fasts_seq = fasts_seq + seq\\n else:\\n file.seek(x)\\n end_of_seq = True\\n fasts_seq = re.sub(r'\\\\n', '', fasts_seq)\\n yield fasta_name, fasts_seq\",\n \"def create_RCSB_fastas(file):\\n folder_path = create_folder(file)\\n filepath = RAWDATA_PATH + file\\n with open(filepath, 'r') as raw_file:\\n raw_data = raw_file.read()\\n chains = raw_data.split('>')\\n cache = []\\n for chain in chains[1:]:\\n head = chain[:4] # for SCOP\\n chain_number = chain[5]\\n prefix_pos = 27 # for SCOP\\n prefix = chain[:prefix_pos]\\n sequence = chain[prefix_pos:]\\n sequence = sequence.replace('\\\\n', '')\\n assert prefix[6:] == '|PDBID|CHAIN|SEQUENCE', 'Unknown prefix'\\n if chain_number < 'A' or chain_number > 'Z': # invalid chain\\n continue\\n elif sequence in cache: # same chain\\n continue\\n if not cache: # new protein\\n cache = [head, sequence]\\n elif head != cache[0]: # new protein\\n protein_sequence = ''\\n for cached_sequence in cache[1:]:\\n protein_sequence += cached_sequence\\n if len(protein_sequence) > 300:\\n new_fasta = open('{0}\\\\{1}.txt'.format(folder_path, head), 'w')\\n new_fasta.write('>' + chain[:prefix_pos] + '\\\\n')\\n new_fasta.write(protein_sequence)\\n new_fasta.close\\n cache = [head, sequence]\\n cache.append(sequence)\\n new_fasta = open('{0}\\\\{1}.txt'.format(folder_path, head), 'w')\\n new_fasta.write('>' + chain[:prefix_pos] + '\\\\n')\\n for cached_sequence in cache[1:]:\\n new_fasta.write(cached_sequence)\\n new_fasta.close\",\n \"def tar(self, folders, tarfile):\\n if not folders:\\n raise ValueError('folders must be set')\\n if not tarfile:\\n raise ValueError('tarfile must be set')\\n with OpenShell(self._conn) as os:\\n if log.isEnabledFor(logging.DEBUG):\\n RemoteOperation.run(os, 'tar -cvf %s %s' % (tarfile, ' '.join(folders)))\\n else:\\n RemoteOperation.run(os, 'tar -cf %s %s' % (tarfile, ' '.join(folders)))\",\n \"def _outside_tar2(self):\\r\\n outside_tar = self.unsafe_common_dir / \\\"unsafe_file.tar.gz\\\"\\r\\n with tarfile.open(outside_tar, \\\"w:gz\\\") as tar:\\r\\n tar.addfile(tarfile.TarInfo(str(self.unsafe_common_dir / \\\"../a_file\\\")))\\r\\n\\r\\n return outside_tar\",\n \"def _extract_fastas_from_fast5(self):\\n\\t\\tfor id, h5path in fastq_paths[self.version].iteritems():\\n\\t\\t\\ttry:\\n\\t\\t\\t\\ttable = self.hdf5file[h5path % self.group]\\n\\t\\t\\t\\tfa = formats.Fasta(table['Fastq'][()])\\n\\t\\t\\t\\tfa.name += \\\" \\\" + self.filename\\n\\t\\t\\t\\tself.fastas[id] = fa\\n\\t\\t\\texcept Exception, e:\\n\\t\\t\\t\\tpass\",\n \"def convert_multi_to_single(file_directory):\\n all_files = os.listdir(file_directory)\\n for file_name in all_files:\\n f_multi = open(file_directory + '/' + file_name, \\\"r\\\")\\n for seq_record in SeqIO.parse(f_multi, \\\"fasta\\\"):\\n seq_id = seq_record.id\\n sequence = str(seq_record.seq)\\n save_seq_file(seq_id, sequence, file_directory)\",\n \"def create_tarballs_from_xml_files_in_folder(xml_dir, download_date=\\\"2017.11.02\\\"):\\n\\n xml_list = glob.glob(os.path.join(xml_dir, \\\"*.xml\\\"))\\n\\n for xml in xml_list:\\n xml_renamed = xml[:-4] + \\\".BLAST.xml\\\"\\n xml_tar_gz = xml[:-4] + \\\".BLAST.xml.tar.gz\\\"\\n xml_txt = xml[:-4] + \\\"_details.txt\\\"\\n # xml_txt = xml[:-4] + \\\".BLAST_details.txt\\\"\\n\\n if not os.path.isfile(xml_tar_gz):\\n copyfile(xml, xml_renamed)\\n acc = os.path.basename(xml).split(\\\".\\\")[0]\\n sys.stdout.write(\\\"{}, \\\".format(acc))\\n sys.stdout.flush()\\n # create an empty text file with the download date\\n date = strftime(\\\"%Y%m%d\\\")\\n with open(xml_txt, \\\"w\\\") as f:\\n f.write(\\\"acc\\\\t{}\\\\ndownload_date\\\\t{}\\\\ndatabase\\\\tncbi_nr\\\\ne_value\\\\t1\\\\n\\\".format(acc, download_date))\\n\\n with tarfile.open(xml_tar_gz, mode='w:gz') as tar:\\n # add the files to the compressed tarfile\\n tar.add(xml_renamed, arcname=os.path.basename(xml_renamed))\\n tar.add(xml_txt, arcname=os.path.basename(xml_txt))\\n\\n # delete the original files\\n try:\\n os.remove(xml_renamed)\\n os.remove(xml_txt)\\n except:\\n sys.stdout.write(\\\"{} could not be deleted\\\".format(xml_renamed))\",\n \"def merge_walkupseq_files(latest_tsca_id):\\n paths = glob.glob('walkupseq_files/*sample_info*')\\n\\n dfs = []\\n for f in paths:\\n tmp = pd.read_table(f, encoding='latin1')\\n dfs.append(tmp)\\n\\n df = pd.concat(dfs, axis=0)\\n df.to_csv('walkupseq_files/walkupseq_all_combined_%s.txt'%latest_tsca_id, sep=\\\"\\\\t\\\", index=None)\\n return df\",\n \"def hdf5_concatenate_core17(job_tuple):\\n\\n proj_folder, top_folder, db_name, run, clone = job_tuple\\n path = os.path.join(proj_folder,\\\"RUN%d/CLONE%d/\\\"%(run,clone))\\n top = md.load(os.path.join(top_folder,\\\"%d.pdb\\\"%run))\\n output_filename = os.path.join(proj_folder,\\\"trajectories/%d_%d.hdf5\\\"%(run,clone))\\n\\n glob_input = os.path.join(path, \\\"results-*.tar.bz2\\\")\\n filenames = glob.glob(glob_input)\\n filenames = sorted(filenames, key=keynat)\\n\\n if len(filenames) <= 0:\\n return\\n\\n trj_file = HDF5TrajectoryFile(output_filename, mode='a')\\n\\n try:\\n trj_file._create_earray(where='/', name='processed_filenames',atom=trj_file.tables.StringAtom(1024), shape=(0,))\\n trj_file.topology = top.topology\\n except trj_file.tables.NodeError:\\n pass\\n\\n for filename in filenames:\\n if six.b(filename) in trj_file._handle.root.processed_filenames: # On Py3, the pytables list of filenames has type byte (e.g. b\\\"hey\\\"), so we need to deal with this via six.\\n print(\\\"Already processed %s\\\" % filename)\\n continue\\n with enter_temp_directory():\\n print(\\\"Processing %s\\\" % filename)\\n archive = tarfile.open(filename, mode='r:bz2')\\n try:\\n archive.extract(\\\"positions.xtc\\\")\\n trj = md.load(\\\"positions.xtc\\\", top=top)\\n for frame in trj:\\n trj_file.write(coordinates=frame.xyz, cell_lengths=frame.unitcell_lengths, cell_angles=frame.unitcell_angles)\\n trj_file._handle.root.processed_filenames.append([filename])\\n except:\\n #something wrong with the current trajectory file. Warn and return immediately\\n warnings.warn(\\\"Problem at %s.Stopping trajectory here\\\"%filename)\\n return\\n return\",\n \"def unzip_and_untar(item):\\n print(\\\"Unpacking %s\\\" % item)\\n\\n f = tarfile.open(item, mode=\\\"r\\\")\\n f.extractall(path=\\\"working\\\")\\n f.close()\",\n \"def createSequenceFile(sequences, tmpDir, filename='seq.fa'):\\n seqfile = os.path.join(tmpDir, filename)\\n with open(seqfile, 'w') as f:\\n for name, sequence in sequences.iteritems():\\n f.write(\\\">{}\\\\n{}\\\\n\\\".format(name, sequence))\\n subprocess.call(\\\"pyfasta flatten {}\\\".format(seqfile), shell=True)\\n return seqfile\",\n \"def test_write_combined_fasta(self):\\r\\n\\r\\n mapping_data = {'%s' % basename(self.fasta1_fp): 'Sample1',\\r\\n '%s' % basename(self.fasta2_fp): 'Sample2',\\r\\n '%s' % basename(self.fasta3_fp): 'Sample3'\\r\\n }\\r\\n\\r\\n fasta_fps = [self.fasta2_fp, self.fasta3_fp, self.fasta1_fp]\\r\\n\\r\\n write_combined_fasta(mapping_data, fasta_fps, self.output_dir,\\r\\n counter=100)\\r\\n\\r\\n output_fp = open(join(self.output_dir, \\\"combined_seqs.fna\\\"), \\\"U\\\")\\r\\n output_lines = [line.strip() for line in output_fp]\\r\\n\\r\\n expected_output_lines = ['>Sample2_100 label3 ZZZ', 'AACGYAACGAGA',\\r\\n '>Sample2_101 label4', 'ACAGAGAGAGGGGAGA',\\r\\n '>Sample3_102 label5 ;LKJ', 'ACAGGGATTTTTAT',\\r\\n '>Sample1_103 label1 XXX', 'ACAGATTACGA',\\r\\n '>Sample1_104 label2 YYY', 'ACATAAAATAGCCGGAG'\\r\\n ]\\r\\n\\r\\n self.assertEqual(output_lines, expected_output_lines)\",\n \"def gatherfiles(self):\\n\\t\\tfrom subprocess import Popen,PIPE\\n\\t\\timport os\\n\\t\\timport tarfile\\n\\t\\timport glob\\n\\t\\t\\n\\t\\tprint \\\"=== \\\",self.nameID,\\\": Joining all the files in one\\\"\\n\\t\\t# FIXME: Only there are 1 file, not needed the hadd\\n\\t\\tfinalfile = os.path.join(\\\"Results\\\",self.outputfile)\\n\\t\\t# FIXED BUG: just cp when there is only one file, otherwise\\n\\t\\t# there are problems with the TTree\\n\\t\\tif len(self.outputfiles) == 1:\\n\\t\\t\\t# Note that when there is only 1 file, always its #task=1\\n\\t\\t\\tcommand = [ 'cp', self.outputfiles[1], finalfile ]\\n\\t\\telse:\\n\\t\\t\\tcommand = [ 'haddPlus', finalfile ]\\n\\t\\t\\tfor f in self.outputfiles.itervalues():\\n\\t\\t\\t\\tcommand.append( f )\\n\\t\\tp = Popen( command ,stdout=PIPE,stderr=PIPE ).communicate()\\n\\t\\t# Checking if everything was allright\\n\\t\\ttotalevts = self.getevents(finalfile,True)\\n\\t\\tif totalevts != self.nevents:\\n\\t\\t\\tmessage = \\\"\\\\033[33;1mclustermanager.gatherfiles: WARNING\\\\033[0m the total file\\\"\\n\\t\\t\\tmessage += \\\"'\\\"+finalfile+\\\"' do not contain all the events:\\\\n\\\"\\n\\t\\t\\tmessage += \\\"Total events to be processed:\\\"+str(self.nevents)+\\\"\\\\n\\\"\\n\\t\\t\\tmessage += \\\"Total events in '\\\"+finalfile+\\\"':\\\"+str(totalevts)+\\\"\\\\n\\\"\\n\\t\\t\\tprint message\\n\\t\\t\\treturn \\n\\t\\t# If everything was fine, deleting the files \\n\\t\\t# and cleaning the directory\\n\\t\\tfor f in self.outputfiles.itervalues():\\n\\t\\t\\tos.remove( f )\\n\\t\\t# Taring and compressing\\n\\t\\tfilestotar = glob.glob(\\\"./*.*\\\")\\n\\t\\tfilestotar.append( \\\".storedmanager\\\")\\n\\t\\ttar = tarfile.open(os.path.basename(self.cwd)+\\\".tar.gz\\\",\\\"w:gz\\\")\\n\\t\\tfor f in filestotar:\\n\\t\\t\\ttar.add(f)\\n\\t\\ttar.close()\\n\\t\\t# if everything was fine, deleting the files\\n\\t\\tif os.path.exists(os.path.basename(self.cwd)+\\\".tar.gz\\\"):\\n\\t\\t\\tfor f in filestotar:\\n\\t\\t\\t\\tos.remove(f)\\n\\t\\telse:\\n\\t\\t\\tmessage = \\\"\\\\033[33;1mclustermanager.gatherfiles: WARNING\\\\033[0m I can't manage\\\\n\\\"\\n\\t\\t\\tmessage += \\\"to create the backup .tar.gz file\\\\n\\\"\\n\\t\\t\\tprint message\\n\\n\\t\\tprint \\\"Created \\\"+finalfile\\n\\t\\tprint \\\"========= Process Completed =========\\\"\",\n \"def unpack_landsat(inpath, outpath, bands=None, clouds=None):\\r\\n tfile = tarfile.open(inpath,'r:gz')\\r\\n if bands is None:\\r\\n #Extract all of the bands.\\r\\n tfile.extractall(outpath);\\r\\n else:\\r\\n #Extract just the bands specified.\\r\\n\\r\\n #Get the names of the members of the archive\\r\\n names = tfile.getnames()\\r\\n\\r\\n #Make sure the bands are given as a list\\r\\n bands = list(bands)\\r\\n\\r\\n #Find those elements of the archive that match the bands specified\\r\\n #\\t(plus metadata file)\\r\\n members = tfile.getmembers()\\r\\n elements = []\\r\\n blist = ''.join(str(i) for i in bands)\\r\\n if clouds:\\r\\n patternStr = '.*_B[' + blist + ']\\\\.TIF|.*_MTL.txt|.*_band[' + blist + \\\\\\r\\n ']\\\\.tif|.*_cfmask.*\\\\.tif|.*\\\\.xml|.*cloud.*\\\\.tif'\\r\\n else:\\r\\n patternStr = '.*_B[' + blist + ']\\\\.TIF|.*_MTL.txt|.*_band[' + blist + \\\\\\r\\n ']\\\\.tif|.*_cfmask.*\\\\.tif|.*\\\\.xml'\\r\\n\\r\\n pattern = re.compile(patternStr)\\r\\n for i, name in enumerate(names):\\r\\n if pattern.match(name):\\r\\n elements.append(members[i])\\r\\n tfile.extractall(outpath,members = elements)\\r\\n\\r\\n '''\\r\\n Note: the below section was written with the intention of\\r\\n adding valuable metadata info to the .TIF files themselves.\\r\\n This theoretically allows easy retreival of key metadata info,\\r\\n but the method to set new metadata seems unreliable. Appears to\\r\\n be an open issue, but there may be a solution. For now, assume\\r\\n this does not work.\\r\\n\\r\\n #Now we loop through each output, adding important metadata.\\r\\n #Fetch metadata and make sure there is only one file.\\r\\n meta = glob.glob(outpath + '/*_MTL.txt')\\r\\n if len(meta) > 1:\\r\\n raise('MORE THAN ONE METADATA FILE FOUND!')\\r\\n\\r\\n metadata = read_metadata(meta[0])\\r\\n\\r\\n #Add the metadata.\\r\\n for tif in glob.glob(outpath + '*.TIF'):\\r\\n #Open the tif file\\r\\n ras = gdal.Open(tif)\\r\\n\\r\\n #Preserve any existing metadata & add important metadata from file\\r\\n meta = ras.GetMetadata()\\r\\n meta['SCENE_CENTER_TIME'] = metadata['SCENE_CENTER_TIME']\\r\\n meta['DATE_ACQUIRED'] = metadata['DATE_ACQUIRED']\\r\\n meta['LANDSAT_SCENE_ID'] = metadata['LANDSAT_SCENE_ID']\\r\\n\\r\\n #Now write the new metadata back to the tif.\\r\\n ras.SetMetadata(meta)\\r\\n ras.FlushCache()\\r\\n ras = None\\r\\n '''\",\n \"def untar(conn, tarball, path):\\n conn.run(f\\\"tar xf {tarball} -C {path}\\\")\",\n \"def generate_archive_file(location, paths, environment=None, compression=None, archive_format=None):\\n if archive_format == 'zip':\\n archive = ZipTarWrapper(location.name, 'w', zipfile.ZIP_DEFLATED)\\n else:\\n write_type = \\\"w\\\"\\n if compression:\\n write_type = \\\"w|{0}\\\".format(compression)\\n archive = tarfile.open(location.name, write_type)\\n\\n # Add all the things to the archive\\n for path_spec in paths:\\n path_spec.add_to_tar(archive, environment)\\n\\n # Finish the zip\\n archive.close()\\n\\n return archive\",\n \"def tar_job(self):\\n curr_dir = os.getcwd()\\n\\n os.chdir(self.temp_project_path)\\n logging.log(level=logging.INFO, msg=\\\"Tarring up Filesystem and Environment\\\")\\n tar_name = f\\\"{self.project_id}_fs\\\"\\n tar_persistor = TarPersistor(base_file_name=tar_name,\\n folder=\\\".\\\",\\n paths_to_tar=os.listdir(),\\n extract_path=False)\\n _ = tar_persistor.persist()\\n\\n os.chdir(curr_dir)\\n\\n tar_path = os.path.join(self.temp_project_path, tar_name) + \\\".tar\\\"\\n return tar_path\",\n \"def do_pack():\\n\\n now = datetime.now()\\n # format the name of the file with the timestamps\\n now_year = now.year\\n now_month = now.month\\n now_day = now.day\\n now_hour = now.hour\\n now_minute = now.minute\\n now_second = now.second\\n # apply the format\\n file_name = 'versions/web_static_{}{}{}{}{}{}.tgz'.format(\\n now_year, now_month, now_day, now_hour, now_minute, now_second\\n )\\n # All archives must be stored in the folder versions\\n local('mkdir -p versions')\\n # execute locally the compression of the folder\\n command = local(\\\"tar -cvzf \\\" + file_name + \\\" ./web_static/\\\")\\n # return the archive path if the archive has been correctly generated\\n if command.succeeded:\\n return file_name\\n else:\\n return None\",\n \"def inBoth(from_files):\\n t_nof1 = []\\n f_nof1 = []\\n array_of_times = []\\n for file in from_files:\\n item = file.replace('_COMPLETE', '')\\n if item in to_files:\\n to = os.path.join('/ToNof1/archive', item)\\n from_nof1 = os.path.join('/FromNof1', file)\\n t_nof1.append(to)\\n f_nof1.append(from_nof1)\\n\\n\\n\\n with open(\\\"TAT_From_Nof1.tsv\\\", 'w') as f:\\n i = 0\\n myHeader = \\\"Completed File\\\\tCompleted Time\\\\tSent File\\\\tSent Time\\\\tDelta\\\\n\\\"\\n f.write(myHeader)\\n while i < len(to_files):\\n today = datetime.today()\\n\\n fName = os.path.basename(f_nof1[i])\\n tName = os.path.basename(t_nof1[i])\\n\\n fTime = getDate(f_nof1[i])\\n tTime = getDate(t_nof1[i])\\n\\n duration = (today - fTime)\\n if duration.days < 90:\\n delta = fTime - tTime\\n seconds = (delta.total_seconds())\\n minutes = seconds / 60.0\\n hours = minutes / 60.0\\n array_of_times.append(hours)\\n delta = str(delta)\\n fTime = str(fTime)\\n tTime = str(tTime)\\n myString = (fName + \\\"\\\\t\\\" + fTime + \\\"\\\\t\\\" + tName + \\\"\\\\t\\\" + tTime + \\\"\\\\t\\\" + delta + \\\"\\\\n\\\")\\n f.write(myString)\",\n \"def _fifo_tar(self):\\r\\n fifop = self.unsafe_common_dir / \\\"fifo.file\\\"\\r\\n fifo_tar = self.unsafe_common_dir / \\\"fifo.tar.gz\\\"\\r\\n os.mkfifo(fifop)\\r\\n with tarfile.open(fifo_tar, \\\"w:gz\\\") as tar:\\r\\n tar.add(fifop)\\r\\n\\r\\n return fifo_tar\",\n \"def tar_cz_relative(*path):\\n file_out = io_BytesIO()\\n tar = tarfile_open(mode = \\\"w:gz\\\", fileobj = file_out)\\n for p in path:\\n tar.add(p, arcname='./')\\n tar.close()\\n return file_out.getvalue()\",\n \"def do_pack():\\n files = 'versions/web_static_{}{}{}{}{}{}.tgz'\\\\\\n .format(T.year, T.month, T.day, T.hour, T.minute, T.second)\\n local('mkdir -p versions')\\n execute = local(\\\"tar -cvzf \\\" + files + \\\" ./web_static/\\\")\\n if execute.succeeded:\\n return files\\n return None\",\n \"def extract_sources(tarsources=[], zipsources=[]):\\n for source in tarsources:\\n cmd = [\\\"tar\\\", \\\"-xvf\\\", source, \\\"-C\\\", WHEEL_BUILD_DIR]\\n subprocess.check_call(cmd)\\n\\n for source in zipsources:\\n cmd = [\\\"unzip\\\", source, \\\"-d\\\", WHEEL_BUILD_DIR]\\n subprocess.check_call(cmd)\",\n \"def handle_tar(file_path, extension, extracted_path, destination_directory):\\n tar = tarfile.open(file_path, extension)\\n # remove files if they already exist\\n if os.path.exists(extracted_path):\\n shutil.rmtree(extracted_path)\\n tar.extractall(path=destination_directory)\\n tar.close()\",\n \"def concatenate_multilane_files(files, prompt):\\n\\n def _concatenate_group(group, first_elem):\\n \\\"\\\"\\\"Concatenate all the files on the list and return the target file path.\\\"\\\"\\\"\\n target_file_name = re.sub(pattern_lane_num, r\\\"\\\\1\\\", os.path.basename(first_elem))\\n target_path = os.path.join(tempfile.gettempdir(), target_file_name)\\n\\n # Overwriting all files by default\\n with open(target_path, \\\"wb\\\") as outf:\\n for fname in group:\\n with open(fname, \\\"rb\\\") as inf:\\n # TODO: check for newline at the end of file first?\\n shutil.copyfileobj(inf, outf)\\n return target_path\\n\\n groups = _find_multilane_groups(files)\\n\\n if not groups:\\n return files\\n\\n perform_concat = True\\n if prompt:\\n answer = click.confirm(\\n \\\"This data appears to have been split across multiple sequencing lanes.\\\\nConcatenate lanes before upload?\\\",\\n default=\\\"Y\\\",\\n )\\n if not answer:\\n perform_concat = False\\n\\n if not perform_concat:\\n return files\\n\\n files = files[:]\\n pattern_lane_num = re.compile(r\\\"[._]L\\\\d+([._])\\\")\\n\\n for group in groups:\\n # The groups considered here will already have more than 1 element\\n first_elem = group[0]\\n if isinstance(first_elem, tuple):\\n concat_fwd = _concatenate_group([fwd for fwd, _ in group], first_elem[0])\\n concat_rev = _concatenate_group([rev for _, rev in group], first_elem[1])\\n files.append((concat_fwd, concat_rev))\\n elif isinstance(first_elem, str):\\n concat = _concatenate_group(group, first_elem)\\n files.append(concat)\\n\\n for elem in group:\\n files.remove(elem)\\n\\n return files\",\n \"def expand_alma_sftp_tarball(key, source_obj):\\n source_tar = tarfile.open(fileobj=io.BytesIO(source_obj), mode=\\\"r:gz\\\")\\n if len(source_tar.getmembers()) == 0:\\n LOGGER.error(\\\"S3 Object is empty.\\\")\\n LOGGER.error(key)\\n return None\\n\\n if len(source_tar.getmembers()) > 1:\\n LOGGER.error(\\\"S3 Object has more than 1 member, which is unexpected.\\\")\\n LOGGER.error(key)\\n return None\\n\\n for item in source_tar:\\n return source_tar.extractfile(item).read()\",\n \"def _unpack_tar(self, dir, filters):\\n try:\\n unpackArchive = gbpc.UnpackTarArchive(self.path, dir, filters)\\n unpackArchive()\\n except gbpc.CommandExecFailed:\\n # unpackArchive already printed an error message\\n raise GbpError\",\n \"def assemble_file(names):\\n md5 = hashlib.md5()\\n filename = ''.join([name.split('-')[-1] for name in names])\\n fpath = os.path.join(FILES_DIR, filename)\\n with open(fpath, \\\"wb\\\") as dst:\\n for name in names:\\n for chunk in chunked_reader(os.path.join(DATA_DIR, name)):\\n md5.update(chunk)\\n dst.write(chunk)\\n\\n return fpath, md5.digest().hex()\",\n \"def test_make_fna(self):\\r\\n fna_fp = os.path.join(self.sff_dir, 'test.fna')\\r\\n fna_gz_fp = os.path.join(self.gz_sff_dir, 'test_gz.fna')\\r\\n make_fna(self.sff_fp, fna_fp)\\r\\n make_fna(self.sff_gz_fp, fna_gz_fp)\\r\\n self.assertEqual(open(fna_fp).read(), fna_txt)\\r\\n self.assertEqual(open(fna_gz_fp).read(), fna_txt)\",\n \"def gzip_files(topDir, afni_file,localizerfile):\\n\\n print 'GZIPPING FILES...'\\n\\n command1 = \\\"gzip %s*BRIK\\\" % (topDir)\\n command2 = \\\"gzip %s*HEAD\\\" % (topDir)\\n command3 = \\\"gzip %s%s/pb00*\\\" % (topDir,afni_file)\\n command4 = \\\"gzip %s%s/errts*\\\" % (topDir,afni_file)\\n command5 = \\\"gzip %s%s/fitts*\\\" % (topDir,afni_file)\\n command6 = \\\"gzip %s%s/*al*\\\" % (topDir,afni_file)\\n command7 = \\\"gzip %s%s/*ns*\\\" % (topDir,afni_file)\\n command8 = \\\"gzip %s%s/all_runs*\\\" % (topDir,afni_file)\\n command9 = \\\"gzip %s%s/*mask*\\\" % (topDir,afni_file)\\n command10 = \\\"gzip %s*nii\\\" % (topDir)\\n command11 = \\\"gzip %s%s/pb01*\\\" % (topDir,afni_file)\\n command12 = \\\"gzip %s%s/pb03*\\\" % (topDir,afni_file)\\n command13 = \\\"gzip %s%s/pb02*\\\" % (topDir,afni_file)\\n\\n os.system(command1)\\n os.system(command2)\\n os.system(command3)\\n os.system(command4)\\n os.system(command5)\\n os.system(command6)\\n os.system(command7)\\n os.system(command8)\\n #os.system(command9)\\n os.system(command10)\\n os.system(command11)\\n try:\\n os.system(command12)\\n except:\\n print 'Could not gzip pb03 files'\\n\\n if localizerfile == 'facescene_loc':\\n os.system(command13)\",\n \"def _setup_input(self, g):\\n tarbytes = io.BytesIO()\\n with tempfile.NamedTemporaryFile() as f:\\n g.serialize(f.name, format=\\\"turtle\\\")\\n tar = tarfile.open(name=\\\"out.tar\\\", mode=\\\"w\\\", fileobj=tarbytes)\\n tar.add(f.name, arcname=\\\"input.ttl\\\")\\n tar.close()\\n # seek to beginning so our file is not empty when docker sees it\\n tarbytes.seek(0)\\n return tarbytes\",\n \"def extract_files(self, *filenames):\\n for filename in filenames:\\n data = self.read_file(filename)\\n f = open(filename, 'wb')\\n f.write(data or b'')\\n f.close()\",\n \"def merge_paired_fastqs(target, outdir):\\n left, right = target.get_fastq()\\n left_fq = join(outdir, target.system_id + \\\"_1.fq.gz\\\")\\n right_fq = join(outdir, target.system_id + \\\"_2.fq.gz\\\")\\n commands = []\\n\\n if is_gz_file(left[0]):\\n commands += [f\\\"cat {' '.join(left)} > {left_fq}\\\"]\\n commands += [f\\\"cat {' '.join(right)} > {right_fq}\\\"]\\n else:\\n commands += [f\\\"cat {' '.join(left)} | \\\" f\\\"gzip -c > {left_fq}\\\"]\\n commands += [f\\\"cat {' '.join(right)} | \\\" f\\\"gzip -c > {right_fq}\\\"]\\n\\n remove = [f\\\"rm {left_fq} {right_fq}\\\"]\\n\\n return (left_fq, right_fq), commands, remove\",\n \"def main():\\n onlyfiles = [f for f in listdir(RAWDATA_PATH) if isfile(join(RAWDATA_PATH, f))]\\n for file in onlyfiles:\\n create_RCSB_fastas(file)\",\n \"def _send_tarstream_to_node_and_extract(\\n tarstream: io.BytesIO,\\n node: Node,\\n remote_path: Path,\\n sudo: bool,\\n) -> None:\\n tar_path = Path('/tmp/dcos_e2e_tmp.tar')\\n with tempfile.NamedTemporaryFile() as tmp_file:\\n tmp_file.write(tarstream.getvalue())\\n tmp_file.flush()\\n\\n node.send_file(\\n local_path=Path(tmp_file.name),\\n remote_path=tar_path,\\n sudo=sudo,\\n )\\n\\n tar_args = ['tar', '-C', str(remote_path), '-xvf', str(tar_path)]\\n node.run(args=tar_args, sudo=sudo)\\n node.run(args=['rm', str(tar_path)], sudo=sudo)\",\n \"def compress_files(self):\\n archive_file_path = tkinter.filedialog.asksaveasfilename(parent=self,\\n defaultextension=\\\".zip\\\",\\n filetypes=[(\\\"Zip File\\\", \\\"*.zip\\\")])\\n treeview_items = self.files_treeview.get_children()\\n if archive_file_path and treeview_items:\\n with ZipFile(archive_file_path, \\\"w\\\", ZIP_DEFLATED) as archive:\\n for row in treeview_items:\\n file_path = self.files_treeview.item(row, \\\"values\\\")[0]\\n file_name = os.path.basename(file_path)\\n archive.write(file_path, arcname=file_name)\",\n \"def export_fasta(self, metadata, analysistype, reportpath, cutoff, program):\\n logging.info('Creating FASTA-formatted files of outputs')\\n for sample in metadata:\\n # Set the name of the FASTA output file\\n sample[analysistype].fasta_output = os.path.join(reportpath, '{sn}_{prog}.fasta'.format(sn=sample.name,\\n prog=analysistype))\\n # Remove the file if it exists. Otherwise, if the samples are processed by the pipeline more than\\n # once, the same results will be appended to the file\\n try:\\n os.remove(sample[analysistype].fasta_output)\\n except FileNotFoundError:\\n pass\\n # Process the sample only if the script could find targets\\n if sample[analysistype].blastresults != 'NA' and sample[analysistype].blastresults:\\n # Open the FASTA output file in append mode\\n with open(sample[analysistype].fasta_output, 'a+') as fasta_output:\\n for target in sorted(sample[analysistype].targetnames):\\n index = 0\\n for hit in sample[analysistype].blastlist:\\n if hit['subject_id'] == target:\\n # Set the name and percent id to avoid writing out the dictionary[key] multiple times\\n if float(hit['percent_match']) >= cutoff:\\n # If the 'align' option was not specified, the .dnaseq attribute will be an empty\\n # dictionary. Populate this attribute as required\\n try:\\n # The .dnaseq attribute will not exist for amino-acid based searches\\n if program == 'blastn':\\n fasta = sample[analysistype].dnaseq[target][index]\\n else:\\n # The .targetsequence attribute will be sufficient\\n fasta = Seq(sample[analysistype].targetsequence[target][index])\\n except (KeyError, IndexError):\\n # Align the protein (and nucleotide) sequences to the reference\\n sample = self.alignprotein(sample=sample,\\n analysistype=analysistype,\\n target=target,\\n program=program,\\n index=index,\\n hit=hit)\\n try:\\n if program == 'blastn':\\n fasta = sample[analysistype].dnaseq[target][index]\\n else:\\n fasta = Seq(sample[analysistype].targetsequence[target][index])\\n except IndexError:\\n fasta = str()\\n # Create the SeqRecord of the FASTA sequence\\n if fasta:\\n try:\\n record = SeqRecord(fasta,\\n id='{name}_{target}'\\n .format(name=sample.name,\\n target=target),\\n description='')\\n # Write the FASTA-formatted record to file\\n fasta_output.write(record.format('fasta'))\\n except (AttributeError, TypeError):\\n pass\\n index += 1\\n # Return the updated metadata object\\n return metadata\",\n \"def untar(tarfile, outdir):\\n tmpdir = tempfile.mkdtemp()\\n try:\\n untared = _open_archive(tarfile, tmpdir)\\n files = [f for f in untared if os.path.isfile(os.path.join(tmpdir, f))]\\n dirs = [d for d in untared if os.path.isdir(os.path.join(tmpdir, d))]\\n assert len(files) + len(dirs) == len(untared), 'Only files and directories'\\n if _files_same(tmpdir, outdir, files) and _dirs_same(tmpdir, outdir, dirs):\\n # Nothing new or different in the tarfile.\\n return False\\n # Some or all of the files / directories are new.\\n _move_files(tmpdir, outdir, files)\\n _move_dirs(tmpdir, outdir, dirs)\\n return True\\n finally:\\n if os.path.isdir(tmpdir):\\n shutil.rmtree(tmpdir)\",\n \"def test_tb_extract_fastq():\\n resource_path = os.path.join(os.path.dirname(__file__), \\\"data/\\\")\\n fastq_file_1 = resource_path + \\\"tb.Human.SRR1658573_1.fastq\\\"\\n fastq_file_2 = resource_path + \\\"tb.Human.SRR1658573_2.fastq\\\"\\n gem_file = resource_path + \\\"tb.Human.GCA_000001405.22_gem.fasta.gem\\\"\\n\\n if not os.path.isfile(gem_file):\\n generate_gem()\\n\\n with gzip.open(gem_file + '.gz', 'rb') as fgz_in:\\n with open(gem_file, 'w') as f_out:\\n f_out.write(fgz_in.read())\\n\\n with gzip.open(fastq_file_1 + '.gz', 'rb') as fgz_in:\\n with open(fastq_file_1, 'w') as f_out:\\n f_out.write(fgz_in.read())\\n\\n with gzip.open(fastq_file_2 + '.gz', 'rb') as fgz_in:\\n with open(fastq_file_2, 'w') as f_out:\\n f_out.write(fgz_in.read())\\n\\n assert os.path.isfile(fastq_file_1) is True\\n assert os.path.getsize(fastq_file_1) > 0\\n assert os.path.isfile(fastq_file_2) is True\\n assert os.path.getsize(fastq_file_2) > 0\",\n \"def untgz(tgz_filename, out_dir):\\r\\n logging.info(\\\"Source: %s\\\" % tgz_filename)\\r\\n tgz = TgzHelper(tgz_filename, out_dir)\\r\\n tgz.extract()\",\n \"def _symlink_tar(self):\\r\\n outsidep = self.unsafe_common_dir / \\\"unsafe_file.txt\\\"\\r\\n symlinkp = self.unsafe_common_dir / \\\"symlink.txt\\\"\\r\\n symlink_tar = self.unsafe_common_dir / \\\"symlink.tar.gz\\\"\\r\\n outsidep.symlink(symlinkp)\\r\\n with tarfile.open(symlink_tar, \\\"w:gz\\\") as tar:\\r\\n tar.add(symlinkp)\\r\\n\\r\\n return symlink_tar\",\n \"def compress_to_tgz(in_path, tgz_fp):\\n t = tarfile.open(name = tgz_fp, mode = 'w:gz')\\n t.add(in_path, path.basename(in_path))\\n t.close()\",\n \"def dump_cworld_tar(\\n cooler_paths,\\n out_path,\\n):\\n\\n dataset_name = os.path.splitext(os.path.split(out_path)[1])[0]\\n\\n with tempfile.TemporaryDirectory() as cworld_tmp_path:\\n for cooler_path in cooler_paths:\\n res = cooler.Cooler(cooler_path).info[\\\"bin-size\\\"]\\n os.mkdir(os.path.join(cworld_tmp_path, \\\"C-\\\" + str(res)))\\n for iced, iced_label in [(True, \\\"iced\\\"), (False, \\\"raw\\\")]:\\n folder_path = os.path.join(cworld_tmp_path, \\\"C-\\\" + str(res), iced_label)\\n os.mkdir(folder_path)\\n\\n mat_path = os.path.join(\\n folder_path,\\n \\\"{}__C-{}-{}.matrix.gz\\\".format(dataset_name, res, iced_label),\\n )\\n\\n dump_cworld(\\n in_cooler=cooler_path, out=mat_path, iced=iced, iced_unity=False\\n )\\n\\n with tarfile.open(out_path, mode=\\\"w\\\") as archive:\\n archive.add(cworld_tmp_path, arcname=dataset_name, recursive=True)\",\n \"def untar(filepath, outfoldername='.', compression='r', deletesource=False):\\n import tarfile\\n\\n with tarfile.open(filepath, compression) as tfile:\\n filelist = tfile.getnames()\\n tfile.extractall(path=outfoldername)\\n\\n if deletesource:\\n try:\\n os.remove(filepath)\\n except:\\n raise Exception(\\\"Could not delete tar archive {0}.\\\".format(filepath))\\n\\n return filelist\",\n \"def _process_fileobj(self,\\n tar_file_obj: IO[bytes],\\n object_node: graph.COSObject) -> None:\\n with tarfile.open(fileobj=tar_file_obj) as tar_file:\\n gz_file_names = [f.name for f in tar_file.getmembers()\\n if f.name.endswith('.gz')]\\n for gz_file_name in gz_file_names:\\n gz_file_obj = tar_file.extractfile(gz_file_name)\\n if gz_file_obj:\\n oem_data = self._parse_oem_data(gz_file_obj)\\n aso_id = self._get_aso_id_from_file_name(gz_file_name)\\n self._save_oem(oem_data, aso_id, object_node)\",\n \"def debianize( strFilename ):\\n \\n #~ data = gzip.GzipFile( strFilename ).read();\\n #~ print data;\\n #~ return;\\n \\n #~ data = gzip.open( strFilename ).read();\\n #~ print data;\\n #~ return; \\n \\n #~ uncompressedData = bz2.BZ2File(strFilename).read()\\n #~ print str(uncompressedData)\\n #~ return;\\n \\n #~ file = open( strFilename, 'rb' );\\n #~ data = file.read();\\n #~ file.close();\\n #~ print debug.dumpHexa( data );\\n \\n #~ ar = tarfile.open(strFilename, 'r:*')\\n #~ for item in ar:\\n #~ print( str(item) );\\n #~ print( \\\"%s:\\\" % item.name );\\n #~ #print debug.dumpHexa(item.buf);\\n #~ #print zlib.decompress(item.buf)\\n #~ #print zlib.decompress(ar.extractfile(item).read())\\n #~ data = ar.extractfile(item.name).read()\\n #~ print data # works !\\n #~ ar.close() \\n #~ return;\\n \\n fileLists = [];\\n file = open( strFilename );\\n data = file.read();\\n file.close();\\n \\n print( \\\"data len: %d\\\" % len( data ) );\\n\\n nDataCompressedOffset = 0; # 132\\n\\n # works fine on toto.gz\\n #~ f = gzip.open(strFilename, 'rb')\\n #~ file_content = f.read()\\n #~ print file_content\\n #~ f.close() \\n \\n #~ decompressor = bz2.BZ2Decompressor();\\n #~ uncompressed = decompressor.decompress(data[nDataCompressedOffset:]);\\n \\n #~ uncompressed = zlib.decompress(data[nDataCompressedOffset:]);\\n \\n uncompressed = decompress( data );\\n print( \\\"uncompressed: %s\\\" % str( uncompressed ) );\",\n \"def targets_to_files(tinfoil, targets, with_includes=True):\\n files = []\\n if with_includes:\\n cfg_included = tinfoil.config_data.getVar('BBINCLUDED', True).split()\\n\\n for target in targets:\\n filename = tinfoil.get_recipe_file(target)\\n files.append(filename)\\n\\n if with_includes:\\n recipe_data = tinfoil.parse_recipe_file(filename)\\n recipe_included = recipe_data.getVar('BBINCLUDED', True).split()\\n final_included = [f for f in (set(recipe_included) - set(cfg_included)) if not f.endswith('.bbclass')]\\n final_included.sort(key=lambda k: k.endswith('.bbappend'))\\n\\n files.extend(final_included)\\n else:\\n appends = tinfoil.get_file_appends(filename)\\n files.extend(appends)\\n\\n return list(bbcmd.iter_uniq(bb.cache.virtualfn2realfn(f)[0] for f in files))\",\n \"def get_archive(katfilenames):\\n\\timport requests\\n\\n\\tfile_refs = []\\n\\tfor filename in katfilenames:\\n\\t\\tif filename.startswith('s3'):\\n\\t\\t\\tres = requests.post(S3_URL, headers=S3_HEAD, data='{\\\"s3_ref\\\":\\\"%s\\\",\\\"ref_key\\\":\\\"Nope\\\"}'%(filename,))\\n\\t\\t\\turl = res.json()['url']\\n\\t\\t\\tres1 = requests.get(url)\\n\\t\\t\\toutfile = filename.split('/')[-1]\\n\\t\\t\\topen(outfile, 'wb').write(res1.content)\\n\\t\\t\\tfile_refs.append(outfile)\\n\\t\\telse:\\n\\t\\t\\tfile_refs.append(filename)\\n\\treturn file_refs\",\n \"def align_rasters(ref_raster, tar_raster, output_suffix):\\n command = [\\\"gdalbuildvrt\\\", \\\"-te\\\"]\\n hDataset = gdal.Open(ref_raster, gdal.GA_ReadOnly)\\n if hDataset is None:\\n return False\\n adfGeoTransform = hDataset.GetGeoTransform(can_return_null=True)\\n\\n tif_file=tar_raster\\n vrt_file = tif_file.replace('.tif', '.vrt')\\n\\n if adfGeoTransform is not None:\\n dfGeoXUL = adfGeoTransform[0]\\n dfGeoYUL = adfGeoTransform[3]\\n dfGeoXLR = adfGeoTransform[0] + adfGeoTransform[1] * hDataset.RasterXSize + \\\\\\n adfGeoTransform[2] * hDataset.RasterYSize\\n dfGeoYLR = adfGeoTransform[3] + adfGeoTransform[4] * hDataset.RasterXSize + \\\\\\n adfGeoTransform[5] * hDataset.RasterYSize\\n xres = str(abs(adfGeoTransform[1]))\\n yres = str(abs(adfGeoTransform[5]))\\n\\n subprocess.call(command + [str(dfGeoXUL), str(dfGeoYLR), str(dfGeoXLR),\\n str(dfGeoYUL), \\\"-q\\\", \\\"-tr\\\", xres, yres,\\n vrt_file, tif_file])\\n\\n output_file = tif_file.replace('.tif', output_suffix)\\n\\n print('gdal_translate -q {} {}'.format(vrt_file, output_file))\\n\\n cmd = 'gdal_translate -q {} {}'.format(vrt_file, output_file)\\n\\n #print(dfGeoXUL, dfGeoYLR, dfGeoXLR, dfGeoYUL, xres, yres)\\n\\n subprocess.call(cmd, shell=True)\\n os.remove(vrt_file)\\n\\n return True\\n\\n else:\\n\\n return False\",\n \"def tarsum(input_file, hash, output_file):\\n tar = tarfile.open(mode=\\\"r:*\\\", fileobj=input_file)\\n\\n chunk_size = 100*1024\\n store_digests = {}\\n\\n for member in tar:\\n if not member.isfile():\\n continue\\n f = tar.extractfile(member)\\n h = hashlib.new(hash)\\n data = f.read(chunk_size)\\n while data:\\n h.update(data)\\n data = f.read(chunk_size)\\n output_file.write(\\\"%s %s\\\\n\\\" % (h.hexdigest(), member.name))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65684086","0.6300177","0.62254524","0.6161973","0.60660845","0.59409815","0.58384496","0.57276076","0.5682935","0.5628571","0.55928606","0.5521933","0.55169624","0.55039227","0.54637206","0.5451794","0.54454917","0.542897","0.53728896","0.53632414","0.53512156","0.53462344","0.53419393","0.5340621","0.5340621","0.53259456","0.53176475","0.5296687","0.52815175","0.52722424","0.5268338","0.5263532","0.52624065","0.52524173","0.5230877","0.52297634","0.52019596","0.5200435","0.5196786","0.5173833","0.5153547","0.51500887","0.5149109","0.5143226","0.5121677","0.5120327","0.5117766","0.50997025","0.5097157","0.5087177","0.50754285","0.5074045","0.5072655","0.507023","0.50661033","0.5065199","0.505431","0.5041617","0.5041505","0.5041488","0.50399965","0.50268704","0.50185084","0.5011009","0.50104773","0.49972716","0.4996249","0.498835","0.49839228","0.49732044","0.49678412","0.49677533","0.49670905","0.49655682","0.4963229","0.49605626","0.49571812","0.49562004","0.4936945","0.4908783","0.49074307","0.49040413","0.49038035","0.48968178","0.48921224","0.4887629","0.48836622","0.48818266","0.48811767","0.4876956","0.48753756","0.4855794","0.48535028","0.48517457","0.48470357","0.4845349","0.48396817","0.4815407","0.48138756","0.4801061"],"string":"[\n \"0.65684086\",\n \"0.6300177\",\n \"0.62254524\",\n \"0.6161973\",\n \"0.60660845\",\n \"0.59409815\",\n \"0.58384496\",\n \"0.57276076\",\n \"0.5682935\",\n \"0.5628571\",\n \"0.55928606\",\n \"0.5521933\",\n \"0.55169624\",\n \"0.55039227\",\n \"0.54637206\",\n \"0.5451794\",\n \"0.54454917\",\n \"0.542897\",\n \"0.53728896\",\n \"0.53632414\",\n \"0.53512156\",\n \"0.53462344\",\n \"0.53419393\",\n \"0.5340621\",\n \"0.5340621\",\n \"0.53259456\",\n \"0.53176475\",\n \"0.5296687\",\n \"0.52815175\",\n \"0.52722424\",\n \"0.5268338\",\n \"0.5263532\",\n \"0.52624065\",\n \"0.52524173\",\n \"0.5230877\",\n \"0.52297634\",\n \"0.52019596\",\n \"0.5200435\",\n \"0.5196786\",\n \"0.5173833\",\n \"0.5153547\",\n \"0.51500887\",\n \"0.5149109\",\n \"0.5143226\",\n \"0.5121677\",\n \"0.5120327\",\n \"0.5117766\",\n \"0.50997025\",\n \"0.5097157\",\n \"0.5087177\",\n \"0.50754285\",\n \"0.5074045\",\n \"0.5072655\",\n \"0.507023\",\n \"0.50661033\",\n \"0.5065199\",\n \"0.505431\",\n \"0.5041617\",\n \"0.5041505\",\n \"0.5041488\",\n \"0.50399965\",\n \"0.50268704\",\n \"0.50185084\",\n \"0.5011009\",\n \"0.50104773\",\n \"0.49972716\",\n \"0.4996249\",\n \"0.498835\",\n \"0.49839228\",\n \"0.49732044\",\n \"0.49678412\",\n \"0.49677533\",\n \"0.49670905\",\n \"0.49655682\",\n \"0.4963229\",\n \"0.49605626\",\n \"0.49571812\",\n \"0.49562004\",\n \"0.4936945\",\n \"0.4908783\",\n \"0.49074307\",\n \"0.49040413\",\n \"0.49038035\",\n \"0.48968178\",\n \"0.48921224\",\n \"0.4887629\",\n \"0.48836622\",\n \"0.48818266\",\n \"0.48811767\",\n \"0.4876956\",\n \"0.48753756\",\n \"0.4855794\",\n \"0.48535028\",\n \"0.48517457\",\n \"0.48470357\",\n \"0.4845349\",\n \"0.48396817\",\n \"0.4815407\",\n \"0.48138756\",\n \"0.4801061\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5832278"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":83185,"cells":{"query":{"kind":"string","value":"Gunzips the file if gzipped. Also works on bgzipped files."},"document":{"kind":"string","value":"def extract_gzip(fname: str, outfile: Optional[str] = None) -> Union[str, None]:\n if not outfile:\n outfile = fname[:-3]\n\n if fname.endswith(\".gz\"):\n with gzip.open(fname, \"rb\") as f_in:\n with open(outfile, \"wb\") as f_out:\n shutil.copyfileobj(f_in, f_out)\n os.unlink(fname)\n return outfile"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def gunzip_file(gzip_file, base_dir):\n full_gzip_file = os.path.join(base_dir, gzip_file)\n if not gzip_file.endswith(\".gz\"):\n return gzip_file\n gunzip_file = full_gzip_file.replace(\".gz\", \"\")\n with gzip.open(full_gzip_file, 'rb') as f_in:\n with open(gunzip_file, 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)\n # Now that file is extracted. Remove file\n os.remove(full_gzip_file)\n\n return os.path.basename(gunzip_file)","def gunzip(data):\n return gzip.GzipFile(fileobj=StringIO(data)).read()","def gunzip_file(gz_path, new_path):\n print(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def gunzip_file(gz_path, new_path):\n print(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def gunzip_file(gz_path, new_path):\n logging.info(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def gunzip_file(gz_path, new_path):\n print(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def gunzip(data):\n f = GzipFile(fileobj=BytesIO(data))\n output_list = []\n chunk = b'.'\n while chunk:\n try:\n chunk = read1(f, 8196)\n output_list.append(chunk)\n except (IOError, EOFError, struct.error):\n if output_list or getattr(f, 'extrabuf', None):\n try:\n output_list.append(f.extrabuf[-f.extrasize:])\n finally:\n break\n else:\n raise\n return b''.join(output_list)","def ungz(filepath, compression='rb', deletesource=False):\n\n import gzip\n\n with gzip.open(filepath, compression) as f:\n outF = open(filepath[:-3], 'wb')\n outF.write(f.read())\n f.close()\n outF.close()\n if deletesource:\n try:\n os.remove(filepath)\n except:\n raise Exception(\"Could not delete gz archive {0}.\".format(filepath))\n\n return filepath[:-3]","def __unzip(self, data):\n compressed = StringIO.StringIO(data)\n gzipper = gzip.GzipFile(fileobj=compressed)\n return gzipper.read()","def ungzip(path):\n unzip_path = \"\".join(path.split(\".\")[0]+\".fna\")\n with gzip.open(path, 'rb') as f_in:\n with open(unzip_path, 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)\n os.remove(path)\n return unzip_path","def clean_gzip():\n this_dir = os.getcwd()\n os.chdir(\"/data/COHERENT2/data/CrystalChar/raw\")\n all_files = glob.glob(\"./**\", recursive=True)\n for f in all_files:\n if \".gz\" in f and \"tar\" not in f:\n print(f)\n sh(\"gunzip \" + f)\n os.chdir(this_dir)","def _gzip_file(filename):\n gzip_filename = filename + '.gz'\n with open(filename, 'rb') as f_in, gzip.open(gzip_filename, 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)","def extracted_file(fname: str):\n new_fname = extract_gzip(fname)\n gzipped = True\n if new_fname is None:\n new_fname = fname\n gzipped = False\n\n try:\n yield new_fname\n finally:\n if gzipped:\n try:\n bgzip_and_name(new_fname)\n except Exception:\n gzip_and_name(new_fname)","def handle_file(self, path):\n\n if path:\n if not matches_patterns(path, self.gzip_patterns):\n return\n\n try:\n original_file = self.open(path, mode=\"rb\")\n except FileNotFoundError:\n pass\n else:\n gzipped_path = \"{0}.gz\".format(path)\n\n if self.exists(gzipped_path):\n self.delete(gzipped_path)\n\n gzipped_file = self._compress(original_file)\n gzipped_path = self.save(gzipped_path, gzipped_file)\n\n return gzipped_path, gzipped_path, True","def de_gzip(data):\n cmps = StringIO.StringIO(data)\n gzipper = gzip.GzipFile(fileobj=cmps)\n return gzipper.read()","def de_gzip(data):\n cmps = StringIO.StringIO(data)\n gzipper = gzip.GzipFile(fileobj=cmps)\n return gzipper.read()","def _unzip(self, data):\r\n with io.BytesIO(data) as buf:\r\n with gzip.GzipFile(fileobj=buf) as unzipped:\r\n return unzipped.read()","def uncompress_gzip(location, target_dir):\n\n return uncompress(location, target_dir, decompressor=gzip.GzipFile)","def _extract_gz(src, dst):\n assert src.endswith(\".gz\"), \"{} is not a valid .gz file.\".format(src)\n assert os.path.exists(src), \"{} does not exist.\".format(src)\n\n with gzip.open(src, \"rb\") as f_src:\n # xxx.postfix.gz --> xxx.postfix\n file_name = os.path.basename(src)[:-3]\n with open(os.path.join(dst, file_name), \"wb\") as f_dst:\n shutil.copyfileobj(f_src, f_dst)","def decompress_gzip(in_str):\n import gzip\n # gzip can only handle file object therefore using StringIO\n copmressed_stream = StringIO.StringIO(in_str)\n gzipper = gzip.GzipFile(fileobj=copmressed_stream)\n s = gzipper.read()\n gzipper.close()\n return s","def decompress_gzip(in_str):\n # gzip can only handle file object therefore using StringIO\n copmressed_stream = StringIO.StringIO(in_str)\n gzipper = gzip.GzipFile(fileobj=copmressed_stream)\n s = gzipper.read()\n gzipper.close()\n return s","def gzopen(f):\n return gzip.open(f, 'rb') if f.endswith('.gz') else open(f, 'r')","def read_gzipped(response):\r\n if response.info().get('Content-Encoding') == 'gzip':\r\n with io.BytesIO(response.read()) as buf:\r\n with gzip.GzipFile(fileobj=buf) as unzipped:\r\n data = unzipped.read()\r\n else:\r\n data = response.read()\r\n return data","def skip_gzip_check(self):\r\n _read_eof = gzip._GzipReader._read_eof\r\n gzip.GzipFile._read_eof = lambda *args, **kwargs: None\r\n yield\r\n gzip.GzipFile._read_eof = _read_eof","def _check_zip_file (filename, path_unzip, outfile) :\n assert path_unzip is not None\n file,ext = os.path.splitext (filename)\n ext = ext.lower ()\n if ext == \".gz\" :\n \n import gzip\n \n if outfile is None :\n dest = filename.split (\"!\")\n dest = dest [ len(dest)-1 ]\n ext = os.path.splitext (dest) [1]\n dest = dest.replace (ext, \".txt\")\n path = os.path.split (filename)\n path = \"/\".join (path [:len (path)-1])\n dest = path + \"/\" + dest\n else :\n dest = outfile\n \n if not os.path.exists (dest) :\n file = gzip.GzipFile (filename, \"r\")\n if outfile is None :\n dest = os.path.split (dest) [1]\n dest = os.path.join (path_unzip, dest)\n \n if os.path.exists (dest) :\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\n if st2 > st1 : \n fLOG (\"ungzipping file (already done)\", dest)\n return dest\n \n fLOG (\"ungzipping file\", dest)\n f = open (dest, \"w\")\n data = file.read (2**27)\n size = 0\n while len (data) > 0 :\n size += len (data)\n fLOG (\"ungzipping \", size, \"bytes\")\n if isinstance (data, bytes) : f.write (bytes.decode (data))\n else : f.write (data)\n data = file.read (2**27)\n f.close ()\n file.close ()\n \n return dest\n \n if ext == \".zip\" :\n \n import zipfile\n try :\n file = zipfile.ZipFile (filename, \"r\")\n except Exception as e :\n fLOG (\"problem with \", filename)\n raise e\n \n if len (file.infolist()) != 1:\n if outfile is not None :\n raise PQHException (\"the archive contains %d files and not one as you expected by filling outfile\" % len (file.infolist()))\n fLOG (\"unzip file (multiple) \", filename)\n #message = \"\\n\".join ([ fi.filename for fi in file.infolist() ] )\n #raise Exception.YstException(\"ColumnInfoSet.load_from_file: file %s contains no file or more than one file\\n\" + message)\n folder = os.path.split (filename) [0]\n todo = 0\n _zip7_path = r\"c:\\Program Files\\7-Zip\"\n zip7 = os.path.exists (_zip7_path)\n wait = [ ]\n for info in file.infolist () :\n fileinside = info.filename\n dest = os.path.join (folder, fileinside)\n if not os.path.exists (dest) :\n fol = os.path.split (dest) [0]\n if not os.path.exists (fol) : os.makedirs (fol)\n if os.path.exists (dest) :\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\n if st2 > st1 : \n continue\n \n if not sys.platform.startswith(\"win\") or not zip7 :\n data = file.read (fileinside)\n dest = os.path.split (dest) [1]\n dest = os.path.join (path_unzip, dest)\n fLOG (\"unzipping file\", dest)\n wait.append(dest)\n f = open (dest, \"w\")\n if isinstance (data, bytes) :\n f.write (str (data))\n else :\n f.write (data)\n f.close ()\n else :\n todo += 1\n \n if todo > 0 and zip7 :\n dest = os.path.realpath (path_unzip)\n cmd = '\"' + _zip7_path + '\\\\7z.exe\" e -y -o\"%s\" \"%s\"' % (dest, os.path.realpath (filename)) \n out,err = run_cmd (cmd, wait = True)\n if len (err) > 0 : raise PQHException (\"command {0} failed\\n{1}\".format(cmd,err))\n if \"Error\" in out : raise PQHException (\"command {0} failed\\n{1}\".format(cmd,out))\n else :\n dest = path_unzip\n \n file.close ()\n \n ch = False\n while not ch :\n ch = True\n for a in wait :\n if not os.path.exists(a) : \n ch = False\n break\n time.sleep(0.5)\n \n return dest\n \n else :\n for info in file.infolist () :\n fileinside = info.filename\n \n path = os.path.split (filename)\n dest = outfile if outfile is not None else path [0] + \"/\" + fileinside\n if not os.path.exists (dest) :\n data = file.read (fileinside)\n if outfile is None :\n dest = os.path.split (dest) [1]\n dest = os.path.join (path_unzip, dest)\n \n if os.path.exists (dest) :\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\n if st2 > st1 : \n fLOG(\"unzipping one file (already done)\", dest)\n return dest\n \n fLOG(\"unzipping one file\", dest)\n f = open (dest, \"w\")\n if isinstance (data, bytes) :\n f.write (bytes.decode (data))\n else :\n f.write (data)\n f.close ()\n file.close ()\n return dest\n \n return filename","def is_gz_file(f):\n with open(f, \"rb\") as fin:\n return binascii.hexlify(fin.read(2)) == b\"1f8b\"","def _gz(filename):\n \n with open(filename, 'rb') as f:\n return binascii.hexlify(f.read(2)) == b'1f8b'","def is_gzipped(response):\n ctype = response.headers.get('Content-Type', b'').lower()\n cenc = response.headers.get('Content-Encoding', b'').lower()\n return (_is_gzipped(ctype) or\n (_is_octetstream(ctype) and cenc in (b'gzip', b'x-gzip')))","def gzipFile(aFile):\n f_in = open(aFile, \"rb\")\n f_out = gzip.open(aFile + \".gz\", \"wb\")\n f_out.writelines(f_in)\n f_out.close()\n f_in.close()\n os.remove(aFile)","def is_gzipped(infile):\n logger = logging.getLogger(__name__)\n\n magic_number = b'\\x1f\\x8b'\n f = open(infile, 'rb')\n with f:\n try:\n assert f.read(2) == magic_number\n except AssertionError as e:\n logger.info(f'{infile} is not gzipped')\n return False\n else:\n logger.debug(f'{infile} is gzipped')\n return True","def unzip(filepath, cleanup=False):\n\t(uzfile, ext) = os.path.splitext(filepath)\n\tif ext != '.gz':\n\t\treturn filepath\n\tif os.path.exists(uzfile):\n\t\treturn uzfile\n\t\n\twith gzip.open(filepath, 'rb') as f_in:\n\t\twith open(uzfile, 'w') as f_out:\n\t\t\tfor line in f_in:\n\t\t\t\tf_out.write(line.decode())\n\t\n\tif cleanup and file_exists(uzfile):\n\t\tos.remove(filepath)\n\treturn uzfile","def gzip_compress(data):\n s = BytesIO()\n g = gzip.GzipFile(fileobj=s, mode='wb')\n g.write(data)\n g.close()\n return s.getvalue()","def open_gzip(fn):\n magic = b'\\x1f\\x8b\\x08'\n l = len(magic)\n with open(fn, 'rb') as f:\n file_start = f.read(l)\n f.seek(0)\n # check if the file is compressed\n if file_start.startswith(magic):\n return gzip.open(fn, 'rt')\n # not compressed\n return open(fn, 'rt')","def is_gzip(fp):\r\n return open(fp, 'rb').read(2) == '\\x1f\\x8b'","def compress(filename, remove=False):\n import gzip\n fin = open(filename, 'rb')\n fout = gzip.open(filename+'.gz', 'wb')\n fout.writelines(fin)\n fout.close()\n fin.close()\n if remove == True:\n os.remove(filename)\n return","def open_gz(filename, mode):\n return gzip.open(filename, mode)","def isgzip(filename):\n magic_number = b'\\x1f\\x8b\\x08'\n with open(filename, 'rb') as f:\n file_start = f.read(len(magic_number))\n\n if magic_number == file_start:\n return True\n return False","def unzip(zipped_file):\n with gzip.open(zipped_file, 'rt', encoding='ISO-8859-1') as file:\n file = file.read()\n return file","def do_gzip(fileobj):\r\n sio = cStringIO.StringIO()\r\n gzf = gzip.GzipFile(fileobj = sio, mode = \"wb\")\r\n while True:\r\n data = fileobj.read(buf_size)\r\n if not data:\r\n break\r\n gzf.write(data)\r\n gzf.close()\r\n return sio","def get_gff(url, dir):\n zip_path = ftp_download(url, dir)\n unzip_path = ungzip(zip_path)\n return unzip_path","def _compress_string(content):\n zbuf = StringIO()\n zfile = GzipFile(mode='wb', compresslevel=6, fileobj=zbuf)\n zfile.write(content)\n zfile.close()\n return zbuf.getvalue()","def read_gzip_file_content(self, s3_path):\n s3_object = self._get_s3_object(s3_path)\n\n bytestream = BytesIO(s3_object.get()['Body'].read())\n\n gzip_file = GzipFile(mode=\"rb\", fileobj=bytestream)\n output = gzip_file.read().decode(\"utf-8\")\n\n return output","def test_decompress_file():\n gz_file = os.path.join(\n tempfile.gettempdir(),\n \"jade-unit-test-file.gz\",\n )\n with gzip.open(gz_file, \"wb\") as f:\n f.write(b\"Hello World\")\n assert os.path.exists(gz_file)\n\n new_file = decompress_file(gz_file)\n assert os.path.exists(new_file)\n with open(new_file, \"r\") as f:\n data = f.read()\n assert data == \"Hello World\"\n\n if os.path.exists(gz_file):\n os.remove(gz_file)\n\n if os.path.exists(new_file):\n os.remove(new_file)","def _downloadWGS(WGSurl) :\n gzipContent = urllib2.urlopen(WGSurl).read()\n gzipFile = StringIO.StringIO(gzipContent)\n o = gzip.GzipFile(fileobj = gzipFile)\n output = None\n try :\n output = o.read()\n except IOError as e:\n print(e)\n o.close()\n return output","def zipfile(filepath, cleanup=False):\n\tzfile = filepath+\".gz\"\n\twith open(filepath, 'rb') as f_in:\n\t\twith gzip.open(zfile, 'wb') as f_out:\n\t\t\tf_out.writelines(f_in)\t\n\t\n\tif cleanup and file_exists(zfile):\n\t\tos.remove(filepath)\n\treturn zfile","def decompress_stream(src, dst):\n with gzip.GzipFile(fileobj=src, mode='rb') as gz:\n for block in iterfile(gz):\n dst.write(block)","def decompress(filename):\n print(\"\\n# start decompression of file: %s \\n#############################################\" % filename)\n\n # check if handed filename has the extension .gz\n if \".gz\" in filename: # if file has the extension gz\n\n if os.path.exists(filename): # check if the file exists\n\n print(\"# filename enthält die endung gz : %s\" % filename)\n\n # if the file was found on the system split its string at the '.gz' position and use evereything before\n filename_txt = filename.split(\".gz\")[0]\n\n print(\"# txt filename: \", filename_txt)\n\n # create an txt file with string before the '.gz' extension and decompress the content of the .gz file\n with gzip.open(filename, 'rb') as decompressFile:\n with open(filename_txt, 'wb') as receivingFile:\n shutil.copyfileobj(decompressFile, receivingFile)\n\n # if the file was not found download it and decompress the content\n else:\n print(\"# ERROR - %s konnte nicht gefunden werden!!\" % filename)\n\n download(HOST, DIRECTORY, filename)\n filename_txt = decompress(filename)\n print(\"# return \", filename_txt)\n return filename_txt\n # if the handed filename has no '.gz' extension throw an Exception\n else:\n\n raise Exception(\"# not a gzip file\")","def save_to_gzip(data,fname):\n with gzip.open(fname + '.gz', 'wb',compresslevel = 9) as f:\n f.write(data.tobytes())","def decompress_file(path, temp_dir='tmp'):\n if path.endswith('.gz'):\n logger.info('Decompressing {} to {}'.format(path, temp_dir))\n return decompress_gzip(\n path,\n os.path.join(temp_dir,\n os.path.splitext(os.path.basename(path))[0])\n )\n else:\n return path","def zip_file(file_path: str) -> str:\n zip_file_path: str = file_path + \".gz\"\n\n print(f\"Compressing {file_path} into {zip_file_path}\")\n timestamp=path.getmtime(file_path)\n with open(file_path, \"rb\") as read_stream:\n with gzip.open(zip_file_path, \"wb\") as write_stream:\n shutil.copyfileobj(read_stream, write_stream)\n os.utime(zip_file_path, (timestamp,timestamp) )\n\n return zip_file_path","def is_zip(filepath):\n\treturn os.path.splitext(filepath)[1] == '.gz'","def are_files_gzipped(raw_files):\n files_are_gzipped = None\n for file_name in raw_files:\n if re.search(r\"\\.gz$\", file_name) is not None:\n if files_are_gzipped is False:\n raise Exception(\n \"It seems one file is compressed and the \"\n \"other is \"\n \"not:\\n{}\".format(\"\\n\".join(raw_files))\n )\n files_are_gzipped = True\n else:\n if files_are_gzipped:\n raise Exception(\n \"It seems one file is compressed and the \"\n \"other is \"\n \"not:\\n{}\".format(\"\\n\".join(raw_files))\n )\n files_are_gzipped = False\n return files_are_gzipped","def _extract_all_gz_in_dir(directory):\n for file in os.listdir(directory):\n if file.endswith(\".gz\"):\n gz_fname = os.path.join(directory, file)\n _extract_gz(gz_fname, os.path.dirname(gz_fname))\n os.remove(gz_fname)","def test_compress_file_response(self):\n with open(__file__, \"rb\") as file1:\n\n def get_response(req):\n file_resp = FileResponse(file1)\n file_resp[\"Content-Type\"] = \"text/html; charset=UTF-8\"\n return file_resp\n\n r = GZipMiddleware(get_response)(self.req)\n with open(__file__, \"rb\") as file2:\n self.assertEqual(self.decompress(b\"\".join(r)), file2.read())\n self.assertEqual(r.get(\"Content-Encoding\"), \"gzip\")\n self.assertIsNot(r.file_to_stream, file1)","def compress_file(path):\n\n process = Popen([\"xz\", \"--compress\", \"--force\", \"--stdout\", path], stdout=PIPE)\n return process.communicate()[0]","def compress_file(path):\n\n process = Popen([\"xz\", \"--compress\", \"--force\", \"--stdout\", path], stdout=PIPE)\n return process.communicate()[0]","def gzip_files(topDir, afni_file,localizerfile):\n\n print 'GZIPPING FILES...'\n\n command1 = \"gzip %s*BRIK\" % (topDir)\n command2 = \"gzip %s*HEAD\" % (topDir)\n command3 = \"gzip %s%s/pb00*\" % (topDir,afni_file)\n command4 = \"gzip %s%s/errts*\" % (topDir,afni_file)\n command5 = \"gzip %s%s/fitts*\" % (topDir,afni_file)\n command6 = \"gzip %s%s/*al*\" % (topDir,afni_file)\n command7 = \"gzip %s%s/*ns*\" % (topDir,afni_file)\n command8 = \"gzip %s%s/all_runs*\" % (topDir,afni_file)\n command9 = \"gzip %s%s/*mask*\" % (topDir,afni_file)\n command10 = \"gzip %s*nii\" % (topDir)\n command11 = \"gzip %s%s/pb01*\" % (topDir,afni_file)\n command12 = \"gzip %s%s/pb03*\" % (topDir,afni_file)\n command13 = \"gzip %s%s/pb02*\" % (topDir,afni_file)\n\n os.system(command1)\n os.system(command2)\n os.system(command3)\n os.system(command4)\n os.system(command5)\n os.system(command6)\n os.system(command7)\n os.system(command8)\n #os.system(command9)\n os.system(command10)\n os.system(command11)\n try:\n os.system(command12)\n except:\n print 'Could not gzip pb03 files'\n\n if localizerfile == 'facescene_loc':\n os.system(command13)","def _extract(self, file_path):\n self._log.debug(\"Extracting file {!r}\".format(\n os.path.basename(file_path)\n ))\n tar = tarfile.open(file_path, \"r:gz\")\n tar.extractall(os.path.dirname(file_path))\n tar.close()","def gzip_worker(args):\n\tp = multiprocessing.current_process()\n\tprint('Start zipping %s: %s %s' %(args[1], p.name, p.pid))\n\tpath = args[0]\n\tfilename = args[1]\n\tassert os.path.splitext(filename)[1] == '.fastq', '%s is not a fastq file' %filename \n\t\n\tcall = 'gzip -c ' + os.path.join(path, filename) + ' > ' + os.path.join(path, filename) + '.gz'\n\tsubprocess.call(call, shell=True)\n\tprint('Completed zipping %s: %s %s' %(filename, p.name, p.pid))","def tar_gz_compress(self, destination):\n\n if destination is not None and isinstance(destination, str):\n with tarfile_open(destination, \"w:gz\") as tar:\n tar.add(self.file)","def is_gzip_result(self):\n return self.__aceQLHttpApi.is_gzip_result()","def unpack(file_path, extraction_path, remove):\n print(file_path)\n Archive(file_path).extractall(extraction_path, auto_create_dir=True)\n # remove original compressed file???\n if remove is True:\n os.remove(file_path)","def __init__(self, input_stream, level=9):\n super(Gzip, self).__init__(input_stream)\n\n self._level = level","def _compress_content(self, content):\n zbuf = io.BytesIO()\n zfile = gzip.GzipFile(mode=\"wb\", compresslevel=9, fileobj=zbuf)\n\n try:\n zfile.write(content.read())\n finally:\n zfile.close()\n\n content.file = zbuf\n content.seek(0)\n\n return content","def gzipPage(page):\n #if not hasattr(page,\"info\"):\n # return(\"\")\n data = object()\n # Check if content encoding is gzip\n if page.info().get('Content-Encoding') == 'gzip':\n buf = StringIO(page.read())\n f = gzip.GzipFile(fileobj=buf)\n data = f.read()\n else :\n data = page.read()\n return(data)","def gzip_and_name(fname, gzip_file=True) -> str:\n if gzip_file:\n with open(fname, \"rb\") as f_in:\n with gzip.open(fname + \".gz\", \"wb\") as f_out:\n shutil.copyfileobj(f_in, f_out)\n os.unlink(fname)\n fname += \".gz\"\n return fname","def open_gzipped(infile, mode='rt'):\n import gzip\n import bz2\n if mode.startswith('r'):\n tmode = 'rt'\n bmode = 'r'\n elif mode.startswith('w'):\n tmode = 'wt'\n bmode = 'w'\n elif mode.startswith('a'):\n tmode = 'at'\n bmode = 'a'\n if hasattr(infile, 'write'):\n return infile\n if isinstance(infile, str):\n if infile.endswith('.gz'):\n return gzip.open(infile, tmode)\n if infile.endswith('.bz2'):\n if hasattr(bz2, 'open'):\n return bz2.open(infile, tmode)\n else:\n return bz2.BZ2File(infile, bmode)\n return open(infile, tmode)","def compress_file(map_, name, save_path):\n size = os.path.getsize(save_path)\n temp = subprocess.run([\"gzip\", \"-k\", save_path])\n cr_size = os.path.getsize(save_path+\".gz\")\n try:\n map_[name] = cr_size / size\n except Exception as e:\n print(f\"File: {save_path}, Ori:{size}, Compr:{cr_size}\")\n print(e)\n raise ZeroDivisionError\n temp = subprocess.run([\"rm\", save_path])\n temp = subprocess.run([\"rm\", save_path+\".gz\"])","def untgz(tgz_filename, out_dir):\r\n logging.info(\"Source: %s\" % tgz_filename)\r\n tgz = TgzHelper(tgz_filename, out_dir)\r\n tgz.extract()","def _uncompress(fname, outdir, msg=msg):\n import os\n assert os.access(fname, os.R_OK), \"could not access [%s]\" % fname\n fname = os.path.abspath(os.path.realpath(fname))\n if not os.path.exists(outdir):\n os.makedirs(outdir)\n orig_dir = os.getcwd()\n try:\n os.chdir(outdir)\n ext = os.path.splitext(fname)[1][1:] # drop the dot\n if ext in ('gz', 'bz2'):\n import tarfile\n f = tarfile.open(fname, 'r:%s'%ext)\n f.extractall()\n else:\n err = 'extension [%s] not handled (yet?)' % ext\n msg.error(err)\n raise ValueError(err)\n finally:\n os.chdir(orig_dir)","def uncompress(path, dest=None, remove=True):\n # assert path.endswith('.zip')\n prefix, ext = split_if_compressed(path)\n folder_name = os.path.basename(prefix)\n file_is_zip = ext == '.zip'\n root_of_folder = None\n if ext == '.gz':\n try:\n with gzip.open(path, 'rb') as f_in, open(prefix, 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)\n except Exception as e:\n remove_file(prefix)\n remove_file(path)\n raise e\n else:\n try:\n with zipfile.ZipFile(path, \"r\") if ext == '.zip' else tarfile.open(path, 'r:*') as archive:\n if not dest:\n namelist = sorted(archive.namelist() if file_is_zip else archive.getnames())\n if namelist[0] == '.':\n namelist = namelist[1:]\n namelist = [p[len('./'):] if p.startswith('./') else p for p in namelist]\n if ext == '.tgz':\n roots = set(x.split('/')[0] for x in namelist)\n if len(roots) == 1:\n root_of_folder = next(iter(roots))\n else:\n # only one file, root_of_folder = ''\n root_of_folder = namelist[0].strip('/') if len(namelist) > 1 else ''\n if all(f.split('/')[0] == root_of_folder for f in namelist[1:]) or not root_of_folder:\n dest = os.path.dirname(path) # only one folder, unzip to the same dir\n else:\n root_of_folder = None\n dest = prefix # assume zip contains more than one file or folder\n print('Extracting {} to {}'.format(path, dest))\n archive.extractall(dest)\n if root_of_folder:\n if root_of_folder != folder_name:\n # move root to match folder name\n os.rename(path_join(dest, root_of_folder), path_join(dest, folder_name))\n dest = path_join(dest, folder_name)\n elif len(namelist) == 1:\n dest = path_join(dest, namelist[0])\n except Exception as e:\n remove_file(path)\n if os.path.exists(prefix):\n if os.path.isfile(prefix):\n os.remove(prefix)\n elif os.path.isdir(prefix):\n shutil.rmtree(prefix)\n raise e\n if remove:\n remove_file(path)\n return dest","def _read_gzip_header(input):\n header = {\n \"extra_field\": {}\n }\n\n magic, flags, mtime = struct.unpack(\"<3sBIxx\", _read_exactly(input, 10))\n if magic != compressor.GZIP_DEFLATE_ID:\n raise IOError(\"Not a gzip-deflate file.\")\n\n if compressor.FRESERVED & flags:\n raise IOError(\"Unknown reserved flags: %s\" % flags)\n\n if compressor.FEXTRA & flags:\n xlen = _read16(input)\n extra_field = input.read(xlen)\n header[\"extra_field\"] = _split_subfields(extra_field)\n\n if compressor.FNAME & flags:\n _skip_cstring(input)\n\n if compressor.FCOMMENT & flags:\n _skip_cstring(input)\n\n if compressor.FHCRC & flags:\n # Skips header CRC\n input.read(2)\n\n return header","def get_infile(filename):\r\n if filename.endswith(\".gz\"):\r\n fin = GzipFile(filename, \"rb\")\r\n else:\r\n fin = open(filename, \"U\")\r\n return fin","def get_infile(filename):\r\n if filename.endswith(\".gz\"):\r\n fin = GzipFile(filename, \"rb\")\r\n else:\r\n fin = open(filename, \"U\")\r\n return fin","def compress_stream(src, dst):\n with gzip.GzipFile(fileobj=dst, mode='wb') as gz:\n for block in iterfile(src):\n gz.write(block)","def gzip_lvl(self):\r\n return self._gzip_lvl","def _determine_compression_safe_file_opener(self):\n f = gzip.open(self.input_fname, \"r\")\n try:\n f.read(1)\n self._compression_safe_file_opener = gzip.open\n except IOError:\n self._compression_safe_file_opener = open\n finally:\n f.close()","def archive_file(filename, maxsize):#{{{\n if not os.path.exists(filename):\n print(filename, \"does not exist. ignore.\", file=sys.stderr)\n return 1\n\n filesize = os.path.getsize(filename)\n if filesize > maxsize:\n cnt = 0\n zipfile = \"\"\n while 1:\n cnt += 1\n zipfile = \"%s.%d.gz\"%(filename, cnt)\n if not os.path.exists(zipfile):\n break\n # write zip file\n try:\n f_in = open(filename, 'rb')\n except IOError:\n print(\"Failed to read %s\"%(filename), file=sys.stderr)\n return 1\n try:\n f_out = gzip.open(zipfile, 'wb')\n except IOError:\n print(\"Failed to write to %s\"%(zipfile), file=sys.stderr)\n return 1\n\n f_out.writelines(f_in)\n f_out.close()\n f_in.close()\n print(\"%s is archived to %s\"%(filename, zipfile))\n os.remove(filename)\n return 0","def default_unzip_s3_object_handler_function(response):\n bytestream = BytesIO(response[\"Body\"].read())\n raw_object = GzipFile(None, \"rb\", fileobj=bytestream).read()\n try:\n # decode if allowed\n return_object = raw_object.decode(\"utf-8\")\n except AttributeError:\n return_object = raw_object\n return json.loads(return_object)","def isGzippable(self, css=0, js=0, REQUEST=None):\n # force: force http compression even if the browser doesn't send an accept\n # debug: return compression state (0: no, 1: yes, 2: force)\n # css: set this to 1 inside a css file (for later use)\n # js: set this to 1 inside a js file (for later use)\n\n if REQUEST is None:\n REQUEST = self.REQUEST\n use_gzip = self.getGzip()\n if not self.getEnabled():\n use_gzip = 'never'\n\n force = 0\n if use_gzip == 'never':\n enable_compression = 0\n elif use_gzip == 'always':\n enable_compression = 1\n force = 1\n elif use_gzip == 'accept-encoding':\n # compress everything except css and js\n enable_compression = 1\n elif use_gzip == 'accept-encoding+user-agent':\n # gzip compatibility info courtesy of\n # http://httpd.apache.org/docs/2.2/mod/mod_deflate.html\n user_agent = REQUEST.get('HTTP_USER_AGENT', '')\n if user_agent.startswith('Mozilla/4'):\n # Netscape 4.x can't handle gzipped css and js\n enable_compression = (css==0 and js==0)\n # Netscape 4.0.6-4.0.8 has some gzip-related bugs\n if user_agent[len('Mozilla/4.')] in ('6','7','8'):\n enable_compression = 0\n # Some versions of MSIE pretend to be Netscape 4.x but are OK with gzipping\n if user_agent.find('MSIE'):\n enable_compression = 1\n\n return (enable_compression, force, REQUEST.get('HTTP_ACCEPT_ENCODING', '').find('gzip') != -1)","def gzinflate(val):\n return zlib.decompress(val)","def read_gzip_bytes(self):\n with gzip.open(self, 'rb') as f:\n return f.read()","def gzip_assets():\n run('cd %(repo_path)s; python gzip_assets.py' % env)","def test_gzip(handler,config):\r\n if not config.gzip:\r\n return False\r\n if not gzip_support:\r\n return False\r\n accept_encoding = handler.headers.get('accept-encoding','').split(',')\r\n accept_encoding = [ x.strip() for x in accept_encoding ]\r\n ctype = handler.resp_headers[\"Content-type\"]\r\n # if gzip is supported by the user agent,\r\n # and if the option gzip in the configuration file is set, \r\n # and content type is text/ or javascript, \r\n # set Content-Encoding to 'gzip' and return True\r\n if 'gzip' in accept_encoding and \\\r\n ctype and (ctype.startswith('text/') or \r\n ctype=='application/x-javascript'):\r\n return True\r\n return False","def test_gzip_file_no_extension(self):\n # Write the data to a file\n temp_file = tempfile.NamedTemporaryFile()\n with gzip.open(temp_file.name, 'wb') as out:\n for item in self.data:\n serialzed = json.dumps(item).encode()\n out.write(serialzed + b'\\n')\n\n # Load from file, ensure it is correct\n actual_data = []\n with JsonlReader(temp_file.name) as f:\n for item in f:\n actual_data.append(item)\n self.assertEqual(self.data, actual_data)","def unzip(imgname, put_lock=True, timeout=None):\n\n if put_lock:\n lock.acquire()\n\n if '.gz' in imgname:\n log.info ('gunzipping {}'.format(imgname))\n subprocess.run(['gunzip',imgname])\n imgname = imgname.replace('.gz','')\n\n elif '.fz' in imgname:\n log.info ('funpacking {}'.format(imgname))\n subprocess.run(['funpack','-D',imgname])\n imgname = imgname.replace('.fz','')\n\n if put_lock:\n lock.release()\n\n return imgname","def test_compress_response(self):\n r = GZipMiddleware(self.get_response)(self.req)\n self.assertEqual(self.decompress(r.content), self.compressible_string)\n self.assertEqual(r.get(\"Content-Encoding\"), \"gzip\")\n self.assertEqual(r.get(\"Content-Length\"), str(len(r.content)))","def unzip_file(\n file_path:str,\n unzip_dest: str,\n rgb_raw_zip: bool = False,\n keep_zip: bool = False\n) -> None:\n\n print('Unzipping: {}'.format(file_path))\n with zipfile.ZipFile(file_path, 'r') as z:\n for f in z.filelist:\n if rgb_raw_zip:\n if f.filename.endswith('.png'):\n date, drive, img_idx, _, img_name = f.filename.split('/')\n if img_idx in ['image_02', 'image_03']:\n f.filename = os.path.basename(f.filename)\n z.extract(f, '/'.join([unzip_dest, drive, 'image', img_idx]))\n else:\n z.extract(f, unzip_dest)\n \n if not keep_zip:\n os.remove(file_path)","def uncompress(compressed_file, dest_dir = None):\n\n\trouting_pairs = (\n\t\t(\".tar.gz\", _uncompress_targz),\n\t\t(\".tgz\", _uncompress_targz),\n\t\t(\".tar\", _uncompress_tar),\n\t\t(\".zip\", _uncompress_zip)\n\t)\n\n\tfound_handler = None\n\tfor suffix, handler in routing_pairs:\n\t\tif compressed_file.filename.endswith(suffix):\n\t\t\tfound_handler = handler\n\t\t\tbreak\n\telse:\n\t\traise ValueError(\"Compressed file does not have known format.\")\n\n\t# If we didn't get a directory to place the uncompressed files into, create\n\t# a temporary one.\n\tif dest_dir is None:\n\t\tdest_dir = tempfile.mkdtemp()\n\n\ttempfile_handle, tempfile_path = tempfile.mkstemp()\n\tos.close(tempfile_handle)\n\n\ttry:\n\t\tcompressed_file.save(tempfile_path)\n\n\t\tfound_handler(tempfile_path, dest_dir)\n\tfinally:\n\t\tos.remove(tempfile_path)\n\n\treturn dest_dir","def prepare_gz(self, filename, *args, **kwargs):\n\n return '/vsigzip/' + filename, args, kwargs","def test_args_gzip(testapp):\n\n timepoint = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\n stream = sitemap.process(\n testapp,\n [\n holocron.WebSiteItem(\n {\n \"destination\": pathlib.Path(\"1.html\"),\n \"updated\": timepoint,\n \"baseurl\": testapp.metadata[\"url\"],\n }\n )\n ],\n gzip=True,\n )\n\n assert isinstance(stream, collections.abc.Iterable)\n assert list(stream) == [\n holocron.WebSiteItem(\n {\n \"destination\": pathlib.Path(\"1.html\"),\n \"updated\": timepoint,\n \"baseurl\": testapp.metadata[\"url\"],\n }\n ),\n holocron.WebSiteItem(\n {\n \"source\": pathlib.Path(\"sitemap://sitemap.xml.gz\"),\n \"destination\": pathlib.Path(\"sitemap.xml.gz\"),\n \"content\": _pytest_xmlasdict(\n {\n \"urlset\": {\n \"@xmlns\": \"http://www.sitemaps.org/schemas/sitemap/0.9\",\n \"url\": {\n \"loc\": \"https://yoda.ua/1.html\",\n \"lastmod\": \"1970-01-01T00:00:00+00:00\",\n },\n }\n },\n ungzip=True,\n ),\n \"baseurl\": testapp.metadata[\"url\"],\n }\n ),\n ]","def unzipdir(path):\n filenames = fullpathlist(path)\n for filename in filenames:\n if filename.endswith(\"bz2\"):\n print \"doing\", filename\n os.system('bunzip2 \"%s\"' % filename)\n else:\n print \"skipping\", filename","def debianize( strFilename ):\n \n #~ data = gzip.GzipFile( strFilename ).read();\n #~ print data;\n #~ return;\n \n #~ data = gzip.open( strFilename ).read();\n #~ print data;\n #~ return; \n \n #~ uncompressedData = bz2.BZ2File(strFilename).read()\n #~ print str(uncompressedData)\n #~ return;\n \n #~ file = open( strFilename, 'rb' );\n #~ data = file.read();\n #~ file.close();\n #~ print debug.dumpHexa( data );\n \n #~ ar = tarfile.open(strFilename, 'r:*')\n #~ for item in ar:\n #~ print( str(item) );\n #~ print( \"%s:\" % item.name );\n #~ #print debug.dumpHexa(item.buf);\n #~ #print zlib.decompress(item.buf)\n #~ #print zlib.decompress(ar.extractfile(item).read())\n #~ data = ar.extractfile(item.name).read()\n #~ print data # works !\n #~ ar.close() \n #~ return;\n \n fileLists = [];\n file = open( strFilename );\n data = file.read();\n file.close();\n \n print( \"data len: %d\" % len( data ) );\n\n nDataCompressedOffset = 0; # 132\n\n # works fine on toto.gz\n #~ f = gzip.open(strFilename, 'rb')\n #~ file_content = f.read()\n #~ print file_content\n #~ f.close() \n \n #~ decompressor = bz2.BZ2Decompressor();\n #~ uncompressed = decompressor.decompress(data[nDataCompressedOffset:]);\n \n #~ uncompressed = zlib.decompress(data[nDataCompressedOffset:]);\n \n uncompressed = decompress( data );\n print( \"uncompressed: %s\" % str( uncompressed ) );","def parse_gzipped_directory(input_dir, start_date, end_date, infos, backup_stamps):\n try:\n file_names = sorted(os.listdir(input_dir)) \n for file_name in file_names:\n if file_name.endswith(\".manifest.gz\") or file_name.endswith(\".manifest\"):\n tmp = parse_file(input_dir + \"/\" + file_name, start_date, end_date, backup_stamps)\n backup_stamps[tmp[\"backup_label\"]] = tmp[\"backup_timestamp_stop_ts\"]\n if tmp:\n infos.append(tmp)\n except OSError as e:\n logging.error(\"Failed to open directory\", exc_info=True)\n exit(1)\n except:\n raise","def vcf_compress(fn):\n ret = cmd_exe(f\"vcf-sort {fn} | bgzip > {fn}.gz && tabix {fn}.gz\")","def parse(path):\n data = gzip.open(path, 'rb')\n for byte_line in data:\n yield eval(byte_line) # return generator instance to save memory","def cutgz(x):\n if x[-3:] == '.gz':\n return x[:-3]\n else:\n return x","def compress_to_tgz(in_path, tgz_fp):\n t = tarfile.open(name = tgz_fp, mode = 'w:gz')\n t.add(in_path, path.basename(in_path))\n t.close()","def _read_gzip_header(content):\n # adapted from gzip.py\n gz_flags = {\n 'FTEXT': 1,\n 'FHCRC': 2,\n 'FEXTRA': 4,\n 'FNAME': 8,\n 'FCOMMENT': 16\n }\n if len(content) < 10:\n raise IndexError, \"Header not complete yet\"\n magic = content[:2]\n if magic != '\\037\\213':\n raise IOError, \\\n u'Not a gzip header (magic is hex %s, should be 1f8b)' % \\\n magic.encode('hex-codec')\n method = ord( content[2:3] )\n if method != 8:\n raise IOError, 'Unknown compression method'\n flag = ord( content[3:4] )\n content_l = list(content[10:])\n if flag & gz_flags['FEXTRA']:\n # Read & discard the extra field, if present\n xlen = ord(content_l.pop())\n xlen = xlen + 256*ord(content_l.pop())\n content_l = content_l[xlen:]\n if flag & gz_flags['FNAME']:\n # Read and discard a null-terminated string \n # containing the filename\n while True:\n st1 = content_l.pop()\n if not content_l or st1 == '\\000':\n break\n if flag & gz_flags['FCOMMENT']:\n # Read and discard a null-terminated string containing a comment\n while True:\n st2 = content_l.pop()\n if not content_l or st2 == '\\000':\n break\n if flag & gz_flags['FHCRC']:\n content_l = content_l[2:] # Read & discard the 16-bit header CRC\n return \"\".join(content_l)","def __handle_compression(self, x):\n if self.__compress:\n return zlib.compress(x)\n return x"],"string":"[\n \"def gunzip_file(gzip_file, base_dir):\\n full_gzip_file = os.path.join(base_dir, gzip_file)\\n if not gzip_file.endswith(\\\".gz\\\"):\\n return gzip_file\\n gunzip_file = full_gzip_file.replace(\\\".gz\\\", \\\"\\\")\\n with gzip.open(full_gzip_file, 'rb') as f_in:\\n with open(gunzip_file, 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n # Now that file is extracted. Remove file\\n os.remove(full_gzip_file)\\n\\n return os.path.basename(gunzip_file)\",\n \"def gunzip(data):\\n return gzip.GzipFile(fileobj=StringIO(data)).read()\",\n \"def gunzip_file(gz_path, new_path):\\n print(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def gunzip_file(gz_path, new_path):\\n print(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def gunzip_file(gz_path, new_path):\\n logging.info(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def gunzip_file(gz_path, new_path):\\n print(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def gunzip(data):\\n f = GzipFile(fileobj=BytesIO(data))\\n output_list = []\\n chunk = b'.'\\n while chunk:\\n try:\\n chunk = read1(f, 8196)\\n output_list.append(chunk)\\n except (IOError, EOFError, struct.error):\\n if output_list or getattr(f, 'extrabuf', None):\\n try:\\n output_list.append(f.extrabuf[-f.extrasize:])\\n finally:\\n break\\n else:\\n raise\\n return b''.join(output_list)\",\n \"def ungz(filepath, compression='rb', deletesource=False):\\n\\n import gzip\\n\\n with gzip.open(filepath, compression) as f:\\n outF = open(filepath[:-3], 'wb')\\n outF.write(f.read())\\n f.close()\\n outF.close()\\n if deletesource:\\n try:\\n os.remove(filepath)\\n except:\\n raise Exception(\\\"Could not delete gz archive {0}.\\\".format(filepath))\\n\\n return filepath[:-3]\",\n \"def __unzip(self, data):\\n compressed = StringIO.StringIO(data)\\n gzipper = gzip.GzipFile(fileobj=compressed)\\n return gzipper.read()\",\n \"def ungzip(path):\\n unzip_path = \\\"\\\".join(path.split(\\\".\\\")[0]+\\\".fna\\\")\\n with gzip.open(path, 'rb') as f_in:\\n with open(unzip_path, 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n os.remove(path)\\n return unzip_path\",\n \"def clean_gzip():\\n this_dir = os.getcwd()\\n os.chdir(\\\"/data/COHERENT2/data/CrystalChar/raw\\\")\\n all_files = glob.glob(\\\"./**\\\", recursive=True)\\n for f in all_files:\\n if \\\".gz\\\" in f and \\\"tar\\\" not in f:\\n print(f)\\n sh(\\\"gunzip \\\" + f)\\n os.chdir(this_dir)\",\n \"def _gzip_file(filename):\\n gzip_filename = filename + '.gz'\\n with open(filename, 'rb') as f_in, gzip.open(gzip_filename, 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\",\n \"def extracted_file(fname: str):\\n new_fname = extract_gzip(fname)\\n gzipped = True\\n if new_fname is None:\\n new_fname = fname\\n gzipped = False\\n\\n try:\\n yield new_fname\\n finally:\\n if gzipped:\\n try:\\n bgzip_and_name(new_fname)\\n except Exception:\\n gzip_and_name(new_fname)\",\n \"def handle_file(self, path):\\n\\n if path:\\n if not matches_patterns(path, self.gzip_patterns):\\n return\\n\\n try:\\n original_file = self.open(path, mode=\\\"rb\\\")\\n except FileNotFoundError:\\n pass\\n else:\\n gzipped_path = \\\"{0}.gz\\\".format(path)\\n\\n if self.exists(gzipped_path):\\n self.delete(gzipped_path)\\n\\n gzipped_file = self._compress(original_file)\\n gzipped_path = self.save(gzipped_path, gzipped_file)\\n\\n return gzipped_path, gzipped_path, True\",\n \"def de_gzip(data):\\n cmps = StringIO.StringIO(data)\\n gzipper = gzip.GzipFile(fileobj=cmps)\\n return gzipper.read()\",\n \"def de_gzip(data):\\n cmps = StringIO.StringIO(data)\\n gzipper = gzip.GzipFile(fileobj=cmps)\\n return gzipper.read()\",\n \"def _unzip(self, data):\\r\\n with io.BytesIO(data) as buf:\\r\\n with gzip.GzipFile(fileobj=buf) as unzipped:\\r\\n return unzipped.read()\",\n \"def uncompress_gzip(location, target_dir):\\n\\n return uncompress(location, target_dir, decompressor=gzip.GzipFile)\",\n \"def _extract_gz(src, dst):\\n assert src.endswith(\\\".gz\\\"), \\\"{} is not a valid .gz file.\\\".format(src)\\n assert os.path.exists(src), \\\"{} does not exist.\\\".format(src)\\n\\n with gzip.open(src, \\\"rb\\\") as f_src:\\n # xxx.postfix.gz --> xxx.postfix\\n file_name = os.path.basename(src)[:-3]\\n with open(os.path.join(dst, file_name), \\\"wb\\\") as f_dst:\\n shutil.copyfileobj(f_src, f_dst)\",\n \"def decompress_gzip(in_str):\\n import gzip\\n # gzip can only handle file object therefore using StringIO\\n copmressed_stream = StringIO.StringIO(in_str)\\n gzipper = gzip.GzipFile(fileobj=copmressed_stream)\\n s = gzipper.read()\\n gzipper.close()\\n return s\",\n \"def decompress_gzip(in_str):\\n # gzip can only handle file object therefore using StringIO\\n copmressed_stream = StringIO.StringIO(in_str)\\n gzipper = gzip.GzipFile(fileobj=copmressed_stream)\\n s = gzipper.read()\\n gzipper.close()\\n return s\",\n \"def gzopen(f):\\n return gzip.open(f, 'rb') if f.endswith('.gz') else open(f, 'r')\",\n \"def read_gzipped(response):\\r\\n if response.info().get('Content-Encoding') == 'gzip':\\r\\n with io.BytesIO(response.read()) as buf:\\r\\n with gzip.GzipFile(fileobj=buf) as unzipped:\\r\\n data = unzipped.read()\\r\\n else:\\r\\n data = response.read()\\r\\n return data\",\n \"def skip_gzip_check(self):\\r\\n _read_eof = gzip._GzipReader._read_eof\\r\\n gzip.GzipFile._read_eof = lambda *args, **kwargs: None\\r\\n yield\\r\\n gzip.GzipFile._read_eof = _read_eof\",\n \"def _check_zip_file (filename, path_unzip, outfile) :\\n assert path_unzip is not None\\n file,ext = os.path.splitext (filename)\\n ext = ext.lower ()\\n if ext == \\\".gz\\\" :\\n \\n import gzip\\n \\n if outfile is None :\\n dest = filename.split (\\\"!\\\")\\n dest = dest [ len(dest)-1 ]\\n ext = os.path.splitext (dest) [1]\\n dest = dest.replace (ext, \\\".txt\\\")\\n path = os.path.split (filename)\\n path = \\\"/\\\".join (path [:len (path)-1])\\n dest = path + \\\"/\\\" + dest\\n else :\\n dest = outfile\\n \\n if not os.path.exists (dest) :\\n file = gzip.GzipFile (filename, \\\"r\\\")\\n if outfile is None :\\n dest = os.path.split (dest) [1]\\n dest = os.path.join (path_unzip, dest)\\n \\n if os.path.exists (dest) :\\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\\n if st2 > st1 : \\n fLOG (\\\"ungzipping file (already done)\\\", dest)\\n return dest\\n \\n fLOG (\\\"ungzipping file\\\", dest)\\n f = open (dest, \\\"w\\\")\\n data = file.read (2**27)\\n size = 0\\n while len (data) > 0 :\\n size += len (data)\\n fLOG (\\\"ungzipping \\\", size, \\\"bytes\\\")\\n if isinstance (data, bytes) : f.write (bytes.decode (data))\\n else : f.write (data)\\n data = file.read (2**27)\\n f.close ()\\n file.close ()\\n \\n return dest\\n \\n if ext == \\\".zip\\\" :\\n \\n import zipfile\\n try :\\n file = zipfile.ZipFile (filename, \\\"r\\\")\\n except Exception as e :\\n fLOG (\\\"problem with \\\", filename)\\n raise e\\n \\n if len (file.infolist()) != 1:\\n if outfile is not None :\\n raise PQHException (\\\"the archive contains %d files and not one as you expected by filling outfile\\\" % len (file.infolist()))\\n fLOG (\\\"unzip file (multiple) \\\", filename)\\n #message = \\\"\\\\n\\\".join ([ fi.filename for fi in file.infolist() ] )\\n #raise Exception.YstException(\\\"ColumnInfoSet.load_from_file: file %s contains no file or more than one file\\\\n\\\" + message)\\n folder = os.path.split (filename) [0]\\n todo = 0\\n _zip7_path = r\\\"c:\\\\Program Files\\\\7-Zip\\\"\\n zip7 = os.path.exists (_zip7_path)\\n wait = [ ]\\n for info in file.infolist () :\\n fileinside = info.filename\\n dest = os.path.join (folder, fileinside)\\n if not os.path.exists (dest) :\\n fol = os.path.split (dest) [0]\\n if not os.path.exists (fol) : os.makedirs (fol)\\n if os.path.exists (dest) :\\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\\n if st2 > st1 : \\n continue\\n \\n if not sys.platform.startswith(\\\"win\\\") or not zip7 :\\n data = file.read (fileinside)\\n dest = os.path.split (dest) [1]\\n dest = os.path.join (path_unzip, dest)\\n fLOG (\\\"unzipping file\\\", dest)\\n wait.append(dest)\\n f = open (dest, \\\"w\\\")\\n if isinstance (data, bytes) :\\n f.write (str (data))\\n else :\\n f.write (data)\\n f.close ()\\n else :\\n todo += 1\\n \\n if todo > 0 and zip7 :\\n dest = os.path.realpath (path_unzip)\\n cmd = '\\\"' + _zip7_path + '\\\\\\\\7z.exe\\\" e -y -o\\\"%s\\\" \\\"%s\\\"' % (dest, os.path.realpath (filename)) \\n out,err = run_cmd (cmd, wait = True)\\n if len (err) > 0 : raise PQHException (\\\"command {0} failed\\\\n{1}\\\".format(cmd,err))\\n if \\\"Error\\\" in out : raise PQHException (\\\"command {0} failed\\\\n{1}\\\".format(cmd,out))\\n else :\\n dest = path_unzip\\n \\n file.close ()\\n \\n ch = False\\n while not ch :\\n ch = True\\n for a in wait :\\n if not os.path.exists(a) : \\n ch = False\\n break\\n time.sleep(0.5)\\n \\n return dest\\n \\n else :\\n for info in file.infolist () :\\n fileinside = info.filename\\n \\n path = os.path.split (filename)\\n dest = outfile if outfile is not None else path [0] + \\\"/\\\" + fileinside\\n if not os.path.exists (dest) :\\n data = file.read (fileinside)\\n if outfile is None :\\n dest = os.path.split (dest) [1]\\n dest = os.path.join (path_unzip, dest)\\n \\n if os.path.exists (dest) :\\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\\n if st2 > st1 : \\n fLOG(\\\"unzipping one file (already done)\\\", dest)\\n return dest\\n \\n fLOG(\\\"unzipping one file\\\", dest)\\n f = open (dest, \\\"w\\\")\\n if isinstance (data, bytes) :\\n f.write (bytes.decode (data))\\n else :\\n f.write (data)\\n f.close ()\\n file.close ()\\n return dest\\n \\n return filename\",\n \"def is_gz_file(f):\\n with open(f, \\\"rb\\\") as fin:\\n return binascii.hexlify(fin.read(2)) == b\\\"1f8b\\\"\",\n \"def _gz(filename):\\n \\n with open(filename, 'rb') as f:\\n return binascii.hexlify(f.read(2)) == b'1f8b'\",\n \"def is_gzipped(response):\\n ctype = response.headers.get('Content-Type', b'').lower()\\n cenc = response.headers.get('Content-Encoding', b'').lower()\\n return (_is_gzipped(ctype) or\\n (_is_octetstream(ctype) and cenc in (b'gzip', b'x-gzip')))\",\n \"def gzipFile(aFile):\\n f_in = open(aFile, \\\"rb\\\")\\n f_out = gzip.open(aFile + \\\".gz\\\", \\\"wb\\\")\\n f_out.writelines(f_in)\\n f_out.close()\\n f_in.close()\\n os.remove(aFile)\",\n \"def is_gzipped(infile):\\n logger = logging.getLogger(__name__)\\n\\n magic_number = b'\\\\x1f\\\\x8b'\\n f = open(infile, 'rb')\\n with f:\\n try:\\n assert f.read(2) == magic_number\\n except AssertionError as e:\\n logger.info(f'{infile} is not gzipped')\\n return False\\n else:\\n logger.debug(f'{infile} is gzipped')\\n return True\",\n \"def unzip(filepath, cleanup=False):\\n\\t(uzfile, ext) = os.path.splitext(filepath)\\n\\tif ext != '.gz':\\n\\t\\treturn filepath\\n\\tif os.path.exists(uzfile):\\n\\t\\treturn uzfile\\n\\t\\n\\twith gzip.open(filepath, 'rb') as f_in:\\n\\t\\twith open(uzfile, 'w') as f_out:\\n\\t\\t\\tfor line in f_in:\\n\\t\\t\\t\\tf_out.write(line.decode())\\n\\t\\n\\tif cleanup and file_exists(uzfile):\\n\\t\\tos.remove(filepath)\\n\\treturn uzfile\",\n \"def gzip_compress(data):\\n s = BytesIO()\\n g = gzip.GzipFile(fileobj=s, mode='wb')\\n g.write(data)\\n g.close()\\n return s.getvalue()\",\n \"def open_gzip(fn):\\n magic = b'\\\\x1f\\\\x8b\\\\x08'\\n l = len(magic)\\n with open(fn, 'rb') as f:\\n file_start = f.read(l)\\n f.seek(0)\\n # check if the file is compressed\\n if file_start.startswith(magic):\\n return gzip.open(fn, 'rt')\\n # not compressed\\n return open(fn, 'rt')\",\n \"def is_gzip(fp):\\r\\n return open(fp, 'rb').read(2) == '\\\\x1f\\\\x8b'\",\n \"def compress(filename, remove=False):\\n import gzip\\n fin = open(filename, 'rb')\\n fout = gzip.open(filename+'.gz', 'wb')\\n fout.writelines(fin)\\n fout.close()\\n fin.close()\\n if remove == True:\\n os.remove(filename)\\n return\",\n \"def open_gz(filename, mode):\\n return gzip.open(filename, mode)\",\n \"def isgzip(filename):\\n magic_number = b'\\\\x1f\\\\x8b\\\\x08'\\n with open(filename, 'rb') as f:\\n file_start = f.read(len(magic_number))\\n\\n if magic_number == file_start:\\n return True\\n return False\",\n \"def unzip(zipped_file):\\n with gzip.open(zipped_file, 'rt', encoding='ISO-8859-1') as file:\\n file = file.read()\\n return file\",\n \"def do_gzip(fileobj):\\r\\n sio = cStringIO.StringIO()\\r\\n gzf = gzip.GzipFile(fileobj = sio, mode = \\\"wb\\\")\\r\\n while True:\\r\\n data = fileobj.read(buf_size)\\r\\n if not data:\\r\\n break\\r\\n gzf.write(data)\\r\\n gzf.close()\\r\\n return sio\",\n \"def get_gff(url, dir):\\n zip_path = ftp_download(url, dir)\\n unzip_path = ungzip(zip_path)\\n return unzip_path\",\n \"def _compress_string(content):\\n zbuf = StringIO()\\n zfile = GzipFile(mode='wb', compresslevel=6, fileobj=zbuf)\\n zfile.write(content)\\n zfile.close()\\n return zbuf.getvalue()\",\n \"def read_gzip_file_content(self, s3_path):\\n s3_object = self._get_s3_object(s3_path)\\n\\n bytestream = BytesIO(s3_object.get()['Body'].read())\\n\\n gzip_file = GzipFile(mode=\\\"rb\\\", fileobj=bytestream)\\n output = gzip_file.read().decode(\\\"utf-8\\\")\\n\\n return output\",\n \"def test_decompress_file():\\n gz_file = os.path.join(\\n tempfile.gettempdir(),\\n \\\"jade-unit-test-file.gz\\\",\\n )\\n with gzip.open(gz_file, \\\"wb\\\") as f:\\n f.write(b\\\"Hello World\\\")\\n assert os.path.exists(gz_file)\\n\\n new_file = decompress_file(gz_file)\\n assert os.path.exists(new_file)\\n with open(new_file, \\\"r\\\") as f:\\n data = f.read()\\n assert data == \\\"Hello World\\\"\\n\\n if os.path.exists(gz_file):\\n os.remove(gz_file)\\n\\n if os.path.exists(new_file):\\n os.remove(new_file)\",\n \"def _downloadWGS(WGSurl) :\\n gzipContent = urllib2.urlopen(WGSurl).read()\\n gzipFile = StringIO.StringIO(gzipContent)\\n o = gzip.GzipFile(fileobj = gzipFile)\\n output = None\\n try :\\n output = o.read()\\n except IOError as e:\\n print(e)\\n o.close()\\n return output\",\n \"def zipfile(filepath, cleanup=False):\\n\\tzfile = filepath+\\\".gz\\\"\\n\\twith open(filepath, 'rb') as f_in:\\n\\t\\twith gzip.open(zfile, 'wb') as f_out:\\n\\t\\t\\tf_out.writelines(f_in)\\t\\n\\t\\n\\tif cleanup and file_exists(zfile):\\n\\t\\tos.remove(filepath)\\n\\treturn zfile\",\n \"def decompress_stream(src, dst):\\n with gzip.GzipFile(fileobj=src, mode='rb') as gz:\\n for block in iterfile(gz):\\n dst.write(block)\",\n \"def decompress(filename):\\n print(\\\"\\\\n# start decompression of file: %s \\\\n#############################################\\\" % filename)\\n\\n # check if handed filename has the extension .gz\\n if \\\".gz\\\" in filename: # if file has the extension gz\\n\\n if os.path.exists(filename): # check if the file exists\\n\\n print(\\\"# filename enthält die endung gz : %s\\\" % filename)\\n\\n # if the file was found on the system split its string at the '.gz' position and use evereything before\\n filename_txt = filename.split(\\\".gz\\\")[0]\\n\\n print(\\\"# txt filename: \\\", filename_txt)\\n\\n # create an txt file with string before the '.gz' extension and decompress the content of the .gz file\\n with gzip.open(filename, 'rb') as decompressFile:\\n with open(filename_txt, 'wb') as receivingFile:\\n shutil.copyfileobj(decompressFile, receivingFile)\\n\\n # if the file was not found download it and decompress the content\\n else:\\n print(\\\"# ERROR - %s konnte nicht gefunden werden!!\\\" % filename)\\n\\n download(HOST, DIRECTORY, filename)\\n filename_txt = decompress(filename)\\n print(\\\"# return \\\", filename_txt)\\n return filename_txt\\n # if the handed filename has no '.gz' extension throw an Exception\\n else:\\n\\n raise Exception(\\\"# not a gzip file\\\")\",\n \"def save_to_gzip(data,fname):\\n with gzip.open(fname + '.gz', 'wb',compresslevel = 9) as f:\\n f.write(data.tobytes())\",\n \"def decompress_file(path, temp_dir='tmp'):\\n if path.endswith('.gz'):\\n logger.info('Decompressing {} to {}'.format(path, temp_dir))\\n return decompress_gzip(\\n path,\\n os.path.join(temp_dir,\\n os.path.splitext(os.path.basename(path))[0])\\n )\\n else:\\n return path\",\n \"def zip_file(file_path: str) -> str:\\n zip_file_path: str = file_path + \\\".gz\\\"\\n\\n print(f\\\"Compressing {file_path} into {zip_file_path}\\\")\\n timestamp=path.getmtime(file_path)\\n with open(file_path, \\\"rb\\\") as read_stream:\\n with gzip.open(zip_file_path, \\\"wb\\\") as write_stream:\\n shutil.copyfileobj(read_stream, write_stream)\\n os.utime(zip_file_path, (timestamp,timestamp) )\\n\\n return zip_file_path\",\n \"def is_zip(filepath):\\n\\treturn os.path.splitext(filepath)[1] == '.gz'\",\n \"def are_files_gzipped(raw_files):\\n files_are_gzipped = None\\n for file_name in raw_files:\\n if re.search(r\\\"\\\\.gz$\\\", file_name) is not None:\\n if files_are_gzipped is False:\\n raise Exception(\\n \\\"It seems one file is compressed and the \\\"\\n \\\"other is \\\"\\n \\\"not:\\\\n{}\\\".format(\\\"\\\\n\\\".join(raw_files))\\n )\\n files_are_gzipped = True\\n else:\\n if files_are_gzipped:\\n raise Exception(\\n \\\"It seems one file is compressed and the \\\"\\n \\\"other is \\\"\\n \\\"not:\\\\n{}\\\".format(\\\"\\\\n\\\".join(raw_files))\\n )\\n files_are_gzipped = False\\n return files_are_gzipped\",\n \"def _extract_all_gz_in_dir(directory):\\n for file in os.listdir(directory):\\n if file.endswith(\\\".gz\\\"):\\n gz_fname = os.path.join(directory, file)\\n _extract_gz(gz_fname, os.path.dirname(gz_fname))\\n os.remove(gz_fname)\",\n \"def test_compress_file_response(self):\\n with open(__file__, \\\"rb\\\") as file1:\\n\\n def get_response(req):\\n file_resp = FileResponse(file1)\\n file_resp[\\\"Content-Type\\\"] = \\\"text/html; charset=UTF-8\\\"\\n return file_resp\\n\\n r = GZipMiddleware(get_response)(self.req)\\n with open(__file__, \\\"rb\\\") as file2:\\n self.assertEqual(self.decompress(b\\\"\\\".join(r)), file2.read())\\n self.assertEqual(r.get(\\\"Content-Encoding\\\"), \\\"gzip\\\")\\n self.assertIsNot(r.file_to_stream, file1)\",\n \"def compress_file(path):\\n\\n process = Popen([\\\"xz\\\", \\\"--compress\\\", \\\"--force\\\", \\\"--stdout\\\", path], stdout=PIPE)\\n return process.communicate()[0]\",\n \"def compress_file(path):\\n\\n process = Popen([\\\"xz\\\", \\\"--compress\\\", \\\"--force\\\", \\\"--stdout\\\", path], stdout=PIPE)\\n return process.communicate()[0]\",\n \"def gzip_files(topDir, afni_file,localizerfile):\\n\\n print 'GZIPPING FILES...'\\n\\n command1 = \\\"gzip %s*BRIK\\\" % (topDir)\\n command2 = \\\"gzip %s*HEAD\\\" % (topDir)\\n command3 = \\\"gzip %s%s/pb00*\\\" % (topDir,afni_file)\\n command4 = \\\"gzip %s%s/errts*\\\" % (topDir,afni_file)\\n command5 = \\\"gzip %s%s/fitts*\\\" % (topDir,afni_file)\\n command6 = \\\"gzip %s%s/*al*\\\" % (topDir,afni_file)\\n command7 = \\\"gzip %s%s/*ns*\\\" % (topDir,afni_file)\\n command8 = \\\"gzip %s%s/all_runs*\\\" % (topDir,afni_file)\\n command9 = \\\"gzip %s%s/*mask*\\\" % (topDir,afni_file)\\n command10 = \\\"gzip %s*nii\\\" % (topDir)\\n command11 = \\\"gzip %s%s/pb01*\\\" % (topDir,afni_file)\\n command12 = \\\"gzip %s%s/pb03*\\\" % (topDir,afni_file)\\n command13 = \\\"gzip %s%s/pb02*\\\" % (topDir,afni_file)\\n\\n os.system(command1)\\n os.system(command2)\\n os.system(command3)\\n os.system(command4)\\n os.system(command5)\\n os.system(command6)\\n os.system(command7)\\n os.system(command8)\\n #os.system(command9)\\n os.system(command10)\\n os.system(command11)\\n try:\\n os.system(command12)\\n except:\\n print 'Could not gzip pb03 files'\\n\\n if localizerfile == 'facescene_loc':\\n os.system(command13)\",\n \"def _extract(self, file_path):\\n self._log.debug(\\\"Extracting file {!r}\\\".format(\\n os.path.basename(file_path)\\n ))\\n tar = tarfile.open(file_path, \\\"r:gz\\\")\\n tar.extractall(os.path.dirname(file_path))\\n tar.close()\",\n \"def gzip_worker(args):\\n\\tp = multiprocessing.current_process()\\n\\tprint('Start zipping %s: %s %s' %(args[1], p.name, p.pid))\\n\\tpath = args[0]\\n\\tfilename = args[1]\\n\\tassert os.path.splitext(filename)[1] == '.fastq', '%s is not a fastq file' %filename \\n\\t\\n\\tcall = 'gzip -c ' + os.path.join(path, filename) + ' > ' + os.path.join(path, filename) + '.gz'\\n\\tsubprocess.call(call, shell=True)\\n\\tprint('Completed zipping %s: %s %s' %(filename, p.name, p.pid))\",\n \"def tar_gz_compress(self, destination):\\n\\n if destination is not None and isinstance(destination, str):\\n with tarfile_open(destination, \\\"w:gz\\\") as tar:\\n tar.add(self.file)\",\n \"def is_gzip_result(self):\\n return self.__aceQLHttpApi.is_gzip_result()\",\n \"def unpack(file_path, extraction_path, remove):\\n print(file_path)\\n Archive(file_path).extractall(extraction_path, auto_create_dir=True)\\n # remove original compressed file???\\n if remove is True:\\n os.remove(file_path)\",\n \"def __init__(self, input_stream, level=9):\\n super(Gzip, self).__init__(input_stream)\\n\\n self._level = level\",\n \"def _compress_content(self, content):\\n zbuf = io.BytesIO()\\n zfile = gzip.GzipFile(mode=\\\"wb\\\", compresslevel=9, fileobj=zbuf)\\n\\n try:\\n zfile.write(content.read())\\n finally:\\n zfile.close()\\n\\n content.file = zbuf\\n content.seek(0)\\n\\n return content\",\n \"def gzipPage(page):\\n #if not hasattr(page,\\\"info\\\"):\\n # return(\\\"\\\")\\n data = object()\\n # Check if content encoding is gzip\\n if page.info().get('Content-Encoding') == 'gzip':\\n buf = StringIO(page.read())\\n f = gzip.GzipFile(fileobj=buf)\\n data = f.read()\\n else :\\n data = page.read()\\n return(data)\",\n \"def gzip_and_name(fname, gzip_file=True) -> str:\\n if gzip_file:\\n with open(fname, \\\"rb\\\") as f_in:\\n with gzip.open(fname + \\\".gz\\\", \\\"wb\\\") as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n os.unlink(fname)\\n fname += \\\".gz\\\"\\n return fname\",\n \"def open_gzipped(infile, mode='rt'):\\n import gzip\\n import bz2\\n if mode.startswith('r'):\\n tmode = 'rt'\\n bmode = 'r'\\n elif mode.startswith('w'):\\n tmode = 'wt'\\n bmode = 'w'\\n elif mode.startswith('a'):\\n tmode = 'at'\\n bmode = 'a'\\n if hasattr(infile, 'write'):\\n return infile\\n if isinstance(infile, str):\\n if infile.endswith('.gz'):\\n return gzip.open(infile, tmode)\\n if infile.endswith('.bz2'):\\n if hasattr(bz2, 'open'):\\n return bz2.open(infile, tmode)\\n else:\\n return bz2.BZ2File(infile, bmode)\\n return open(infile, tmode)\",\n \"def compress_file(map_, name, save_path):\\n size = os.path.getsize(save_path)\\n temp = subprocess.run([\\\"gzip\\\", \\\"-k\\\", save_path])\\n cr_size = os.path.getsize(save_path+\\\".gz\\\")\\n try:\\n map_[name] = cr_size / size\\n except Exception as e:\\n print(f\\\"File: {save_path}, Ori:{size}, Compr:{cr_size}\\\")\\n print(e)\\n raise ZeroDivisionError\\n temp = subprocess.run([\\\"rm\\\", save_path])\\n temp = subprocess.run([\\\"rm\\\", save_path+\\\".gz\\\"])\",\n \"def untgz(tgz_filename, out_dir):\\r\\n logging.info(\\\"Source: %s\\\" % tgz_filename)\\r\\n tgz = TgzHelper(tgz_filename, out_dir)\\r\\n tgz.extract()\",\n \"def _uncompress(fname, outdir, msg=msg):\\n import os\\n assert os.access(fname, os.R_OK), \\\"could not access [%s]\\\" % fname\\n fname = os.path.abspath(os.path.realpath(fname))\\n if not os.path.exists(outdir):\\n os.makedirs(outdir)\\n orig_dir = os.getcwd()\\n try:\\n os.chdir(outdir)\\n ext = os.path.splitext(fname)[1][1:] # drop the dot\\n if ext in ('gz', 'bz2'):\\n import tarfile\\n f = tarfile.open(fname, 'r:%s'%ext)\\n f.extractall()\\n else:\\n err = 'extension [%s] not handled (yet?)' % ext\\n msg.error(err)\\n raise ValueError(err)\\n finally:\\n os.chdir(orig_dir)\",\n \"def uncompress(path, dest=None, remove=True):\\n # assert path.endswith('.zip')\\n prefix, ext = split_if_compressed(path)\\n folder_name = os.path.basename(prefix)\\n file_is_zip = ext == '.zip'\\n root_of_folder = None\\n if ext == '.gz':\\n try:\\n with gzip.open(path, 'rb') as f_in, open(prefix, 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n except Exception as e:\\n remove_file(prefix)\\n remove_file(path)\\n raise e\\n else:\\n try:\\n with zipfile.ZipFile(path, \\\"r\\\") if ext == '.zip' else tarfile.open(path, 'r:*') as archive:\\n if not dest:\\n namelist = sorted(archive.namelist() if file_is_zip else archive.getnames())\\n if namelist[0] == '.':\\n namelist = namelist[1:]\\n namelist = [p[len('./'):] if p.startswith('./') else p for p in namelist]\\n if ext == '.tgz':\\n roots = set(x.split('/')[0] for x in namelist)\\n if len(roots) == 1:\\n root_of_folder = next(iter(roots))\\n else:\\n # only one file, root_of_folder = ''\\n root_of_folder = namelist[0].strip('/') if len(namelist) > 1 else ''\\n if all(f.split('/')[0] == root_of_folder for f in namelist[1:]) or not root_of_folder:\\n dest = os.path.dirname(path) # only one folder, unzip to the same dir\\n else:\\n root_of_folder = None\\n dest = prefix # assume zip contains more than one file or folder\\n print('Extracting {} to {}'.format(path, dest))\\n archive.extractall(dest)\\n if root_of_folder:\\n if root_of_folder != folder_name:\\n # move root to match folder name\\n os.rename(path_join(dest, root_of_folder), path_join(dest, folder_name))\\n dest = path_join(dest, folder_name)\\n elif len(namelist) == 1:\\n dest = path_join(dest, namelist[0])\\n except Exception as e:\\n remove_file(path)\\n if os.path.exists(prefix):\\n if os.path.isfile(prefix):\\n os.remove(prefix)\\n elif os.path.isdir(prefix):\\n shutil.rmtree(prefix)\\n raise e\\n if remove:\\n remove_file(path)\\n return dest\",\n \"def _read_gzip_header(input):\\n header = {\\n \\\"extra_field\\\": {}\\n }\\n\\n magic, flags, mtime = struct.unpack(\\\"<3sBIxx\\\", _read_exactly(input, 10))\\n if magic != compressor.GZIP_DEFLATE_ID:\\n raise IOError(\\\"Not a gzip-deflate file.\\\")\\n\\n if compressor.FRESERVED & flags:\\n raise IOError(\\\"Unknown reserved flags: %s\\\" % flags)\\n\\n if compressor.FEXTRA & flags:\\n xlen = _read16(input)\\n extra_field = input.read(xlen)\\n header[\\\"extra_field\\\"] = _split_subfields(extra_field)\\n\\n if compressor.FNAME & flags:\\n _skip_cstring(input)\\n\\n if compressor.FCOMMENT & flags:\\n _skip_cstring(input)\\n\\n if compressor.FHCRC & flags:\\n # Skips header CRC\\n input.read(2)\\n\\n return header\",\n \"def get_infile(filename):\\r\\n if filename.endswith(\\\".gz\\\"):\\r\\n fin = GzipFile(filename, \\\"rb\\\")\\r\\n else:\\r\\n fin = open(filename, \\\"U\\\")\\r\\n return fin\",\n \"def get_infile(filename):\\r\\n if filename.endswith(\\\".gz\\\"):\\r\\n fin = GzipFile(filename, \\\"rb\\\")\\r\\n else:\\r\\n fin = open(filename, \\\"U\\\")\\r\\n return fin\",\n \"def compress_stream(src, dst):\\n with gzip.GzipFile(fileobj=dst, mode='wb') as gz:\\n for block in iterfile(src):\\n gz.write(block)\",\n \"def gzip_lvl(self):\\r\\n return self._gzip_lvl\",\n \"def _determine_compression_safe_file_opener(self):\\n f = gzip.open(self.input_fname, \\\"r\\\")\\n try:\\n f.read(1)\\n self._compression_safe_file_opener = gzip.open\\n except IOError:\\n self._compression_safe_file_opener = open\\n finally:\\n f.close()\",\n \"def archive_file(filename, maxsize):#{{{\\n if not os.path.exists(filename):\\n print(filename, \\\"does not exist. ignore.\\\", file=sys.stderr)\\n return 1\\n\\n filesize = os.path.getsize(filename)\\n if filesize > maxsize:\\n cnt = 0\\n zipfile = \\\"\\\"\\n while 1:\\n cnt += 1\\n zipfile = \\\"%s.%d.gz\\\"%(filename, cnt)\\n if not os.path.exists(zipfile):\\n break\\n # write zip file\\n try:\\n f_in = open(filename, 'rb')\\n except IOError:\\n print(\\\"Failed to read %s\\\"%(filename), file=sys.stderr)\\n return 1\\n try:\\n f_out = gzip.open(zipfile, 'wb')\\n except IOError:\\n print(\\\"Failed to write to %s\\\"%(zipfile), file=sys.stderr)\\n return 1\\n\\n f_out.writelines(f_in)\\n f_out.close()\\n f_in.close()\\n print(\\\"%s is archived to %s\\\"%(filename, zipfile))\\n os.remove(filename)\\n return 0\",\n \"def default_unzip_s3_object_handler_function(response):\\n bytestream = BytesIO(response[\\\"Body\\\"].read())\\n raw_object = GzipFile(None, \\\"rb\\\", fileobj=bytestream).read()\\n try:\\n # decode if allowed\\n return_object = raw_object.decode(\\\"utf-8\\\")\\n except AttributeError:\\n return_object = raw_object\\n return json.loads(return_object)\",\n \"def isGzippable(self, css=0, js=0, REQUEST=None):\\n # force: force http compression even if the browser doesn't send an accept\\n # debug: return compression state (0: no, 1: yes, 2: force)\\n # css: set this to 1 inside a css file (for later use)\\n # js: set this to 1 inside a js file (for later use)\\n\\n if REQUEST is None:\\n REQUEST = self.REQUEST\\n use_gzip = self.getGzip()\\n if not self.getEnabled():\\n use_gzip = 'never'\\n\\n force = 0\\n if use_gzip == 'never':\\n enable_compression = 0\\n elif use_gzip == 'always':\\n enable_compression = 1\\n force = 1\\n elif use_gzip == 'accept-encoding':\\n # compress everything except css and js\\n enable_compression = 1\\n elif use_gzip == 'accept-encoding+user-agent':\\n # gzip compatibility info courtesy of\\n # http://httpd.apache.org/docs/2.2/mod/mod_deflate.html\\n user_agent = REQUEST.get('HTTP_USER_AGENT', '')\\n if user_agent.startswith('Mozilla/4'):\\n # Netscape 4.x can't handle gzipped css and js\\n enable_compression = (css==0 and js==0)\\n # Netscape 4.0.6-4.0.8 has some gzip-related bugs\\n if user_agent[len('Mozilla/4.')] in ('6','7','8'):\\n enable_compression = 0\\n # Some versions of MSIE pretend to be Netscape 4.x but are OK with gzipping\\n if user_agent.find('MSIE'):\\n enable_compression = 1\\n\\n return (enable_compression, force, REQUEST.get('HTTP_ACCEPT_ENCODING', '').find('gzip') != -1)\",\n \"def gzinflate(val):\\n return zlib.decompress(val)\",\n \"def read_gzip_bytes(self):\\n with gzip.open(self, 'rb') as f:\\n return f.read()\",\n \"def gzip_assets():\\n run('cd %(repo_path)s; python gzip_assets.py' % env)\",\n \"def test_gzip(handler,config):\\r\\n if not config.gzip:\\r\\n return False\\r\\n if not gzip_support:\\r\\n return False\\r\\n accept_encoding = handler.headers.get('accept-encoding','').split(',')\\r\\n accept_encoding = [ x.strip() for x in accept_encoding ]\\r\\n ctype = handler.resp_headers[\\\"Content-type\\\"]\\r\\n # if gzip is supported by the user agent,\\r\\n # and if the option gzip in the configuration file is set, \\r\\n # and content type is text/ or javascript, \\r\\n # set Content-Encoding to 'gzip' and return True\\r\\n if 'gzip' in accept_encoding and \\\\\\r\\n ctype and (ctype.startswith('text/') or \\r\\n ctype=='application/x-javascript'):\\r\\n return True\\r\\n return False\",\n \"def test_gzip_file_no_extension(self):\\n # Write the data to a file\\n temp_file = tempfile.NamedTemporaryFile()\\n with gzip.open(temp_file.name, 'wb') as out:\\n for item in self.data:\\n serialzed = json.dumps(item).encode()\\n out.write(serialzed + b'\\\\n')\\n\\n # Load from file, ensure it is correct\\n actual_data = []\\n with JsonlReader(temp_file.name) as f:\\n for item in f:\\n actual_data.append(item)\\n self.assertEqual(self.data, actual_data)\",\n \"def unzip(imgname, put_lock=True, timeout=None):\\n\\n if put_lock:\\n lock.acquire()\\n\\n if '.gz' in imgname:\\n log.info ('gunzipping {}'.format(imgname))\\n subprocess.run(['gunzip',imgname])\\n imgname = imgname.replace('.gz','')\\n\\n elif '.fz' in imgname:\\n log.info ('funpacking {}'.format(imgname))\\n subprocess.run(['funpack','-D',imgname])\\n imgname = imgname.replace('.fz','')\\n\\n if put_lock:\\n lock.release()\\n\\n return imgname\",\n \"def test_compress_response(self):\\n r = GZipMiddleware(self.get_response)(self.req)\\n self.assertEqual(self.decompress(r.content), self.compressible_string)\\n self.assertEqual(r.get(\\\"Content-Encoding\\\"), \\\"gzip\\\")\\n self.assertEqual(r.get(\\\"Content-Length\\\"), str(len(r.content)))\",\n \"def unzip_file(\\n file_path:str,\\n unzip_dest: str,\\n rgb_raw_zip: bool = False,\\n keep_zip: bool = False\\n) -> None:\\n\\n print('Unzipping: {}'.format(file_path))\\n with zipfile.ZipFile(file_path, 'r') as z:\\n for f in z.filelist:\\n if rgb_raw_zip:\\n if f.filename.endswith('.png'):\\n date, drive, img_idx, _, img_name = f.filename.split('/')\\n if img_idx in ['image_02', 'image_03']:\\n f.filename = os.path.basename(f.filename)\\n z.extract(f, '/'.join([unzip_dest, drive, 'image', img_idx]))\\n else:\\n z.extract(f, unzip_dest)\\n \\n if not keep_zip:\\n os.remove(file_path)\",\n \"def uncompress(compressed_file, dest_dir = None):\\n\\n\\trouting_pairs = (\\n\\t\\t(\\\".tar.gz\\\", _uncompress_targz),\\n\\t\\t(\\\".tgz\\\", _uncompress_targz),\\n\\t\\t(\\\".tar\\\", _uncompress_tar),\\n\\t\\t(\\\".zip\\\", _uncompress_zip)\\n\\t)\\n\\n\\tfound_handler = None\\n\\tfor suffix, handler in routing_pairs:\\n\\t\\tif compressed_file.filename.endswith(suffix):\\n\\t\\t\\tfound_handler = handler\\n\\t\\t\\tbreak\\n\\telse:\\n\\t\\traise ValueError(\\\"Compressed file does not have known format.\\\")\\n\\n\\t# If we didn't get a directory to place the uncompressed files into, create\\n\\t# a temporary one.\\n\\tif dest_dir is None:\\n\\t\\tdest_dir = tempfile.mkdtemp()\\n\\n\\ttempfile_handle, tempfile_path = tempfile.mkstemp()\\n\\tos.close(tempfile_handle)\\n\\n\\ttry:\\n\\t\\tcompressed_file.save(tempfile_path)\\n\\n\\t\\tfound_handler(tempfile_path, dest_dir)\\n\\tfinally:\\n\\t\\tos.remove(tempfile_path)\\n\\n\\treturn dest_dir\",\n \"def prepare_gz(self, filename, *args, **kwargs):\\n\\n return '/vsigzip/' + filename, args, kwargs\",\n \"def test_args_gzip(testapp):\\n\\n timepoint = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\\n stream = sitemap.process(\\n testapp,\\n [\\n holocron.WebSiteItem(\\n {\\n \\\"destination\\\": pathlib.Path(\\\"1.html\\\"),\\n \\\"updated\\\": timepoint,\\n \\\"baseurl\\\": testapp.metadata[\\\"url\\\"],\\n }\\n )\\n ],\\n gzip=True,\\n )\\n\\n assert isinstance(stream, collections.abc.Iterable)\\n assert list(stream) == [\\n holocron.WebSiteItem(\\n {\\n \\\"destination\\\": pathlib.Path(\\\"1.html\\\"),\\n \\\"updated\\\": timepoint,\\n \\\"baseurl\\\": testapp.metadata[\\\"url\\\"],\\n }\\n ),\\n holocron.WebSiteItem(\\n {\\n \\\"source\\\": pathlib.Path(\\\"sitemap://sitemap.xml.gz\\\"),\\n \\\"destination\\\": pathlib.Path(\\\"sitemap.xml.gz\\\"),\\n \\\"content\\\": _pytest_xmlasdict(\\n {\\n \\\"urlset\\\": {\\n \\\"@xmlns\\\": \\\"http://www.sitemaps.org/schemas/sitemap/0.9\\\",\\n \\\"url\\\": {\\n \\\"loc\\\": \\\"https://yoda.ua/1.html\\\",\\n \\\"lastmod\\\": \\\"1970-01-01T00:00:00+00:00\\\",\\n },\\n }\\n },\\n ungzip=True,\\n ),\\n \\\"baseurl\\\": testapp.metadata[\\\"url\\\"],\\n }\\n ),\\n ]\",\n \"def unzipdir(path):\\n filenames = fullpathlist(path)\\n for filename in filenames:\\n if filename.endswith(\\\"bz2\\\"):\\n print \\\"doing\\\", filename\\n os.system('bunzip2 \\\"%s\\\"' % filename)\\n else:\\n print \\\"skipping\\\", filename\",\n \"def debianize( strFilename ):\\n \\n #~ data = gzip.GzipFile( strFilename ).read();\\n #~ print data;\\n #~ return;\\n \\n #~ data = gzip.open( strFilename ).read();\\n #~ print data;\\n #~ return; \\n \\n #~ uncompressedData = bz2.BZ2File(strFilename).read()\\n #~ print str(uncompressedData)\\n #~ return;\\n \\n #~ file = open( strFilename, 'rb' );\\n #~ data = file.read();\\n #~ file.close();\\n #~ print debug.dumpHexa( data );\\n \\n #~ ar = tarfile.open(strFilename, 'r:*')\\n #~ for item in ar:\\n #~ print( str(item) );\\n #~ print( \\\"%s:\\\" % item.name );\\n #~ #print debug.dumpHexa(item.buf);\\n #~ #print zlib.decompress(item.buf)\\n #~ #print zlib.decompress(ar.extractfile(item).read())\\n #~ data = ar.extractfile(item.name).read()\\n #~ print data # works !\\n #~ ar.close() \\n #~ return;\\n \\n fileLists = [];\\n file = open( strFilename );\\n data = file.read();\\n file.close();\\n \\n print( \\\"data len: %d\\\" % len( data ) );\\n\\n nDataCompressedOffset = 0; # 132\\n\\n # works fine on toto.gz\\n #~ f = gzip.open(strFilename, 'rb')\\n #~ file_content = f.read()\\n #~ print file_content\\n #~ f.close() \\n \\n #~ decompressor = bz2.BZ2Decompressor();\\n #~ uncompressed = decompressor.decompress(data[nDataCompressedOffset:]);\\n \\n #~ uncompressed = zlib.decompress(data[nDataCompressedOffset:]);\\n \\n uncompressed = decompress( data );\\n print( \\\"uncompressed: %s\\\" % str( uncompressed ) );\",\n \"def parse_gzipped_directory(input_dir, start_date, end_date, infos, backup_stamps):\\n try:\\n file_names = sorted(os.listdir(input_dir)) \\n for file_name in file_names:\\n if file_name.endswith(\\\".manifest.gz\\\") or file_name.endswith(\\\".manifest\\\"):\\n tmp = parse_file(input_dir + \\\"/\\\" + file_name, start_date, end_date, backup_stamps)\\n backup_stamps[tmp[\\\"backup_label\\\"]] = tmp[\\\"backup_timestamp_stop_ts\\\"]\\n if tmp:\\n infos.append(tmp)\\n except OSError as e:\\n logging.error(\\\"Failed to open directory\\\", exc_info=True)\\n exit(1)\\n except:\\n raise\",\n \"def vcf_compress(fn):\\n ret = cmd_exe(f\\\"vcf-sort {fn} | bgzip > {fn}.gz && tabix {fn}.gz\\\")\",\n \"def parse(path):\\n data = gzip.open(path, 'rb')\\n for byte_line in data:\\n yield eval(byte_line) # return generator instance to save memory\",\n \"def cutgz(x):\\n if x[-3:] == '.gz':\\n return x[:-3]\\n else:\\n return x\",\n \"def compress_to_tgz(in_path, tgz_fp):\\n t = tarfile.open(name = tgz_fp, mode = 'w:gz')\\n t.add(in_path, path.basename(in_path))\\n t.close()\",\n \"def _read_gzip_header(content):\\n # adapted from gzip.py\\n gz_flags = {\\n 'FTEXT': 1,\\n 'FHCRC': 2,\\n 'FEXTRA': 4,\\n 'FNAME': 8,\\n 'FCOMMENT': 16\\n }\\n if len(content) < 10:\\n raise IndexError, \\\"Header not complete yet\\\"\\n magic = content[:2]\\n if magic != '\\\\037\\\\213':\\n raise IOError, \\\\\\n u'Not a gzip header (magic is hex %s, should be 1f8b)' % \\\\\\n magic.encode('hex-codec')\\n method = ord( content[2:3] )\\n if method != 8:\\n raise IOError, 'Unknown compression method'\\n flag = ord( content[3:4] )\\n content_l = list(content[10:])\\n if flag & gz_flags['FEXTRA']:\\n # Read & discard the extra field, if present\\n xlen = ord(content_l.pop())\\n xlen = xlen + 256*ord(content_l.pop())\\n content_l = content_l[xlen:]\\n if flag & gz_flags['FNAME']:\\n # Read and discard a null-terminated string \\n # containing the filename\\n while True:\\n st1 = content_l.pop()\\n if not content_l or st1 == '\\\\000':\\n break\\n if flag & gz_flags['FCOMMENT']:\\n # Read and discard a null-terminated string containing a comment\\n while True:\\n st2 = content_l.pop()\\n if not content_l or st2 == '\\\\000':\\n break\\n if flag & gz_flags['FHCRC']:\\n content_l = content_l[2:] # Read & discard the 16-bit header CRC\\n return \\\"\\\".join(content_l)\",\n \"def __handle_compression(self, x):\\n if self.__compress:\\n return zlib.compress(x)\\n return x\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76103014","0.758293","0.7453833","0.74080575","0.73874843","0.73601073","0.7083313","0.6650277","0.6621982","0.66076165","0.6582111","0.65322065","0.6479576","0.64636713","0.64612234","0.64612234","0.6430386","0.6367628","0.6275241","0.6251574","0.6234673","0.6152969","0.61408776","0.61379457","0.6132504","0.610348","0.61018366","0.60614026","0.6059398","0.6033975","0.601347","0.60016817","0.60015845","0.59668756","0.59111047","0.58988386","0.5894194","0.58933085","0.5819468","0.58022666","0.57590544","0.5678708","0.5677997","0.5670103","0.5669613","0.566435","0.56577253","0.5641681","0.56198806","0.5601753","0.5597462","0.5579389","0.55686116","0.5559318","0.5544597","0.5544597","0.5534074","0.5527361","0.5525738","0.55128217","0.5494672","0.54899764","0.5455059","0.5440851","0.543831","0.54305017","0.5426036","0.54254675","0.5417402","0.5416614","0.5404593","0.5392391","0.5382255","0.5382255","0.5371482","0.53659624","0.5353654","0.53453577","0.5339826","0.533798","0.53327376","0.5316548","0.5308121","0.53025603","0.52953756","0.5290517","0.5285686","0.52838194","0.5280911","0.5280292","0.52767694","0.5263493","0.5252895","0.52441955","0.5240679","0.5235174","0.52289826","0.52217495","0.5212175","0.5211377"],"string":"[\n \"0.76103014\",\n \"0.758293\",\n \"0.7453833\",\n \"0.74080575\",\n \"0.73874843\",\n \"0.73601073\",\n \"0.7083313\",\n \"0.6650277\",\n \"0.6621982\",\n \"0.66076165\",\n \"0.6582111\",\n \"0.65322065\",\n \"0.6479576\",\n \"0.64636713\",\n \"0.64612234\",\n \"0.64612234\",\n \"0.6430386\",\n \"0.6367628\",\n \"0.6275241\",\n \"0.6251574\",\n \"0.6234673\",\n \"0.6152969\",\n \"0.61408776\",\n \"0.61379457\",\n \"0.6132504\",\n \"0.610348\",\n \"0.61018366\",\n \"0.60614026\",\n \"0.6059398\",\n \"0.6033975\",\n \"0.601347\",\n \"0.60016817\",\n \"0.60015845\",\n \"0.59668756\",\n \"0.59111047\",\n \"0.58988386\",\n \"0.5894194\",\n \"0.58933085\",\n \"0.5819468\",\n \"0.58022666\",\n \"0.57590544\",\n \"0.5678708\",\n \"0.5677997\",\n \"0.5670103\",\n \"0.5669613\",\n \"0.566435\",\n \"0.56577253\",\n \"0.5641681\",\n \"0.56198806\",\n \"0.5601753\",\n \"0.5597462\",\n \"0.5579389\",\n \"0.55686116\",\n \"0.5559318\",\n \"0.5544597\",\n \"0.5544597\",\n \"0.5534074\",\n \"0.5527361\",\n \"0.5525738\",\n \"0.55128217\",\n \"0.5494672\",\n \"0.54899764\",\n \"0.5455059\",\n \"0.5440851\",\n \"0.543831\",\n \"0.54305017\",\n \"0.5426036\",\n \"0.54254675\",\n \"0.5417402\",\n \"0.5416614\",\n \"0.5404593\",\n \"0.5392391\",\n \"0.5382255\",\n \"0.5382255\",\n \"0.5371482\",\n \"0.53659624\",\n \"0.5353654\",\n \"0.53453577\",\n \"0.5339826\",\n \"0.533798\",\n \"0.53327376\",\n \"0.5316548\",\n \"0.5308121\",\n \"0.53025603\",\n \"0.52953756\",\n \"0.5290517\",\n \"0.5285686\",\n \"0.52838194\",\n \"0.5280911\",\n \"0.5280292\",\n \"0.52767694\",\n \"0.5263493\",\n \"0.5252895\",\n \"0.52441955\",\n \"0.5240679\",\n \"0.5235174\",\n \"0.52289826\",\n \"0.52217495\",\n \"0.5212175\",\n \"0.5211377\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6552791"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":83186,"cells":{"query":{"kind":"string","value":"Unzips the file if zipped."},"document":{"kind":"string","value":"def extract_zip(\n fname: str, outfile: Optional[str] = None, concat: bool = False\n) -> Union[str, None]:\n if not outfile:\n outfile = fname[:-4]\n\n with ZipFile(fname, \"r\") as fzip, TemporaryDirectory() as tmpdir:\n fzip.extractall(path=tmpdir)\n fnames = glob(f\"{tmpdir}/*\")\n\n if len(fnames) > 1 and not concat:\n raise ValueError(\n \"Downloaded zip file contains multiple files, but concat is not specified!\"\n )\n\n # Concatenate (also works with one file)\n with open(outfile, \"w\") as out:\n for infile in fnames:\n for line in open(infile):\n out.write(line)\n\n os.unlink(fname)\n\n return outfile"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def unzip(zip_path, output_file, data_folder):\n\n print('Unzipping file: {}'.format(zip_path))\n pyunpack.Archive(zip_path).extractall(data_folder)\n\n # Checks if unzip was successful\n if not os.path.exists(output_file):\n raise ValueError(\n 'Error in unzipping process! {} not found.'.format(output_file))","def unzip_file(zip_file: str) -> None:\n destination = tempfile.mkdtemp(prefix='gaelo_pross_unzip_')\n with ZipFile(zip_file) as my_zip:\n for member in my_zip.namelist():\n filename = os.path.basename(member)\n # skip directories\n if not filename:\n continue\n # copy file (taken from zipfile's extract)\n source = my_zip.open(member)\n target = open(os.path.join(destination, filename), \"wb\")\n with source, target:\n shutil.copyfileobj(source, target)\n # return destination","def unzip_data():\n zip_ref = zipfile.ZipFile(data_zip, 'r')\n zip_ref.extractall('')\n zip_ref.close()","def unzip_file(data_zip, path_unzip):\r\n with zipfile.ZipFile(data_zip, \"r\") as zip_temp:\r\n zip_temp.extractall(path_unzip)","def unzip(zip_path, cleanup=False):\n zfile = zipfile.ZipFile(zip_path, 'r')\n zfile.extractall(os.path.dirname(zip_path))\n zfile.close()\n if cleanup:\n os.remove(zip_path)","def unzip(zipped_file):\n with gzip.open(zipped_file, 'rt', encoding='ISO-8859-1') as file:\n file = file.read()\n return file","def _unzip_file(zip_file_path: str, unzip_dir: str = \"\") -> None:\n if not unzip_dir:\n unzip_dir = os.path.dirname(zip_file_path)\n op_desc = f\"Extracting: {os.path.basename(zip_file_path)}\"\n try:\n with ZipFile(file=zip_file_path) as zip_file:\n for member_name in tqdm(zip_file.namelist(), desc=op_desc):\n file_name = os.path.basename(member_name)\n if not file_name:\n continue\n target_path = os.path.join(unzip_dir, file_name)\n target_path = open(target_path, \"wb\")\n source_file = zip_file.open(member_name)\n with source_file, target_path:\n shutil.copyfileobj(source_file, target_path)\n os.remove(zip_file_path)\n except Exception as zip_error:\n zip_file_str = os.path.basename(zip_file_path)\n zip_file_str = os.path.splitext(zip_file_str)[0]\n for file_name in os.listdir(unzip_dir):\n if zip_file_str in file_name:\n os.remove(os.path.join(unzip_dir, file_name))\n raise zip_error","def unzip_file(zipfile_path, target_dir, touchfile_path):\r\n with zipfile.ZipFile(zipfile_path, 'r') as zip_ref:\r\n zip_ref.extractall(target_dir)\r\n\r\n with open(touchfile_path, 'w') as touchfile:\r\n touchfile.write(f'unzipped {zipfile_path}')","def unpackage():\n\n zipfileLoc = hou.ui.selectFile(title=\"please select a zipFile created by the package function\", pattern=\"*.zip\")\n if not zipfileLoc: \n \n return\n \n file_ = zipfile.ZipFile(hou.expandString(zipfileLoc), \"r\")\n\n isOke = False\n \n for name in file_.namelist():\n \n if name.endswith(\".hip\") or name.endswith(\".hipnc\"):\n \n isOke = True\n break\n \n if not isOke: \n \n return\n \n unpackLoc = hou.expandString(hou.ui.selectFile(title=\"please select a directory you wish to use to unpack the files to.\"))\n \n if not unpackLoc or not os.path.isdir(unpackLoc): \n \n return\n \n unzip(file_, unpackLoc)\n unpackageDir = os.path.dirname(file_.namelist()[0])\n otlsfiles = glob.glob(os.path.join(unpackLoc, unpackageDir, \"otls\", \"*\"))\n hipfile = glob.glob(os.path.join(unpackLoc, unpackageDir, \"*.hip*\"))\n \n if len(hipfile) != 1: \n \n return\n \n hou.hipFile.load(hipfile[0])\n \n for otl in otlsfiles:\n\n hou.hda.installFile(otl)","def unzip(self):\n global pointer\n global error_flag\n global totalFiles\n while pointer < len(self.files) and ((self.t and not error_flag) or not self.t):\n # Se o modo nao for t pode avancar sem restricoes\n # Se o modo e' t e a error_flag nao for false entao pode avancar\n self.sem.acquire()\n iterator = pointer\n pointer += 1\n self.sem.release()\n if iterator < len(self.files): # Iterator e' o ficheiro que deve ser utilizado pela thread\n File = self.files[iterator]\n if os.path.isfile(File): # Ver se o ficheiro existe\n with ZipFile(File, 'r') as zipfile:\n zipfile.extractall('.') # Unzip\n self.totalFilesSem.acquire()\n totalFiles += 1\n self.totalFilesSem.release()\n else:\n print \"O ficheiro\", File, \"não existe.\" # Se nao exister, avisa o utilizador\n error_flag = True # Atualiza a sua propria flag","def unzip_single_file(zip_file_name, output_file_name):\n if not os.path.isfile(output_file_name):\n with open(output_file_name, 'wb') as out_file:\n with zipfile.ZipFile(zip_file_name) as zipped:\n for info in zipped.infolist():\n if output_file_name in info.filename:\n with zipped.open(info) as requested_file:\n out_file.write(requested_file.read())\n return","def unzip(input_filename, extract_dir):\n if not zipfile.is_zipfile(input_filename):\n raise ValueError(\"%s is not a zip file\" % (input_filename))\n zip_ds = zipfile.ZipFile(input_filename)\n zip_ds.extractall(path=extract_dir)\n zip_ds.close()","def unzip(input_file, output_file):\n output_file = validator.validate_unzip(input_file, output_file)\n process = subprocess.Popen([PBWT_BIN, 'unzip', input_file, output_file],\n stdout=subprocess.PIPE)\n process_results(str(process.communicate()[0]))","def _check_zip_file (filename, path_unzip, outfile) :\n assert path_unzip is not None\n file,ext = os.path.splitext (filename)\n ext = ext.lower ()\n if ext == \".gz\" :\n \n import gzip\n \n if outfile is None :\n dest = filename.split (\"!\")\n dest = dest [ len(dest)-1 ]\n ext = os.path.splitext (dest) [1]\n dest = dest.replace (ext, \".txt\")\n path = os.path.split (filename)\n path = \"/\".join (path [:len (path)-1])\n dest = path + \"/\" + dest\n else :\n dest = outfile\n \n if not os.path.exists (dest) :\n file = gzip.GzipFile (filename, \"r\")\n if outfile is None :\n dest = os.path.split (dest) [1]\n dest = os.path.join (path_unzip, dest)\n \n if os.path.exists (dest) :\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\n if st2 > st1 : \n fLOG (\"ungzipping file (already done)\", dest)\n return dest\n \n fLOG (\"ungzipping file\", dest)\n f = open (dest, \"w\")\n data = file.read (2**27)\n size = 0\n while len (data) > 0 :\n size += len (data)\n fLOG (\"ungzipping \", size, \"bytes\")\n if isinstance (data, bytes) : f.write (bytes.decode (data))\n else : f.write (data)\n data = file.read (2**27)\n f.close ()\n file.close ()\n \n return dest\n \n if ext == \".zip\" :\n \n import zipfile\n try :\n file = zipfile.ZipFile (filename, \"r\")\n except Exception as e :\n fLOG (\"problem with \", filename)\n raise e\n \n if len (file.infolist()) != 1:\n if outfile is not None :\n raise PQHException (\"the archive contains %d files and not one as you expected by filling outfile\" % len (file.infolist()))\n fLOG (\"unzip file (multiple) \", filename)\n #message = \"\\n\".join ([ fi.filename for fi in file.infolist() ] )\n #raise Exception.YstException(\"ColumnInfoSet.load_from_file: file %s contains no file or more than one file\\n\" + message)\n folder = os.path.split (filename) [0]\n todo = 0\n _zip7_path = r\"c:\\Program Files\\7-Zip\"\n zip7 = os.path.exists (_zip7_path)\n wait = [ ]\n for info in file.infolist () :\n fileinside = info.filename\n dest = os.path.join (folder, fileinside)\n if not os.path.exists (dest) :\n fol = os.path.split (dest) [0]\n if not os.path.exists (fol) : os.makedirs (fol)\n if os.path.exists (dest) :\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\n if st2 > st1 : \n continue\n \n if not sys.platform.startswith(\"win\") or not zip7 :\n data = file.read (fileinside)\n dest = os.path.split (dest) [1]\n dest = os.path.join (path_unzip, dest)\n fLOG (\"unzipping file\", dest)\n wait.append(dest)\n f = open (dest, \"w\")\n if isinstance (data, bytes) :\n f.write (str (data))\n else :\n f.write (data)\n f.close ()\n else :\n todo += 1\n \n if todo > 0 and zip7 :\n dest = os.path.realpath (path_unzip)\n cmd = '\"' + _zip7_path + '\\\\7z.exe\" e -y -o\"%s\" \"%s\"' % (dest, os.path.realpath (filename)) \n out,err = run_cmd (cmd, wait = True)\n if len (err) > 0 : raise PQHException (\"command {0} failed\\n{1}\".format(cmd,err))\n if \"Error\" in out : raise PQHException (\"command {0} failed\\n{1}\".format(cmd,out))\n else :\n dest = path_unzip\n \n file.close ()\n \n ch = False\n while not ch :\n ch = True\n for a in wait :\n if not os.path.exists(a) : \n ch = False\n break\n time.sleep(0.5)\n \n return dest\n \n else :\n for info in file.infolist () :\n fileinside = info.filename\n \n path = os.path.split (filename)\n dest = outfile if outfile is not None else path [0] + \"/\" + fileinside\n if not os.path.exists (dest) :\n data = file.read (fileinside)\n if outfile is None :\n dest = os.path.split (dest) [1]\n dest = os.path.join (path_unzip, dest)\n \n if os.path.exists (dest) :\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\n if st2 > st1 : \n fLOG(\"unzipping one file (already done)\", dest)\n return dest\n \n fLOG(\"unzipping one file\", dest)\n f = open (dest, \"w\")\n if isinstance (data, bytes) :\n f.write (bytes.decode (data))\n else :\n f.write (data)\n f.close ()\n file.close ()\n return dest\n \n return filename","def unzip(zip_file, dest_folder):\n zip = zipfile.ZipFile(zip_file, 'r')\n if os.path.exists(dest_folder):\n pass\n else:\n os.makedirs(dest_folder)\n if dest_folder[-1] != '/':\n dest_folder += '/'\n for filename in zip.namelist():\n # --- Folder?\n if filename.endswith('/'):\n if os.path.exists(join(abspath(dest_folder),filename)):\n pass\n else:\n os.makedirs(join(abspath(dest_folder),filename))\n else:\n try:\n os.makedirs(normpath((abspath(dest_folder)+'/'+dirname(filename))))\n try:\n bytes = zip.read(filename)\n #print 'Unzipping file:', filename, 'with', len(bytes), 'bytes..'\n file((join(dest_folder,filename)), 'wb').write(zip.read(filename))\n accesstime = time.time()\n timeTuple=(int(zip.getinfo(filename).date_time[0]),\\\n int(zip.getinfo(filename).date_time[1]),\\\n int(zip.getinfo(filename).date_time[2]),\\\n int(zip.getinfo(filename).date_time[3]) ,\\\n int(zip.getinfo(filename).date_time[4]),\\\n int(zip.getinfo(filename).date_time[5]),\\\n int(0),int(0),int(0))\n modifiedtime = mktime(timeTuple)\n utime((join(dest_folder,filename)), (accesstime,modifiedtime))\n except IOError:\n pass\n except:\n if os.path.exists(normpath((abspath(dest_folder)+'/'+dirname(filename)))):\n try:\n bytes = zip.read(filename)\n #print 'Unzipping file:', filename, 'with', len(bytes), 'bytes..'\n file((join(dest_folder,filename)), 'wb').write(zip.read(filename))\n accesstime = time.time()\n timeTuple=(int(zip.getinfo(filename).date_time[0]),\\\n int(zip.getinfo(filename).date_time[1]),\\\n int(zip.getinfo(filename).date_time[2]),\\\n int(zip.getinfo(filename).date_time[3]) ,\\\n int(zip.getinfo(filename).date_time[4]),\\\n int(zip.getinfo(filename).date_time[5]),\\\n int(0),int(0),int(0))\n modifiedtime = mktime(timeTuple)\n utime((join(dest_folder,filename)), (accesstime,modifiedtime))\n except IOError:\n pass\n else:\n os.makedirs(normpath((abspath(dest_folder)+'/'+dirname(filename))))\n zip.close","def unzip_data(zip_f,data_folder_path): \n\n with zipfile.ZipFile(zip_f,\"r\") as zip_ref:\n zip_ref.extractall(data_folder_path)","def _unzip(filename, branch=None):\n try:\n file = zipfile.ZipFile(filename)\n basename = os.path.dirname(filename)\n basename = basename.replace(\".zip\", \"\")\n file.extractall(path=basename)\n return basename, filename\n except Exception as e:\n six.print_(e)","def unzip(filepath, cleanup=False):\n\t(uzfile, ext) = os.path.splitext(filepath)\n\tif ext != '.gz':\n\t\treturn filepath\n\tif os.path.exists(uzfile):\n\t\treturn uzfile\n\t\n\twith gzip.open(filepath, 'rb') as f_in:\n\t\twith open(uzfile, 'w') as f_out:\n\t\t\tfor line in f_in:\n\t\t\t\tf_out.write(line.decode())\n\t\n\tif cleanup and file_exists(uzfile):\n\t\tos.remove(filepath)\n\treturn uzfile","def unzip(f, targetdir):\n import zipfile\n\n with zipfile.ZipFile(f, \"r\") as zip_ref:\n zip_ref.extractall(targetdir)","def _unzip(self, data):\r\n with io.BytesIO(data) as buf:\r\n with gzip.GzipFile(fileobj=buf) as unzipped:\r\n return unzipped.read()","def _unpack_archive(self):\n with zipfile.ZipFile(self._archive_full_path, 'r') as zip_ref:\n zip_ref.extractall(self._storage_path)\n\n _logger.debug('Archive has been unpacked.')","def unzip(zipped_file, output_directory=None,\n prefix=\"apsharvest_unzip_\", suffix=\"\"):\n if not output_directory:\n # We create a temporary directory to extract our stuff in\n try:\n output_directory = mkdtemp(suffix=suffix,\n prefix=prefix,\n dir=os.path.join(CFG_TMPSHAREDDIR, 'apsharvest'))\n except Exception, e:\n try:\n os.removedirs(output_directory)\n except TypeError:\n pass\n raise e\n return _do_unzip(zipped_file, output_directory)","def _unzip_files(self) -> None:\n for file in self.input_path.iterdir():\n if is_zipfile(file):\n with ZipFile(file, mode=\"r\") as archive:\n archive.extractall(path=self.temp_path)","def test_unzip_file(self):\n\n # Path to the compressed file\n zipped_file = os.path.join(self.xmlfilepath, \"DLTINS_20210117_01of01.zip\")\n # Test for correct data\n # NOTE : For this test case to pass the source xml zipped file\n # should be present in the download path\n self.assertTrue(unzip_file(zipped_file, self.xmlfilepath))\n\n # Test for wrong target path\n self.assertFalse(unzip_file(zipped_file, r\"D:\\kqcA CK j \"))\n\n # Test for incorrect compressed file\n self.assertFalse(unzip_file(\"D:\\somerandomfile\", self.xmlfilepath))","def unpack(input_filename, extract_dir):\n if not is_archive_file(input_filename):\n raise AttributeError(\"Input_filename must be an archive (ex: .tar.gz, .zip)\")\n if zipfile.is_zipfile(input_filename):\n unzip(input_filename, extract_dir)\n else:\n untar(input_filename, extract_dir)","def unzip(zfile, md=False):\n\tbasedir = ''\n\tcount = -1\n\tif md:\n\t\tbasedir = prepareBaseDir(zfile)\n\t\n\tzfile = zipfile.ZipFile(zfile, 'r')\n\tfor name in zfile.namelist():\n\t\tcount+=1\n\t\tuname = name.decode('gbk')\n\t\tif uname.endswith('.DS_Store'):\n\t\t\tcontinue\n\t\t\n\t\t#prepare directory\n\t\tdirs = os.path.dirname(uname)\n\t\tif basedir:\n\t\t\tdirs = os.path.join(basedir, dirs)\n\t\tprint 'Extracting: ' + uname\n\t\tif dirs and not os.path.exists(dirs):\n\t\t\tprint 'Prepare directories: ', dirs\n\t\t\tos.makedirs(dirs)\n\t\tif (count == 0):\n\t\t\thomeDir = uname[:-1]\n\t\t#ready to unzip file\n\t\tdata = zfile.read(name)\n\t\tif basedir:\n\t\t\tuname = os.path.join(basedir, uname)\n\t\tif not os.path.exists(uname):\n\t\t\tfo = open(uname, 'w')\n\t\t\tfo.write(data)\n\t\t\tfo.close()\n\tzfile.close()\n\treturn homeDir","def extract_and_clean(zipper, zip_path, filename):\n zipper.extract(zip_path)\n if \"/\" in zip_path :\n os.rename(zip_path, filename)\n shutil.rmtree(zip_path.split('/')[0])","def unzip(path):\n zip_ref = zipfile.ZipFile(path, 'r')\n new_path = path[:-3]\n zip_ref.extractall(new_path)\n zip_ref.close()\n return new_path","def unzip(self):\n try:\n zipped_files = [f for f in os.listdir('.') if os.path.isfile(f)]\n for file in zipped_files:\n unzipped = self.unzip_file(file)\n if not unzipped:\n logging.error('Failed to unzip {}'.format(file))\n return False\n all_files = [f for f in os.listdir('.') if os.path.isfile(f)]\n for f in all_files:\n os.chmod(f, self.file_mode)\n except Exception as e:\n logging.error('Failed to unzip and change file mode {}'\n .format(e))\n return False\n return True","def unzip_file(path_to_zip_file, directory_to_extract_to):\n \n with zipfile.ZipFile(path_to_zip_file, 'r') as zip_ref:\n zip_ref.extractall(directory_to_extract_to)\n\n return","def unzip_file(self, filename, location, flatten=True):\n if not os.path.exists(location):\n os.makedirs(location)\n zipfp = open(filename, 'rb')\n try:\n zip = zipfile.ZipFile(zipfp)\n leading = has_leading_dir(zip.namelist()) and flatten\n for name in zip.namelist():\n data = zip.read(name)\n fn = name\n if leading:\n fn = split_leading_dir(name)[1]\n fn = os.path.join(location, fn)\n dir = os.path.dirname(fn)\n if not os.path.exists(dir):\n os.makedirs(dir)\n if fn.endswith('/') or fn.endswith('\\\\'):\n # A directory\n if not os.path.exists(fn):\n os.makedirs(fn)\n else:\n fp = open(fn, 'wb')\n try:\n fp.write(data)\n finally:\n fp.close()\n finally:\n zipfp.close()","def file_unzipper(directory):\n debug.log(\"Unzipping directory (%s)...\"%directory)\n #FINDING AND UNZIPPING ZIPPED FILES\n for root, dirs, files in os.walk(directory, topdown=False):\n if root != \"\":\n orig_dir = os.getcwd()\n os.chdir(directory)\n Popen('gunzip -q -f *.gz > /dev/null 2>&1', shell=True).wait()\n Popen('unzip -qq -o \"*.zip\" > /dev/null 2>&1', shell=True).wait()\n Popen('rm -f *.zip > /dev/null 2>&1', shell=True).wait()\n os.chdir(orig_dir)","def extract_file(self):\n# path_destination = os.path.join(\n# self.root, self.resources.replace(\".zip\", \"\"))\n# os.makedirs(path_destination, exist_ok=True)\n shutil.unpack_archive(os.path.join(\n self.root, self.resources), self.root)\n os.remove(os.path.join(self.root, self.resources))","def unzip(path, filename_as_folder=False):\n for filename in os.listdir(path):\n if filename.endswith(\".zip\"):\n name = os.path.splitext(os.path.basename(filename))[0]\n if not os.path.isdir(name):\n try:\n file = os.path.join(path, filename)\n zip = ZipFile(file)\n if filename_as_folder:\n directory = os.path.join(path, name)\n os.mkdir(directory)\n print(\"Unzipping {} to {}\".format(filename, directory))\n zip.extractall(directory)\n else:\n print(\"Unzipping {} to {}\".format(filename, path))\n zip.extractall(path)\n except BadZipfile:\n print(\"BAD ZIP: \" + filename)\n try:\n os.remove(file)\n except OSError as e: # this would be \"except OSError, e:\" before Python 2.6\n if e.errno != errno.ENOENT: # errno.ENOENT = no such file or directory\n raise # re-raise exception if a different error occured","def _unzip(self, data: bytes) -> str:\n\n self.log.info(\"Unzipping facilities...\")\n z = zipfile.ZipFile(io.BytesIO(data))\n return z.read('facility.dat').decode('utf-8')","def unzip_data(folder, zip_file_basename):\n # path\n filename = os.path.join(folder, zip_file_basename + '.zip')\n new_folder = os.path.join(os.path.dirname(__file__), 'data')\n if not os.path.isdir(new_folder):\n os.mkdir(new_folder)\n # unzip\n if os.path.isfile(os.path.join(new_folder, zip_file_basename + '.csv')):\n return 0\n else:\n zip_file = zipfile.ZipFile(filename, 'r')\n zip_file.extractall(new_folder)\n zip_file.close()\n basename = os.path.join(new_folder, zip_file_basename)\n os.rename(basename + '.txt', basename + '.csv')\n return 1","def _uncompress(fname, outdir, msg=msg):\n import os\n assert os.access(fname, os.R_OK), \"could not access [%s]\" % fname\n fname = os.path.abspath(os.path.realpath(fname))\n if not os.path.exists(outdir):\n os.makedirs(outdir)\n orig_dir = os.getcwd()\n try:\n os.chdir(outdir)\n ext = os.path.splitext(fname)[1][1:] # drop the dot\n if ext in ('gz', 'bz2'):\n import tarfile\n f = tarfile.open(fname, 'r:%s'%ext)\n f.extractall()\n else:\n err = 'extension [%s] not handled (yet?)' % ext\n msg.error(err)\n raise ValueError(err)\n finally:\n os.chdir(orig_dir)","def finalize_zip(zip, filename):\n zip.close()\n with open(filename, 'wb') as file:\n file.write(zipbytes.getvalue())","def unzip(local_zip: str, extract_dir: str, pwd: str = None):\n def get_zipinfo_datetime(zipmember: zipfile.ZipInfo) -> datetime:\n zt = zipmember.date_time # tuple: year, month, day, hour, min, sec\n # ZIP uses localtime\n return datetime(zt[0], zt[1], zt[2], zt[3], zt[4], zt[5], tzinfo=tz.tzlocal())\n\n def has_file_changed(zipmember: zipfile.ZipInfo, dst_path):\n st: os.stat_result = None\n try:\n st = os.stat(dst_path, follow_symlinks=False)\n if st.st_size != zipmember.file_size:\n return True\n dst_mtime: datetime = datetime.fromtimestamp(st.st_mtime, tz=tz.tzlocal())\n src_mtime = get_zipinfo_datetime(zipmember)\n if dst_mtime != src_mtime:\n return True\n except (OSError, ValueError):\n return True # does not exist\n return False\n\n def make_symlink(zipmember: zipfile.ZipInfo, symlink_location, is_directory):\n target = zip.read(zipmember, pwd=pwd).decode('utf-8')\n if os.path.lexists(symlink_location):\n os.remove(symlink_location)\n os.symlink(target, symlink_location, target_is_directory=is_directory)\n\n unzipped_files: List[Tuple[zipfile.ZipFile, str]] = []\n\n with zipfile.ZipFile(local_zip, \"r\") as zip:\n for zipmember in zip.infolist():\n dst_path = os.path.normpath(os.path.join(extract_dir, zipmember.filename))\n mode = zipmember.external_attr >> 16\n is_symlink = stat.S_ISLNK(mode)\n #what = 'DIR' if zipmember.is_dir() else 'FILE'\n #what = what + ' LINK' if is_symlink else what\n #print(f'{what} {zipmember.filename} S_IMODE={stat.S_IMODE(mode):0o} S_IFMT={stat.S_IFMT(mode):0o}')\n if zipmember.is_dir(): # make dirs if needed\n if is_symlink:\n make_symlink(zipmember, dst_path, is_directory=True)\n else:\n os.makedirs(dst_path, exist_ok=True)\n elif has_file_changed(zipmember, dst_path): # only extract if file appears to be modified\n unzipped_files.append((zipmember, dst_path))\n if is_symlink:\n make_symlink(zipmember, dst_path, is_directory=False)\n else:\n with zip.open(zipmember, pwd=pwd) as src, open(dst_path, \"wb\") as dst:\n shutil.copyfileobj(src, dst)\n for zipmember, dst_path in unzipped_files:\n # set the correct permissions for files and folders\n perm = stat.S_IMODE(zipmember.external_attr >> 16)\n os.chmod(dst_path, perm)\n # always set the modification date from the zipmember timestamp,\n # this way we can avoid unnecessarily modifying files and causing full rebuilds\n time = get_zipinfo_datetime(zipmember)\n #print(f' | {dst_path} {time}')\n mtime = time.timestamp()\n if System.windows:\n os.utime(dst_path, times=(mtime, mtime))\n else:\n os.utime(dst_path, times=(mtime, mtime), follow_symlinks=False)\n\n return len(unzipped_files)","def uncompress(path, dest=None, remove=True):\n # assert path.endswith('.zip')\n prefix, ext = split_if_compressed(path)\n folder_name = os.path.basename(prefix)\n file_is_zip = ext == '.zip'\n root_of_folder = None\n if ext == '.gz':\n try:\n with gzip.open(path, 'rb') as f_in, open(prefix, 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)\n except Exception as e:\n remove_file(prefix)\n remove_file(path)\n raise e\n else:\n try:\n with zipfile.ZipFile(path, \"r\") if ext == '.zip' else tarfile.open(path, 'r:*') as archive:\n if not dest:\n namelist = sorted(archive.namelist() if file_is_zip else archive.getnames())\n if namelist[0] == '.':\n namelist = namelist[1:]\n namelist = [p[len('./'):] if p.startswith('./') else p for p in namelist]\n if ext == '.tgz':\n roots = set(x.split('/')[0] for x in namelist)\n if len(roots) == 1:\n root_of_folder = next(iter(roots))\n else:\n # only one file, root_of_folder = ''\n root_of_folder = namelist[0].strip('/') if len(namelist) > 1 else ''\n if all(f.split('/')[0] == root_of_folder for f in namelist[1:]) or not root_of_folder:\n dest = os.path.dirname(path) # only one folder, unzip to the same dir\n else:\n root_of_folder = None\n dest = prefix # assume zip contains more than one file or folder\n print('Extracting {} to {}'.format(path, dest))\n archive.extractall(dest)\n if root_of_folder:\n if root_of_folder != folder_name:\n # move root to match folder name\n os.rename(path_join(dest, root_of_folder), path_join(dest, folder_name))\n dest = path_join(dest, folder_name)\n elif len(namelist) == 1:\n dest = path_join(dest, namelist[0])\n except Exception as e:\n remove_file(path)\n if os.path.exists(prefix):\n if os.path.isfile(prefix):\n os.remove(prefix)\n elif os.path.isdir(prefix):\n shutil.rmtree(prefix)\n raise e\n if remove:\n remove_file(path)\n return dest","def unzip_and_untar(item):\n print(\"Unpacking %s\" % item)\n\n f = tarfile.open(item, mode=\"r\")\n f.extractall(path=\"working\")\n f.close()","def unarchive(self, target: str, output_target: str = None):\n\t\t\"\"\"An unsucessful decompression will result in a False status, and the header will be None\"\"\"\n\t\ttry:\n\t\t\ttarget = os.path.abspath(target)\n\t\t\tprint(f\"Decompressing archive {target}\")\n\t\t\tif output_target:\n\t\t\t\tprint(f\"Using specified output dir {output_target}\")\n\t\t\t\toutdir = output_target\n\t\t\telse:\n\t\t\t\toutdir = os.path.dirname(target)\n\t\t\t\tprint(f\"Decompressing archive in place at {outdir}\")\n\n\t\t\tprint(\"Opening archive...\")\n\t\t\twith open(target, \"rb+\") as archive:\n\t\t\t\tprint(f\"Reading header...\")\n\t\t\t\theader = archive.read(HEADER_LENGTH)\n\t\t\t\tprint(f\"Reading archive contents...\")\n\t\t\t\tzip_contents = BytesIO(archive.read())\n\t\t\t\"Loading archive...\"\n\t\t\tzip = zipfile.ZipFile(zip_contents, \"r\", zipfile.ZIP_DEFLATED)\n\t\t\tprint(\"Extracting...\")\n\t\t\tzip.extractall(outdir)\n\t\t\tprint(\"Sucess!\")\n\t\t\tstatus = True\n\n\t\texcept Exception as e:\n\t\t\tprint(f\"Error decompressing archive {target} - {e}\")\n\t\t\tstatus = False\n\t\t\theader = None\n\n\t\treturn (status, header)","def unzip(file_loc, extract_loc=None):\n try:\n with zipfile.ZipFile(\n file_loc, \"r\"\n ) as file: # opening the zip file using 'zipfile.ZipFile' class\n print(\"Ok\")\n # ZipFile.infolist() returns a list containing all the members of an archive file\n print(file.infolist())\n\n # ZipFile.namelist() returns a list containing all the members with names of an archive file\n print(file.namelist())\n\n # ZipFile.getinfo(path = filepath) returns the information about a member of Zip file.\n # It raises a KeyError if it doesn't contain the mentioned file\n print(file.getinfo(file.namelist()[-1]))\n\n # If extraction directory not given, extracted to 'data/processed/file_name'\n if extract_loc == None:\n base = os.path.dirname(file_loc)\n folder_name = os.path.basename(base)\n extract_loc = \"data/processed/\" + folder_name\n\n # ZipFile.extractall(path = filepath, pwd = password) extracts all\n # the files to current directory\n file.extractall(path=extract_loc)\n # after executing check the directory to see extracted files\n\n except zipfile.BadZipFile: # if the zip file has any errors then it prints the\n # error message which you wrote under the 'except' block\n print(\"Error: Zip file is corrupted\")\n\n except zipfile.LargeZipFile:\n print(\"Error: File size if too large\") # if the file size is too large to\n # open it prints the error you have written\n except FileNotFoundError:\n print(\"Error: File not found\")","def unzip_nested_zip(dataset_zip, path_unzip):\r\n\r\n with zipfile.ZipFile(dataset_zip, \"r\") as zfile:\r\n try:\r\n zfile.extractall(path=path_unzip)\r\n except OSError as e:\r\n logging.warning(\r\n \"Please check the unzipped files manually. There may be some missed important files.\"\r\n )\r\n logging.warning(\"The directory is: \" + path_unzip)\r\n for root, dirs, files in os.walk(path_unzip):\r\n for filename in files:\r\n if re.search(r\"\\.zip$\", filename):\r\n file_spec = os.path.join(root, filename)\r\n new_dir = os.path.join(root, filename[0:-4])\r\n unzip_nested_zip(file_spec, new_dir)","def unzipArchives(zip_file, password):\n with ZipFile(zip_file) as archive:\n archive.extractall(pwd=bytes(password, \"utf8\"))","def unpack(file_path, extraction_path, remove):\n print(file_path)\n Archive(file_path).extractall(extraction_path, auto_create_dir=True)\n # remove original compressed file???\n if remove is True:\n os.remove(file_path)","def fromZip(self, zip_location,extract_location):\n zip_file = zipfile.ZipFile(zip_location,'r')\n zip_file.extractall(extract_location)","def Unzip(fullPath,installDirectory, quietMode):\n with zipfile.ZipFile(fullPath, 'r') as zip:\n # TODO - check zipfile contents for file number;\n # should always be 1 binary file unless Hashicorp jumps the shark on the build\n extractedFile = zip.namelist()[0]\n if not quietMode:\n print(\"[-] - Extracting (unzip) -> [{0}] ...\".format(extractedFile))\n zip.extractall(installDirectory)\n return extractedFile","def _extract_file(dest_path, root_dir):\n logger.info(\"Unzipping the dataset file.\")\n with zipfile.ZipFile(dest_path, \"r\") as zip_dir:\n zip_dir.extractall(root_dir)","def unzip_file(zip_path, directory_to_extract_to):\n ensure_dir(directory_to_extract_to)\n with zipfile.ZipFile(file=zip_path) as zip_file:\n # Loop over each file\n for file in tqdm(iterable=zip_file.namelist(), total=len(zip_file.namelist())):\n try:\n zip_file.extract(member=file, path=directory_to_extract_to)\n except BadZipFile as e:\n print(e)","def extract_file(self, filename):\n unp_bin = os.path.join(self.modulebin, 'unp')\n\n filepath = os.path.dirname(filename)\n uncompressed = ['fasta', 'fa', 'fastq', 'fq', 'fna', 'h5' ]\n supported = ['tar.gz', 'tar.bz2', 'bz2', 'gz', 'lz',\n 'rar', 'tar', 'tgz','zip']\n for ext in uncompressed:\n if filename.endswith('.'+ext):\n return filename\n for ext in supported:\n if filename.endswith('.'+ext):\n extracted_file = filename[:filename.index(ext)-1]\n if os.path.exists(extracted_file): # Check extracted already\n return extracted_file\n logger.info(\"Extracting {}...\".format(filename))\n # p = subprocess.Popen([unp_bin, filename],\n # cwd=filepath, stderr=subprocess.STDOUT)\n # p.wait()\n # Hide the \"broken pipe\" message from unp\n out = subprocess.Popen([unp_bin, filename],\n cwd=filepath,\n stdout=subprocess.PIPE,\n stderr=subprocess.STDOUT).communicate()[0]\n if os.path.exists(extracted_file):\n return extracted_file\n else:\n logger.error(\"Extraction of {} failed: {}\".format(filename, out))\n raise Exception('Archive structure error')\n logger.error(\"Could not extract {}\".format(filename))\n return filename","def unzip() -> None:\n logger = logging.getLogger(__name__)\n logger.info('Download the dataset')\n\n # define the destination\n destination = project_dir / 'data' / 'raw'\n\n # extract zip\n zip_file = ZipFile(destination / \"original.zip\")\n zip_file.extractall(destination)","def x_unzip(xid=None):\n\t_loadconfig()\n\tnavimport.conf.print_zips()\n\n\txrec = None\n\tif xid == None:\n\t\txrec = _prompt_xid(\"No to unzip >\")\n\telse:\n\t\txrec = navimport.conf.get_xplane_zip_info(0)\n\n\tif xrec != None:\n\t\tprint xrec\n\n\t\ts = \"unzip \"\n\t\ts += \" -d \" + navimport.conf.work_dir(\"/xplane_unzipped/%s\" % xrec['zip_dir'])\n\t\ts += \" \"\n\t\ts += navimport.conf.work_dir(\"/xplane_zips/%s\" % xrec['file_name'])\n\t\tlocal(s)","def ungzip(path):\n unzip_path = \"\".join(path.split(\".\")[0]+\".fna\")\n with gzip.open(path, 'rb') as f_in:\n with open(unzip_path, 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)\n os.remove(path)\n return unzip_path","def extract_zip(zip_path: pathlib.Path, output_path: pathlib.Path, flatten: bool = True) -> None:\n try:\n with zipfile.ZipFile(zip_path) as zf:\n if flatten:\n for member_info in zf.infolist():\n member_name = member_info.filename\n if member_name.startswith('__MACOSX'):\n # Ignore Mac OS X metadata\n continue\n\n member_base_name = os.path.basename(member_name)\n if not member_base_name:\n # Skip directories\n continue\n\n member_output_path = output_path / member_base_name\n\n with zf.open(member_info) as input_stream, member_output_path.open(\n 'wb'\n ) as output_stream:\n shutil.copyfileobj(input_stream, output_stream)\n else:\n zf.extractall(output_path)\n except zipfile.BadZipfile as e:\n raise ScoreError(f'Could not read ZIP file \"{zip_path.name}\": {str(e)}.')","def _do_unzip(zipped_file, output_directory):\n z = zipfile.ZipFile(zipped_file)\n for path in z.namelist():\n relative_path = os.path.join(output_directory, path)\n dirname, dummy = os.path.split(relative_path)\n try:\n if relative_path.endswith(os.sep) and not os.path.exists(dirname):\n os.makedirs(relative_path)\n elif not os.path.exists(relative_path):\n dirname = os.path.join(output_directory, os.path.dirname(path))\n if os.path.dirname(path) and not os.path.exists(dirname):\n os.makedirs(dirname)\n fd = open(relative_path, \"w\")\n fd.write(z.read(path))\n fd.close()\n except IOError, e:\n raise e\n return output_directory","def main(self, line):\n # filename with optional destination\n args = bash(line)\n if args is None:\n return\n elif not (1 <= len(args) <= 2):\n print \"unzip: Usage: unzip file [destination]\"\n else:\n filename = os.path.abspath(args[0])\n if not os.path.isfile(filename):\n print \"unzip: %s: No such file\" % args[0]\n else:\n # PK magic marker check\n f = open(filename)\n try:\n pk_check = f.read(2)\n except Exception:\n pk_check = ''\n finally:\n f.close()\n if pk_check != 'PK':\n print \"unzip: %s: does not appear to be a zip file\" % args[0]\n else:\n if (os.path.basename(filename).lower().endswith('.zip')):\n altpath = os.path.splitext(os.path.basename(filename))[0]\n else:\n altpath = os.path.basename(filename) + '_unzipped'\n altpath = os.path.join(os.path.dirname(filename), altpath)\n location = (args[1:2] or [altpath])[0]\n if (os.path.exists(location)) and not (os.path.isdir(location)):\n print \"unzip: %s: destination is not a directory\" % location\n return\n elif not os.path.exists(location):\n os.makedirs(location)\n zipfp = open(filename, 'rb')\n try:\n zipf = zipfile.ZipFile(zipfp)\n # check for a leading directory common to all files and remove it\n dirnames = [os.path.join(os.path.dirname(x), '') for x in zipf.namelist()]\n common_dir = os.path.commonprefix(dirnames or ['/'])\n # Check to make sure there aren't 2 or more sub directories with the same prefix\n if not common_dir.endswith('/'):\n common_dir = os.path.join(os.path.dirname(common_dir), '')\n for name in zipf.namelist():\n data = zipf.read(name)\n fn = name\n if common_dir:\n if fn.startswith(common_dir):\n fn = fn.split(common_dir, 1)[-1]\n elif fn.startswith('/' + common_dir):\n fn = fn.split('/' + common_dir, 1)[-1]\n fn = fn.lstrip('/')\n fn = os.path.join(location, fn)\n dirf = os.path.dirname(fn)\n if not os.path.exists(dirf):\n os.makedirs(dirf)\n if fn.endswith('/'):\n # A directory\n if not os.path.exists(fn):\n os.makedirs(fn)\n else:\n fp = open(fn, 'wb')\n try:\n fp.write(data)\n finally:\n fp.close()\n except Exception:\n zipfp.close()\n print \"unzip: %s: zip file is corrupt\" % args[0]\n return\n finally:\n zipfp.close()","def remove_zip(self, file_name, callback=None):\n\n if not file_name:\n return\n\n def _cb(*args):\n if callback:\n callback(*args)\n\n file_name_no_ext = os.path.splitext(file_name)[0]\n abs_path_file_name = self.get_abs_path(file_name_no_ext)\n\n try:\n # remove folder and contents\n os.remove(abs_path_file_name)\n if callback:\n try:\n _cb('removed-zip', True)\n except:\n pass\n finally:\n return","def __unzip(self, data):\n compressed = StringIO.StringIO(data)\n gzipper = gzip.GzipFile(fileobj=compressed)\n return gzipper.read()","def _unzip(save_path, _, database_name, data_path):\r\n print('Extracting {}...'.format(database_name))\r\n with zipfile.ZipFile(save_path) as zf:\r\n zf.extractall(data_path)","def unzip (file, path_unzip = None, outfile = None) :\n if path_unzip is None : path_unzip = GetPath ()\n fLOG (\"unzip file\", file)\n file = _check_source (file, path_unzip = path_unzip, outfile = outfile)\n \n nb = 0\n while not os.path.exists (file) and nb < 10 :\n time.sleep(0.5)\n nb += 1\n \n if not os.path.exists (file) :\n raise FileNotFoundError(file)\n \n return file","def unzip(source_archive_path, target_path):\n assert zipfile.is_zipfile(source_archive_path), 'Not a valid ZIP archive'\n print('Decompressing archive {} into {}'.format(source_archive_path, target_path))\n with zipfile.ZipFile(source_archive_path) as zf:\n zf.extractall(target_path)\n print('Done')","def extract_zip(zip_path, target_folder):\n with zipfile.ZipFile(zip_path) as archive:\n archive.extractall(target_folder)","def extract_zip_contents(zip_file, destination):\n logging.info(\"Extracting ZIP File\")\n if os.path.isfile(zip_file):\n with zipfile.ZipFile(zip_file, \"r\") as zip_ref:\n zip_ref.extractall(destination)\n else:\n logging.error(\"%s not found.\", zip_file)\n sys.exit(\"ZIP is not the filesystem.\")","def unzip(file_path: str) -> str:\n destination_directory, zip_file = os.path.split(file_path)\n extracted_path, _ = os.path.splitext(file_path)\n\n if file_path.endswith('tar.gz') or file_path.endswith('tgz'):\n handle_tar(file_path, 'r:gz', extracted_path, destination_directory)\n elif file_path.endswith('tar'):\n handle_tar(file_path, 'r:', extracted_path, destination_directory)\n return extracted_path","def extract_file(self):\n shutil.unpack_archive(os.path.join(self.root, self.resources), self.root)\n os.remove(os.path.join(self.root, self.resources))","def unzip_archive(archive):\n tmpdir = os.path.join(tempfile.gettempdir(),\n os.path.basename(archive))\n assert tmpdir != archive # That wouldn't work out\n\n if os.path.exists(tmpdir):\n # files are already extracted\n pass\n else:\n if tarfile.is_tarfile(archive):\n print 'Extracting tarfile ...'\n with tarfile.open(archive) as tf:\n tf.extractall(path=tmpdir)\n elif zipfile.is_zipfile(archive):\n print 'Extracting zipfile ...'\n with zipfile.ZipFile(archive) as zf:\n zf.extractall(path=tmpdir)\n else:\n raise ValueError('Unknown file type for %s' % os.path.basename(archive))\n return tmpdir","def unzip_file(zipfilename, unziptodir):\n\tunziptodir = unziptodir.replace(cfg.SEP_DCOMM, cfg.SEP_COMM)\n\tmake_dirs(unziptodir)\n\tzfobj = zipfile.ZipFile(zipfilename)\n\tfor name in zfobj.namelist():\n\t\tname = name.replace(cfg.SEP_DCOMM,cfg.SEP_COMM)\n\t\tif name.endswith(cfg.SEP_COMM):\n\t\t\tos.makedirs(os.path.join(unziptodir, name))\n\t\telse:\n\t\t\text_filename = os.path.join(unziptodir, name)\n\t\t\text_filename = ext_filename.replace(cfg.SEP_DCOMM,cfg.SEP_COMM)\n\t\t\text_dir= os.path.dirname(ext_filename)\n\t\t\tmake_dirs(ext_dir)\n\t\t\toutfile = open(ext_filename, 'wb')\n\t\t\toutfile.write(zfobj.read(name))\n\t\t\toutfile.close()","def unzip_file(path_to_zip_file: str, dir_to_extract_to: str) -> str:\n with zipfile.ZipFile(path_to_zip_file, 'r') as zip_ref:\n zip_ref.extractall(dir_to_extract_to)\n return f'{dir_to_extract_to}/{zip_ref.namelist()[0]}'","def unzipper(data_address, target_directory):\n import zipfile\n data = \"/home/sharoonsaxena/Datasets/dogs-vs-cats.zip\"\n zip_ref = zipfile.ZipFile(data, \"r\")\n zip_ref.extractall(\"/home/sharoonsaxena/Datasets/extracted/\")\n zip_ref.close()","def testZipUrl(self):\n try:\n remoteLocator = self.__zipFileUrl\n # fn = self.__fileU.getFileName(remoteLocator)\n ok = self.__fileU.isLocal(remoteLocator)\n self.assertFalse(ok)\n #\n lPath = os.path.join(self.__workPath, self.__fileU.getFileName(self.__zipFileUrl))\n ok = self.__fileU.get(remoteLocator, lPath)\n self.assertTrue(ok)\n ok = self.__fileU.exists(lPath)\n self.assertTrue(ok)\n ok = self.__fileU.isLocal(lPath)\n self.assertTrue(ok)\n tPath = self.__fileU.getFilePath(lPath)\n self.assertEqual(lPath, tPath)\n fp = self.__fileU.uncompress(lPath, outputDir=self.__workPath)\n ok = fp.endswith(\"Food_Display_Table.xlsx\")\n self.assertTrue(ok)\n\n except Exception as e:\n logger.exception(\"Failing with %s\", str(e))\n self.fail()","def unzip_file(filename, location, flatten=True):\n if not os.path.exists(location):\n os.makedirs(location)\n zipfp = open(filename, 'rb')\n try:\n zip = zipfile.ZipFile(zipfp)\n leading = has_leading_dir(zip.namelist()) and flatten\n for name in zip.namelist():\n data = zip.read(name)\n fn = name\n if leading:\n fn = split_leading_dir(name)[1]\n fn = os.path.join(location, fn)\n dir = os.path.dirname(fn)\n if not os.path.exists(dir):\n os.makedirs(dir)\n if fn.endswith('/') or fn.endswith('\\\\'):\n # A directory\n if not os.path.exists(fn):\n os.makedirs(fn)\n else:\n fp = open(fn, 'wb')\n try:\n fp.write(data)\n finally:\n fp.close()\n finally:\n zipfp.close()","def unzip(filename,destination=None,force=False):\n if not destination:\n destination=os.path.splitext(os.path.basename(filename))[0]\n destination = os.path.join(tmpdir,destination)\n if os.path.exists(destination):\n if force:\n shutil.rmtree(destination)\n else:\n zipname = filename.split('/')[-1]\n zip_url = \"https://geo.colorado.edu/apps/geolibrary/datasets/{0}\".format(zipname)\n if not os.path.isfile(\"/data/static/geolibrary/datasets/{0}\".format(zipname)):\n shutil.copy(filename,\"/data/static/geolibrary/datasets/{0}\".format(zipname))\n os.remove(filename)\n return {\"folder\": destination,\"zipdata\":False,\"zipurl\":zip_url}\n zip_ref = zipfile.ZipFile(filename,'r')\n zip_ref.extractall(destination)\n zipname = filename.split('/')[-1]\n shutil.copy(filename,\"/data/static/geolibrary/datasets/{0}\".format(zipname))\n zip_url = \"https://geo.colorado.edu/apps/geolibrary/datasets/{0}\".format(zipname)\n os.remove(filename)\n return {\"folder\": destination,\"zipdata\":True,\"zipurl\":zip_url}","def ZipExtract(zipname, filename, path=os.getcwd()):\n try:\n zpf = zipfile.ZipFile(zipname)\n zpf.extract(filename, path)\n zpf.close()\n return True\n except KeyError:\n logging.warning('Could not find %s to extract from %s.',\n (filename, zipname))\n return False","def unzip(checkpoint_path: pathlib.Path, archive_path: pathlib.Path) -> None:\n checkpoint_path.mkdir(parents=True, exist_ok=True)\n with ZipFile(archive_path, \"r\") as zf:\n zf.extractall(path=checkpoint_path)\n archive_path.unlink()","def extract_zip(file, extract_location):\n\n with zipfile.ZipFile(file, \"r\") as zip_ref:\n zip_ref.extractall(extract_location)\n\n print(f\"Extracted file to {extract_location}\")","def Extract_zip_file (path_to_zip,dir_to_save_into):\n with zipfile.ZipFile(path_to_zip) as zf:\n \n for member in tqdm(zf.namelist(), desc='Extracting'):\n try:\n if ('annotations' in member) and (member.endswith('.json')): \n zf.extract(member, dir_to_save_into)\n shutil.move(os.path.join(dir_to_save_into,member),dir_to_save_into)\n if ('train' in member):\n zf.extract(member, dir_to_save_into)\n if ('test' in member):\n zf.extract(member, dir_to_save_into)\n if ('val' in member):\n zf.extract(member, dir_to_save_into)\n except zipfile.error as e:\n pass\n\n #delete zip\n os.remove(path_to_zip)\n if(os.path.isdir(os.path.join(dir_to_save_into,'annotations'))):\n # remove the tmp annotations directory\n shutil.rmtree(os.path.join(dir_to_save_into,'annotations'))","def unzip_citibike_data(zip_dir):\n# zip_dir = \"data/citibike-tripdata-nyc/\"\n# csv_dir = \"data/citibike-tripdata-nyc/csv\"\n extension = \".zip\"\n\n # for each zip file in zip_dir extract data\n for item in os.listdir(zip_dir):\n if item.endswith(extension):\n\n # create zipfile object and extract\n file_name = zip_dir + item\n with zipfile.ZipFile(file_name, \"r\") as zip_ref:\n zip_ref.extractall(zip_dir)\n print(item + \" done\")","def uncompress_file(location, decompressor):\n # FIXME: do not create a sub-directory and instead strip the \"compression\"\n # extension such gz, etc. or introspect the archive header to get the file\n # name when present.\n assert location\n assert decompressor\n\n warnings = []\n base_name = fileutils.file_base_name(location)\n target_location = os.path.join(fileutils.get_temp_dir(\n prefix='extractcode-extract-'), base_name)\n\n with decompressor(location, 'rb') as compressed:\n with open(target_location, 'wb') as uncompressed:\n buffer_size = 32 * 1024 * 1024\n while True:\n chunk = compressed.read(buffer_size)\n if not chunk:\n break\n uncompressed.write(chunk)\n\n if getattr(decompressor, 'has_trailing_garbage', False):\n warnings.append(location + ': Trailing garbage found and ignored.')\n\n return target_location, warnings","def extract_file(self):\n shutil.unpack_archive(os.path.join(\n self.root, self.resources), f\"{self.root}\")\n os.remove(os.path.join(self.root, self.resources))","def unzip_file(zip_path: str, output_dir: str) -> UnzipFiles:\n files = []\n with zipfile.ZipFile(zip_path, 'r') as zip_ref:\n zip_ref.extractall(output_dir)\n for file_path in os.listdir(output_dir):\n files.append(f\"{output_dir}/{file_path}\")\n return files","def unzip(zipped):\n return zip(*zipped)","def unzip_item(source_path, destination_path, password):\n\n if not destination_path:\n destination_path = source_path.replace(\".zip\", \"\")\n if not os.path.isdir(destination_path):\n os.makedirs(destination_path)\n else:\n destination_path += \"_unzipped\"\n if not os.path.isdir(destination_path):\n os.makedirs(destination_path)\n\n try:\n with pyzipper.AESZipFile(source_path) as z:\n members = z.infolist()\n for i, member in enumerate(members):\n z.extract(member, destination_path, pwd=password)\n print(f\"Unpacked {member.filename} from archive.\")\n print(f\"{source_path} unpacked successfully to {destination_path}.\")\n except Exception:\n tb = traceback.format_exc()\n print(\"Something went wrong\")\n print(tb)","def fetch(self) -> None:\n archive_path = os.path.join(self._output_dir, self._archive_name)\n self._download_file(self._parsed_url.original_url, archive_path)\n try:\n with zipfile.ZipFile(archive_path, \"r\") as zip_file:\n zip_file.extractall(path=self._output_dir)\n except zipfile.BadZipfile:\n raise REANAFetcherError(\"The provided zip file is not valid\")\n\n os.remove(archive_path)\n\n if not self._discover_workflow_specs():\n top_level_entries = [\n os.path.join(self._output_dir, entry)\n for entry in os.listdir(self._output_dir)\n ]\n # Some zip archives contain a single directory with all the files.\n if len(top_level_entries) == 1 and os.path.isdir(top_level_entries[0]):\n top_level_dir = top_level_entries[0]\n # Move all entries inside the top level directory\n # to the output directory.\n for entry in os.listdir(top_level_dir):\n shutil.move(os.path.join(top_level_dir, entry), self._output_dir)\n os.rmdir(top_level_dir)","def untar(input_filename, extract_dir):\n try:\n tar_ds = tarfile.open(input_filename)\n except tarfile.TarError:\n raise ValueError(\"%s is not a tar file\" % (input_filename))\n tar_ds.extractall(path=extract_dir)\n tar_ds.close()","def ExtractZip(zip_path, dest_dir):\n zip_path = GetWindowsPathWithUNCPrefix(zip_path)\n dest_dir = GetWindowsPathWithUNCPrefix(dest_dir)\n with zipfile.ZipFile(zip_path) as zf:\n for info in zf.infolist():\n zf.extract(info, dest_dir)\n # UNC-prefixed paths must be absolute/normalized. See\n # https://docs.microsoft.com/en-us/windows/desktop/fileio/naming-a-file#maximum-path-length-limitation\n file_path = os.path.abspath(os.path.join(dest_dir, info.filename))\n # The Unix st_mode bits (see \"man 7 inode\") are stored in the upper 16\n # bits of external_attr. Of those, we set the lower 12 bits, which are the\n # file mode bits (since the file type bits can't be set by chmod anyway).\n attrs = info.external_attr >> 16\n if attrs != 0: # Rumor has it these can be 0 for zips created on Windows.\n os.chmod(file_path, attrs & 0o7777)","def unpack_first(input_filename: str, extract_dir: str) -> str:\n if not is_archive_file(input_filename):\n raise AttributeError(\"Input_filename must be an archive (ex: .tar.gz, .zip)\")\n if zipfile.is_zipfile(input_filename):\n return unzip_first(input_filename, extract_dir)\n else:\n return untar_first(input_filename, extract_dir)","def uncompress(self, compressed):\n\t\traise Exception(NotImplemented)","def unzip_file(\n file_path:str,\n unzip_dest: str,\n rgb_raw_zip: bool = False,\n keep_zip: bool = False\n) -> None:\n\n print('Unzipping: {}'.format(file_path))\n with zipfile.ZipFile(file_path, 'r') as z:\n for f in z.filelist:\n if rgb_raw_zip:\n if f.filename.endswith('.png'):\n date, drive, img_idx, _, img_name = f.filename.split('/')\n if img_idx in ['image_02', 'image_03']:\n f.filename = os.path.basename(f.filename)\n z.extract(f, '/'.join([unzip_dest, drive, 'image', img_idx]))\n else:\n z.extract(f, unzip_dest)\n \n if not keep_zip:\n os.remove(file_path)","def getzip(url, zipfile, unzipdir):\n done_file = os.path.join(unzipdir, '.'+os.path.basename(zipfile)+'.done')\n if file_exists(done_file):\n print('{} already downloaded and extracted; skipping. To reinstall \"rm {}\"'.format(os.path.basename(zipfile), done_file))\n else:\n print('Downloading {} as {}.'.format(url, zipfile))\n urlretrieve(url, zipfile)\n print('Extracting {} into {}.'.format(zipfile, unzipdir))\n with ZipFile(zipfile, 'r') as zip:\n zip.extractall(unzipdir)\n os.remove(zipfile)\n with open(done_file, 'w'):\n pass","def test_unarchive_run(self):\n pass","def ExtractFile(self, dest_dir):\n self.__get_packed_xwalk_app_template(dest_dir)\n file_path = os.path.join(dest_dir, self.file_name)\n tar = tarfile.open(file_path, 'r:gz')\n tar.extractall(dest_dir)\n tar.close()\n file_path = os.path.join(dest_dir, self.file_name)\n if os.path.isfile(file_path):\n os.remove(file_path)","def unzip_oxygen_files(zip_file):\n name_main_content = None\n name_left_menu = None\n list_img_files_to_save = list()\n\n files_unzipped = ZipFile(zip_file)\n for file_unzipped_name in files_unzipped.namelist():\n if not file_unzipped_name.startswith('__MACOSX'):\n if file_unzipped_name.endswith(\".jpeg\"):\n list_img_files_to_save.append(file_unzipped_name)\n elif file_unzipped_name.endswith(\".indexList.html\"):\n name_left_menu = file_unzipped_name\n elif file_unzipped_name.endswith(\"_xsd.html\"):\n name_main_content = file_unzipped_name\n\n return files_unzipped, name_left_menu, name_main_content, list_img_files_to_save","def unzip_first(input_filename: str, extract_dir: str) -> str:\n with zipfile.ZipFile(input_filename) as zip_file:\n zip_file_list = zip_file.infolist()\n zip_index = 0\n while zip_index < len(zip_file_list) and zip_file_list[zip_index].is_dir():\n zip_index += 1\n if zip_index == len(zip_file_list):\n res = ''\n else:\n file_to_extract = zip_file_list[zip_index]\n zip_file.extract(file_to_extract, extract_dir)\n res = os.path.join(extract_dir, file_to_extract.filename)\n return res","def close(self):\n self.myzip.close()","def extractSourceToDestination(self, strZipFile: str):\n with zipfile.ZipFile(strZipFile, 'r') as zipRef:\n zipRef.extractall(self.strDataDir)\n\n os.remove(strZipFile)","def unzip_all(input_file: pathlib.Path) -> Tuple[pathlib.Path, tempfile.TemporaryDirectory]:\n output_temp_dir = tempfile.TemporaryDirectory()\n output_path = pathlib.Path(output_temp_dir.name)\n\n extract_zip(input_file, output_path)\n\n return output_path, output_temp_dir","def unzipfile(filename, passcode):\n # Password is SHA-256 hash of the pass code received\n password = hashlib.sha256(passcode.encode('utf-8')).hexdigest()\n # Unzip with password\n with ZipFile(filename) as zf:\n zf.extractall(pwd=bytes(password, 'utf-8'))","def unpack_archive(\r\n file_path: str, unpack_path: str = None, remove_if_exists: bool = False\r\n) -> Optional[str]:\r\n import tarfile\r\n import zipfile\r\n\r\n if not os.path.isfile(file_path):\r\n log.warning(\"File does not exist: \" + file_path)\r\n return None\r\n\r\n if zipfile.is_zipfile(file_path):\r\n unpack_path = extract_zip(file_path, unpack_path, remove_if_exists)\r\n elif tarfile.is_tarfile(file_path):\r\n unpack_path = extract_tar(file_path, unpack_path, remove_if_exists)\r\n else:\r\n unpack_path = extract_via_patoolib(file_path, unpack_path, remove_if_exists)\r\n\r\n if unpack_path and os.path.isdir(unpack_path):\r\n unpack_folder_name = os.path.basename(unpack_path)\r\n if len(os.listdir(unpack_path)) == 1 and unpack_folder_name in os.listdir(\r\n unpack_path\r\n ):\r\n # unpacked folder contains one folder with same name -> move content to higher up folder\r\n folder_to_move = os.path.join(unpack_path, unpack_folder_name)\r\n files = os.listdir(folder_to_move)\r\n for f in files:\r\n shutil.move(os.path.join(folder_to_move, f), unpack_path)\r\n\r\n # Remove empty folder\r\n if len(os.listdir(folder_to_move)) == 0:\r\n os.rmdir(folder_to_move)\r\n else:\r\n log.info(\"Folder content was moved but folder is not empty.\")\r\n\r\n return unpack_path","def unzip_to_temp_dir(zip_file_name):\n if not zip_file_name or not os.path.exists(zip_file_name):\n return None\n\n zf = zipfile.ZipFile(zip_file_name)\n\n if zf.testzip() is not None:\n return None\n\n # Unzip the files into a temporary directory\n LOGGER.info(\"Extracting zipped file: %s\" % zip_file_name)\n tempdir = tempfile.mkdtemp()\n\n try:\n # Create directories that don't exist\n for zip_name in zf.namelist():\n # We have no knowledge on the os where the zipped file was\n # created, so we restrict to zip files with paths without\n # charactor \"\\\" and \"/\".\n name = (zip_name.replace(\"\\\\\", os.path.sep).\n replace(\"/\", os.path.sep))\n dest = os.path.join(tempdir, name)\n if (name.endswith(os.path.sep) and not os.path.exists(dest)):\n os.mkdir(dest)\n LOGGER.debug(\"Directory %s created.\" % dest)\n\n # Copy files\n for zip_name in zf.namelist():\n # We have no knowledge on the os where the zipped file was\n # created, so we restrict to zip files with paths without\n # charactor \"\\\" and \"/\".\n name = (zip_name.replace(\"\\\\\", os.path.sep).\n replace(\"/\", os.path.sep))\n dest = os.path.join(tempdir, name)\n if not (name.endswith(os.path.sep)):\n LOGGER.debug(\"Copying file %s......\" % dest)\n outfile = open(dest, 'wb')\n outfile.write(zf.read(zip_name))\n outfile.close()\n LOGGER.debug(\"File %s copied.\" % dest)\n\n LOGGER.info(\"Unzipped file can be found at %s\" % tempdir)\n return tempdir\n\n except IOError as err:\n LOGGER.error(\"Error in extracting webdriver.xpi: %s\" % err)\n return None","def ExtractZip(filename, output_dir, verbose=True):\n MaybeMakeDirectory(output_dir)\n\n # On Linux and Mac, we use the unzip command as it will\n # handle links and file bits (executable), which is much\n # easier then trying to do that with ZipInfo options.\n #\n # On Windows, try to use 7z if it is installed, otherwise fall back to python\n # zip module and pray we don't have files larger than 512MB to unzip.\n unzip_cmd = None\n if IsLinux():\n unzip_cmd = ['unzip', '-o']\n elif IsMac():\n # The Mac version of unzip does not have LARGE_FILE_SUPPORT until\n # macOS 10.12, so use ditto instead. The Python ZipFile fallback\n # used on Windows does not support symbolic links, which makes it\n # unsuitable for Mac builds.\n unzip_cmd = ['ditto', '-x', '-k']\n elif IsWindows() and os.path.exists('C:\\\\Program Files\\\\7-Zip\\\\7z.exe'):\n unzip_cmd = ['C:\\\\Program Files\\\\7-Zip\\\\7z.exe', 'x', '-y']\n\n if unzip_cmd:\n # Make sure path is absolute before changing directories.\n filepath = os.path.abspath(filename)\n saved_dir = os.getcwd()\n os.chdir(output_dir)\n command = unzip_cmd + [filepath]\n # When using ditto, a destination is required.\n if command[0] == 'ditto':\n command += ['.']\n result = RunCommand(command)\n os.chdir(saved_dir)\n if result:\n raise ExternalError('unzip failed: %s => %s' % (str(command), result))\n else:\n assert IsWindows()\n zf = zipfile.ZipFile(filename)\n # TODO(hinoka): This can be multiprocessed.\n for name in zf.namelist():\n if verbose:\n print 'Extracting %s' % name\n zf.extract(name, output_dir)\n if IsMac():\n # Restore permission bits.\n os.chmod(os.path.join(output_dir, name),\n zf.getinfo(name).external_attr >> 16L)"],"string":"[\n \"def unzip(zip_path, output_file, data_folder):\\n\\n print('Unzipping file: {}'.format(zip_path))\\n pyunpack.Archive(zip_path).extractall(data_folder)\\n\\n # Checks if unzip was successful\\n if not os.path.exists(output_file):\\n raise ValueError(\\n 'Error in unzipping process! {} not found.'.format(output_file))\",\n \"def unzip_file(zip_file: str) -> None:\\n destination = tempfile.mkdtemp(prefix='gaelo_pross_unzip_')\\n with ZipFile(zip_file) as my_zip:\\n for member in my_zip.namelist():\\n filename = os.path.basename(member)\\n # skip directories\\n if not filename:\\n continue\\n # copy file (taken from zipfile's extract)\\n source = my_zip.open(member)\\n target = open(os.path.join(destination, filename), \\\"wb\\\")\\n with source, target:\\n shutil.copyfileobj(source, target)\\n # return destination\",\n \"def unzip_data():\\n zip_ref = zipfile.ZipFile(data_zip, 'r')\\n zip_ref.extractall('')\\n zip_ref.close()\",\n \"def unzip_file(data_zip, path_unzip):\\r\\n with zipfile.ZipFile(data_zip, \\\"r\\\") as zip_temp:\\r\\n zip_temp.extractall(path_unzip)\",\n \"def unzip(zip_path, cleanup=False):\\n zfile = zipfile.ZipFile(zip_path, 'r')\\n zfile.extractall(os.path.dirname(zip_path))\\n zfile.close()\\n if cleanup:\\n os.remove(zip_path)\",\n \"def unzip(zipped_file):\\n with gzip.open(zipped_file, 'rt', encoding='ISO-8859-1') as file:\\n file = file.read()\\n return file\",\n \"def _unzip_file(zip_file_path: str, unzip_dir: str = \\\"\\\") -> None:\\n if not unzip_dir:\\n unzip_dir = os.path.dirname(zip_file_path)\\n op_desc = f\\\"Extracting: {os.path.basename(zip_file_path)}\\\"\\n try:\\n with ZipFile(file=zip_file_path) as zip_file:\\n for member_name in tqdm(zip_file.namelist(), desc=op_desc):\\n file_name = os.path.basename(member_name)\\n if not file_name:\\n continue\\n target_path = os.path.join(unzip_dir, file_name)\\n target_path = open(target_path, \\\"wb\\\")\\n source_file = zip_file.open(member_name)\\n with source_file, target_path:\\n shutil.copyfileobj(source_file, target_path)\\n os.remove(zip_file_path)\\n except Exception as zip_error:\\n zip_file_str = os.path.basename(zip_file_path)\\n zip_file_str = os.path.splitext(zip_file_str)[0]\\n for file_name in os.listdir(unzip_dir):\\n if zip_file_str in file_name:\\n os.remove(os.path.join(unzip_dir, file_name))\\n raise zip_error\",\n \"def unzip_file(zipfile_path, target_dir, touchfile_path):\\r\\n with zipfile.ZipFile(zipfile_path, 'r') as zip_ref:\\r\\n zip_ref.extractall(target_dir)\\r\\n\\r\\n with open(touchfile_path, 'w') as touchfile:\\r\\n touchfile.write(f'unzipped {zipfile_path}')\",\n \"def unpackage():\\n\\n zipfileLoc = hou.ui.selectFile(title=\\\"please select a zipFile created by the package function\\\", pattern=\\\"*.zip\\\")\\n if not zipfileLoc: \\n \\n return\\n \\n file_ = zipfile.ZipFile(hou.expandString(zipfileLoc), \\\"r\\\")\\n\\n isOke = False\\n \\n for name in file_.namelist():\\n \\n if name.endswith(\\\".hip\\\") or name.endswith(\\\".hipnc\\\"):\\n \\n isOke = True\\n break\\n \\n if not isOke: \\n \\n return\\n \\n unpackLoc = hou.expandString(hou.ui.selectFile(title=\\\"please select a directory you wish to use to unpack the files to.\\\"))\\n \\n if not unpackLoc or not os.path.isdir(unpackLoc): \\n \\n return\\n \\n unzip(file_, unpackLoc)\\n unpackageDir = os.path.dirname(file_.namelist()[0])\\n otlsfiles = glob.glob(os.path.join(unpackLoc, unpackageDir, \\\"otls\\\", \\\"*\\\"))\\n hipfile = glob.glob(os.path.join(unpackLoc, unpackageDir, \\\"*.hip*\\\"))\\n \\n if len(hipfile) != 1: \\n \\n return\\n \\n hou.hipFile.load(hipfile[0])\\n \\n for otl in otlsfiles:\\n\\n hou.hda.installFile(otl)\",\n \"def unzip(self):\\n global pointer\\n global error_flag\\n global totalFiles\\n while pointer < len(self.files) and ((self.t and not error_flag) or not self.t):\\n # Se o modo nao for t pode avancar sem restricoes\\n # Se o modo e' t e a error_flag nao for false entao pode avancar\\n self.sem.acquire()\\n iterator = pointer\\n pointer += 1\\n self.sem.release()\\n if iterator < len(self.files): # Iterator e' o ficheiro que deve ser utilizado pela thread\\n File = self.files[iterator]\\n if os.path.isfile(File): # Ver se o ficheiro existe\\n with ZipFile(File, 'r') as zipfile:\\n zipfile.extractall('.') # Unzip\\n self.totalFilesSem.acquire()\\n totalFiles += 1\\n self.totalFilesSem.release()\\n else:\\n print \\\"O ficheiro\\\", File, \\\"não existe.\\\" # Se nao exister, avisa o utilizador\\n error_flag = True # Atualiza a sua propria flag\",\n \"def unzip_single_file(zip_file_name, output_file_name):\\n if not os.path.isfile(output_file_name):\\n with open(output_file_name, 'wb') as out_file:\\n with zipfile.ZipFile(zip_file_name) as zipped:\\n for info in zipped.infolist():\\n if output_file_name in info.filename:\\n with zipped.open(info) as requested_file:\\n out_file.write(requested_file.read())\\n return\",\n \"def unzip(input_filename, extract_dir):\\n if not zipfile.is_zipfile(input_filename):\\n raise ValueError(\\\"%s is not a zip file\\\" % (input_filename))\\n zip_ds = zipfile.ZipFile(input_filename)\\n zip_ds.extractall(path=extract_dir)\\n zip_ds.close()\",\n \"def unzip(input_file, output_file):\\n output_file = validator.validate_unzip(input_file, output_file)\\n process = subprocess.Popen([PBWT_BIN, 'unzip', input_file, output_file],\\n stdout=subprocess.PIPE)\\n process_results(str(process.communicate()[0]))\",\n \"def _check_zip_file (filename, path_unzip, outfile) :\\n assert path_unzip is not None\\n file,ext = os.path.splitext (filename)\\n ext = ext.lower ()\\n if ext == \\\".gz\\\" :\\n \\n import gzip\\n \\n if outfile is None :\\n dest = filename.split (\\\"!\\\")\\n dest = dest [ len(dest)-1 ]\\n ext = os.path.splitext (dest) [1]\\n dest = dest.replace (ext, \\\".txt\\\")\\n path = os.path.split (filename)\\n path = \\\"/\\\".join (path [:len (path)-1])\\n dest = path + \\\"/\\\" + dest\\n else :\\n dest = outfile\\n \\n if not os.path.exists (dest) :\\n file = gzip.GzipFile (filename, \\\"r\\\")\\n if outfile is None :\\n dest = os.path.split (dest) [1]\\n dest = os.path.join (path_unzip, dest)\\n \\n if os.path.exists (dest) :\\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\\n if st2 > st1 : \\n fLOG (\\\"ungzipping file (already done)\\\", dest)\\n return dest\\n \\n fLOG (\\\"ungzipping file\\\", dest)\\n f = open (dest, \\\"w\\\")\\n data = file.read (2**27)\\n size = 0\\n while len (data) > 0 :\\n size += len (data)\\n fLOG (\\\"ungzipping \\\", size, \\\"bytes\\\")\\n if isinstance (data, bytes) : f.write (bytes.decode (data))\\n else : f.write (data)\\n data = file.read (2**27)\\n f.close ()\\n file.close ()\\n \\n return dest\\n \\n if ext == \\\".zip\\\" :\\n \\n import zipfile\\n try :\\n file = zipfile.ZipFile (filename, \\\"r\\\")\\n except Exception as e :\\n fLOG (\\\"problem with \\\", filename)\\n raise e\\n \\n if len (file.infolist()) != 1:\\n if outfile is not None :\\n raise PQHException (\\\"the archive contains %d files and not one as you expected by filling outfile\\\" % len (file.infolist()))\\n fLOG (\\\"unzip file (multiple) \\\", filename)\\n #message = \\\"\\\\n\\\".join ([ fi.filename for fi in file.infolist() ] )\\n #raise Exception.YstException(\\\"ColumnInfoSet.load_from_file: file %s contains no file or more than one file\\\\n\\\" + message)\\n folder = os.path.split (filename) [0]\\n todo = 0\\n _zip7_path = r\\\"c:\\\\Program Files\\\\7-Zip\\\"\\n zip7 = os.path.exists (_zip7_path)\\n wait = [ ]\\n for info in file.infolist () :\\n fileinside = info.filename\\n dest = os.path.join (folder, fileinside)\\n if not os.path.exists (dest) :\\n fol = os.path.split (dest) [0]\\n if not os.path.exists (fol) : os.makedirs (fol)\\n if os.path.exists (dest) :\\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\\n if st2 > st1 : \\n continue\\n \\n if not sys.platform.startswith(\\\"win\\\") or not zip7 :\\n data = file.read (fileinside)\\n dest = os.path.split (dest) [1]\\n dest = os.path.join (path_unzip, dest)\\n fLOG (\\\"unzipping file\\\", dest)\\n wait.append(dest)\\n f = open (dest, \\\"w\\\")\\n if isinstance (data, bytes) :\\n f.write (str (data))\\n else :\\n f.write (data)\\n f.close ()\\n else :\\n todo += 1\\n \\n if todo > 0 and zip7 :\\n dest = os.path.realpath (path_unzip)\\n cmd = '\\\"' + _zip7_path + '\\\\\\\\7z.exe\\\" e -y -o\\\"%s\\\" \\\"%s\\\"' % (dest, os.path.realpath (filename)) \\n out,err = run_cmd (cmd, wait = True)\\n if len (err) > 0 : raise PQHException (\\\"command {0} failed\\\\n{1}\\\".format(cmd,err))\\n if \\\"Error\\\" in out : raise PQHException (\\\"command {0} failed\\\\n{1}\\\".format(cmd,out))\\n else :\\n dest = path_unzip\\n \\n file.close ()\\n \\n ch = False\\n while not ch :\\n ch = True\\n for a in wait :\\n if not os.path.exists(a) : \\n ch = False\\n break\\n time.sleep(0.5)\\n \\n return dest\\n \\n else :\\n for info in file.infolist () :\\n fileinside = info.filename\\n \\n path = os.path.split (filename)\\n dest = outfile if outfile is not None else path [0] + \\\"/\\\" + fileinside\\n if not os.path.exists (dest) :\\n data = file.read (fileinside)\\n if outfile is None :\\n dest = os.path.split (dest) [1]\\n dest = os.path.join (path_unzip, dest)\\n \\n if os.path.exists (dest) :\\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\\n if st2 > st1 : \\n fLOG(\\\"unzipping one file (already done)\\\", dest)\\n return dest\\n \\n fLOG(\\\"unzipping one file\\\", dest)\\n f = open (dest, \\\"w\\\")\\n if isinstance (data, bytes) :\\n f.write (bytes.decode (data))\\n else :\\n f.write (data)\\n f.close ()\\n file.close ()\\n return dest\\n \\n return filename\",\n \"def unzip(zip_file, dest_folder):\\n zip = zipfile.ZipFile(zip_file, 'r')\\n if os.path.exists(dest_folder):\\n pass\\n else:\\n os.makedirs(dest_folder)\\n if dest_folder[-1] != '/':\\n dest_folder += '/'\\n for filename in zip.namelist():\\n # --- Folder?\\n if filename.endswith('/'):\\n if os.path.exists(join(abspath(dest_folder),filename)):\\n pass\\n else:\\n os.makedirs(join(abspath(dest_folder),filename))\\n else:\\n try:\\n os.makedirs(normpath((abspath(dest_folder)+'/'+dirname(filename))))\\n try:\\n bytes = zip.read(filename)\\n #print 'Unzipping file:', filename, 'with', len(bytes), 'bytes..'\\n file((join(dest_folder,filename)), 'wb').write(zip.read(filename))\\n accesstime = time.time()\\n timeTuple=(int(zip.getinfo(filename).date_time[0]),\\\\\\n int(zip.getinfo(filename).date_time[1]),\\\\\\n int(zip.getinfo(filename).date_time[2]),\\\\\\n int(zip.getinfo(filename).date_time[3]) ,\\\\\\n int(zip.getinfo(filename).date_time[4]),\\\\\\n int(zip.getinfo(filename).date_time[5]),\\\\\\n int(0),int(0),int(0))\\n modifiedtime = mktime(timeTuple)\\n utime((join(dest_folder,filename)), (accesstime,modifiedtime))\\n except IOError:\\n pass\\n except:\\n if os.path.exists(normpath((abspath(dest_folder)+'/'+dirname(filename)))):\\n try:\\n bytes = zip.read(filename)\\n #print 'Unzipping file:', filename, 'with', len(bytes), 'bytes..'\\n file((join(dest_folder,filename)), 'wb').write(zip.read(filename))\\n accesstime = time.time()\\n timeTuple=(int(zip.getinfo(filename).date_time[0]),\\\\\\n int(zip.getinfo(filename).date_time[1]),\\\\\\n int(zip.getinfo(filename).date_time[2]),\\\\\\n int(zip.getinfo(filename).date_time[3]) ,\\\\\\n int(zip.getinfo(filename).date_time[4]),\\\\\\n int(zip.getinfo(filename).date_time[5]),\\\\\\n int(0),int(0),int(0))\\n modifiedtime = mktime(timeTuple)\\n utime((join(dest_folder,filename)), (accesstime,modifiedtime))\\n except IOError:\\n pass\\n else:\\n os.makedirs(normpath((abspath(dest_folder)+'/'+dirname(filename))))\\n zip.close\",\n \"def unzip_data(zip_f,data_folder_path): \\n\\n with zipfile.ZipFile(zip_f,\\\"r\\\") as zip_ref:\\n zip_ref.extractall(data_folder_path)\",\n \"def _unzip(filename, branch=None):\\n try:\\n file = zipfile.ZipFile(filename)\\n basename = os.path.dirname(filename)\\n basename = basename.replace(\\\".zip\\\", \\\"\\\")\\n file.extractall(path=basename)\\n return basename, filename\\n except Exception as e:\\n six.print_(e)\",\n \"def unzip(filepath, cleanup=False):\\n\\t(uzfile, ext) = os.path.splitext(filepath)\\n\\tif ext != '.gz':\\n\\t\\treturn filepath\\n\\tif os.path.exists(uzfile):\\n\\t\\treturn uzfile\\n\\t\\n\\twith gzip.open(filepath, 'rb') as f_in:\\n\\t\\twith open(uzfile, 'w') as f_out:\\n\\t\\t\\tfor line in f_in:\\n\\t\\t\\t\\tf_out.write(line.decode())\\n\\t\\n\\tif cleanup and file_exists(uzfile):\\n\\t\\tos.remove(filepath)\\n\\treturn uzfile\",\n \"def unzip(f, targetdir):\\n import zipfile\\n\\n with zipfile.ZipFile(f, \\\"r\\\") as zip_ref:\\n zip_ref.extractall(targetdir)\",\n \"def _unzip(self, data):\\r\\n with io.BytesIO(data) as buf:\\r\\n with gzip.GzipFile(fileobj=buf) as unzipped:\\r\\n return unzipped.read()\",\n \"def _unpack_archive(self):\\n with zipfile.ZipFile(self._archive_full_path, 'r') as zip_ref:\\n zip_ref.extractall(self._storage_path)\\n\\n _logger.debug('Archive has been unpacked.')\",\n \"def unzip(zipped_file, output_directory=None,\\n prefix=\\\"apsharvest_unzip_\\\", suffix=\\\"\\\"):\\n if not output_directory:\\n # We create a temporary directory to extract our stuff in\\n try:\\n output_directory = mkdtemp(suffix=suffix,\\n prefix=prefix,\\n dir=os.path.join(CFG_TMPSHAREDDIR, 'apsharvest'))\\n except Exception, e:\\n try:\\n os.removedirs(output_directory)\\n except TypeError:\\n pass\\n raise e\\n return _do_unzip(zipped_file, output_directory)\",\n \"def _unzip_files(self) -> None:\\n for file in self.input_path.iterdir():\\n if is_zipfile(file):\\n with ZipFile(file, mode=\\\"r\\\") as archive:\\n archive.extractall(path=self.temp_path)\",\n \"def test_unzip_file(self):\\n\\n # Path to the compressed file\\n zipped_file = os.path.join(self.xmlfilepath, \\\"DLTINS_20210117_01of01.zip\\\")\\n # Test for correct data\\n # NOTE : For this test case to pass the source xml zipped file\\n # should be present in the download path\\n self.assertTrue(unzip_file(zipped_file, self.xmlfilepath))\\n\\n # Test for wrong target path\\n self.assertFalse(unzip_file(zipped_file, r\\\"D:\\\\kqcA CK j \\\"))\\n\\n # Test for incorrect compressed file\\n self.assertFalse(unzip_file(\\\"D:\\\\somerandomfile\\\", self.xmlfilepath))\",\n \"def unpack(input_filename, extract_dir):\\n if not is_archive_file(input_filename):\\n raise AttributeError(\\\"Input_filename must be an archive (ex: .tar.gz, .zip)\\\")\\n if zipfile.is_zipfile(input_filename):\\n unzip(input_filename, extract_dir)\\n else:\\n untar(input_filename, extract_dir)\",\n \"def unzip(zfile, md=False):\\n\\tbasedir = ''\\n\\tcount = -1\\n\\tif md:\\n\\t\\tbasedir = prepareBaseDir(zfile)\\n\\t\\n\\tzfile = zipfile.ZipFile(zfile, 'r')\\n\\tfor name in zfile.namelist():\\n\\t\\tcount+=1\\n\\t\\tuname = name.decode('gbk')\\n\\t\\tif uname.endswith('.DS_Store'):\\n\\t\\t\\tcontinue\\n\\t\\t\\n\\t\\t#prepare directory\\n\\t\\tdirs = os.path.dirname(uname)\\n\\t\\tif basedir:\\n\\t\\t\\tdirs = os.path.join(basedir, dirs)\\n\\t\\tprint 'Extracting: ' + uname\\n\\t\\tif dirs and not os.path.exists(dirs):\\n\\t\\t\\tprint 'Prepare directories: ', dirs\\n\\t\\t\\tos.makedirs(dirs)\\n\\t\\tif (count == 0):\\n\\t\\t\\thomeDir = uname[:-1]\\n\\t\\t#ready to unzip file\\n\\t\\tdata = zfile.read(name)\\n\\t\\tif basedir:\\n\\t\\t\\tuname = os.path.join(basedir, uname)\\n\\t\\tif not os.path.exists(uname):\\n\\t\\t\\tfo = open(uname, 'w')\\n\\t\\t\\tfo.write(data)\\n\\t\\t\\tfo.close()\\n\\tzfile.close()\\n\\treturn homeDir\",\n \"def extract_and_clean(zipper, zip_path, filename):\\n zipper.extract(zip_path)\\n if \\\"/\\\" in zip_path :\\n os.rename(zip_path, filename)\\n shutil.rmtree(zip_path.split('/')[0])\",\n \"def unzip(path):\\n zip_ref = zipfile.ZipFile(path, 'r')\\n new_path = path[:-3]\\n zip_ref.extractall(new_path)\\n zip_ref.close()\\n return new_path\",\n \"def unzip(self):\\n try:\\n zipped_files = [f for f in os.listdir('.') if os.path.isfile(f)]\\n for file in zipped_files:\\n unzipped = self.unzip_file(file)\\n if not unzipped:\\n logging.error('Failed to unzip {}'.format(file))\\n return False\\n all_files = [f for f in os.listdir('.') if os.path.isfile(f)]\\n for f in all_files:\\n os.chmod(f, self.file_mode)\\n except Exception as e:\\n logging.error('Failed to unzip and change file mode {}'\\n .format(e))\\n return False\\n return True\",\n \"def unzip_file(path_to_zip_file, directory_to_extract_to):\\n \\n with zipfile.ZipFile(path_to_zip_file, 'r') as zip_ref:\\n zip_ref.extractall(directory_to_extract_to)\\n\\n return\",\n \"def unzip_file(self, filename, location, flatten=True):\\n if not os.path.exists(location):\\n os.makedirs(location)\\n zipfp = open(filename, 'rb')\\n try:\\n zip = zipfile.ZipFile(zipfp)\\n leading = has_leading_dir(zip.namelist()) and flatten\\n for name in zip.namelist():\\n data = zip.read(name)\\n fn = name\\n if leading:\\n fn = split_leading_dir(name)[1]\\n fn = os.path.join(location, fn)\\n dir = os.path.dirname(fn)\\n if not os.path.exists(dir):\\n os.makedirs(dir)\\n if fn.endswith('/') or fn.endswith('\\\\\\\\'):\\n # A directory\\n if not os.path.exists(fn):\\n os.makedirs(fn)\\n else:\\n fp = open(fn, 'wb')\\n try:\\n fp.write(data)\\n finally:\\n fp.close()\\n finally:\\n zipfp.close()\",\n \"def file_unzipper(directory):\\n debug.log(\\\"Unzipping directory (%s)...\\\"%directory)\\n #FINDING AND UNZIPPING ZIPPED FILES\\n for root, dirs, files in os.walk(directory, topdown=False):\\n if root != \\\"\\\":\\n orig_dir = os.getcwd()\\n os.chdir(directory)\\n Popen('gunzip -q -f *.gz > /dev/null 2>&1', shell=True).wait()\\n Popen('unzip -qq -o \\\"*.zip\\\" > /dev/null 2>&1', shell=True).wait()\\n Popen('rm -f *.zip > /dev/null 2>&1', shell=True).wait()\\n os.chdir(orig_dir)\",\n \"def extract_file(self):\\n# path_destination = os.path.join(\\n# self.root, self.resources.replace(\\\".zip\\\", \\\"\\\"))\\n# os.makedirs(path_destination, exist_ok=True)\\n shutil.unpack_archive(os.path.join(\\n self.root, self.resources), self.root)\\n os.remove(os.path.join(self.root, self.resources))\",\n \"def unzip(path, filename_as_folder=False):\\n for filename in os.listdir(path):\\n if filename.endswith(\\\".zip\\\"):\\n name = os.path.splitext(os.path.basename(filename))[0]\\n if not os.path.isdir(name):\\n try:\\n file = os.path.join(path, filename)\\n zip = ZipFile(file)\\n if filename_as_folder:\\n directory = os.path.join(path, name)\\n os.mkdir(directory)\\n print(\\\"Unzipping {} to {}\\\".format(filename, directory))\\n zip.extractall(directory)\\n else:\\n print(\\\"Unzipping {} to {}\\\".format(filename, path))\\n zip.extractall(path)\\n except BadZipfile:\\n print(\\\"BAD ZIP: \\\" + filename)\\n try:\\n os.remove(file)\\n except OSError as e: # this would be \\\"except OSError, e:\\\" before Python 2.6\\n if e.errno != errno.ENOENT: # errno.ENOENT = no such file or directory\\n raise # re-raise exception if a different error occured\",\n \"def _unzip(self, data: bytes) -> str:\\n\\n self.log.info(\\\"Unzipping facilities...\\\")\\n z = zipfile.ZipFile(io.BytesIO(data))\\n return z.read('facility.dat').decode('utf-8')\",\n \"def unzip_data(folder, zip_file_basename):\\n # path\\n filename = os.path.join(folder, zip_file_basename + '.zip')\\n new_folder = os.path.join(os.path.dirname(__file__), 'data')\\n if not os.path.isdir(new_folder):\\n os.mkdir(new_folder)\\n # unzip\\n if os.path.isfile(os.path.join(new_folder, zip_file_basename + '.csv')):\\n return 0\\n else:\\n zip_file = zipfile.ZipFile(filename, 'r')\\n zip_file.extractall(new_folder)\\n zip_file.close()\\n basename = os.path.join(new_folder, zip_file_basename)\\n os.rename(basename + '.txt', basename + '.csv')\\n return 1\",\n \"def _uncompress(fname, outdir, msg=msg):\\n import os\\n assert os.access(fname, os.R_OK), \\\"could not access [%s]\\\" % fname\\n fname = os.path.abspath(os.path.realpath(fname))\\n if not os.path.exists(outdir):\\n os.makedirs(outdir)\\n orig_dir = os.getcwd()\\n try:\\n os.chdir(outdir)\\n ext = os.path.splitext(fname)[1][1:] # drop the dot\\n if ext in ('gz', 'bz2'):\\n import tarfile\\n f = tarfile.open(fname, 'r:%s'%ext)\\n f.extractall()\\n else:\\n err = 'extension [%s] not handled (yet?)' % ext\\n msg.error(err)\\n raise ValueError(err)\\n finally:\\n os.chdir(orig_dir)\",\n \"def finalize_zip(zip, filename):\\n zip.close()\\n with open(filename, 'wb') as file:\\n file.write(zipbytes.getvalue())\",\n \"def unzip(local_zip: str, extract_dir: str, pwd: str = None):\\n def get_zipinfo_datetime(zipmember: zipfile.ZipInfo) -> datetime:\\n zt = zipmember.date_time # tuple: year, month, day, hour, min, sec\\n # ZIP uses localtime\\n return datetime(zt[0], zt[1], zt[2], zt[3], zt[4], zt[5], tzinfo=tz.tzlocal())\\n\\n def has_file_changed(zipmember: zipfile.ZipInfo, dst_path):\\n st: os.stat_result = None\\n try:\\n st = os.stat(dst_path, follow_symlinks=False)\\n if st.st_size != zipmember.file_size:\\n return True\\n dst_mtime: datetime = datetime.fromtimestamp(st.st_mtime, tz=tz.tzlocal())\\n src_mtime = get_zipinfo_datetime(zipmember)\\n if dst_mtime != src_mtime:\\n return True\\n except (OSError, ValueError):\\n return True # does not exist\\n return False\\n\\n def make_symlink(zipmember: zipfile.ZipInfo, symlink_location, is_directory):\\n target = zip.read(zipmember, pwd=pwd).decode('utf-8')\\n if os.path.lexists(symlink_location):\\n os.remove(symlink_location)\\n os.symlink(target, symlink_location, target_is_directory=is_directory)\\n\\n unzipped_files: List[Tuple[zipfile.ZipFile, str]] = []\\n\\n with zipfile.ZipFile(local_zip, \\\"r\\\") as zip:\\n for zipmember in zip.infolist():\\n dst_path = os.path.normpath(os.path.join(extract_dir, zipmember.filename))\\n mode = zipmember.external_attr >> 16\\n is_symlink = stat.S_ISLNK(mode)\\n #what = 'DIR' if zipmember.is_dir() else 'FILE'\\n #what = what + ' LINK' if is_symlink else what\\n #print(f'{what} {zipmember.filename} S_IMODE={stat.S_IMODE(mode):0o} S_IFMT={stat.S_IFMT(mode):0o}')\\n if zipmember.is_dir(): # make dirs if needed\\n if is_symlink:\\n make_symlink(zipmember, dst_path, is_directory=True)\\n else:\\n os.makedirs(dst_path, exist_ok=True)\\n elif has_file_changed(zipmember, dst_path): # only extract if file appears to be modified\\n unzipped_files.append((zipmember, dst_path))\\n if is_symlink:\\n make_symlink(zipmember, dst_path, is_directory=False)\\n else:\\n with zip.open(zipmember, pwd=pwd) as src, open(dst_path, \\\"wb\\\") as dst:\\n shutil.copyfileobj(src, dst)\\n for zipmember, dst_path in unzipped_files:\\n # set the correct permissions for files and folders\\n perm = stat.S_IMODE(zipmember.external_attr >> 16)\\n os.chmod(dst_path, perm)\\n # always set the modification date from the zipmember timestamp,\\n # this way we can avoid unnecessarily modifying files and causing full rebuilds\\n time = get_zipinfo_datetime(zipmember)\\n #print(f' | {dst_path} {time}')\\n mtime = time.timestamp()\\n if System.windows:\\n os.utime(dst_path, times=(mtime, mtime))\\n else:\\n os.utime(dst_path, times=(mtime, mtime), follow_symlinks=False)\\n\\n return len(unzipped_files)\",\n \"def uncompress(path, dest=None, remove=True):\\n # assert path.endswith('.zip')\\n prefix, ext = split_if_compressed(path)\\n folder_name = os.path.basename(prefix)\\n file_is_zip = ext == '.zip'\\n root_of_folder = None\\n if ext == '.gz':\\n try:\\n with gzip.open(path, 'rb') as f_in, open(prefix, 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n except Exception as e:\\n remove_file(prefix)\\n remove_file(path)\\n raise e\\n else:\\n try:\\n with zipfile.ZipFile(path, \\\"r\\\") if ext == '.zip' else tarfile.open(path, 'r:*') as archive:\\n if not dest:\\n namelist = sorted(archive.namelist() if file_is_zip else archive.getnames())\\n if namelist[0] == '.':\\n namelist = namelist[1:]\\n namelist = [p[len('./'):] if p.startswith('./') else p for p in namelist]\\n if ext == '.tgz':\\n roots = set(x.split('/')[0] for x in namelist)\\n if len(roots) == 1:\\n root_of_folder = next(iter(roots))\\n else:\\n # only one file, root_of_folder = ''\\n root_of_folder = namelist[0].strip('/') if len(namelist) > 1 else ''\\n if all(f.split('/')[0] == root_of_folder for f in namelist[1:]) or not root_of_folder:\\n dest = os.path.dirname(path) # only one folder, unzip to the same dir\\n else:\\n root_of_folder = None\\n dest = prefix # assume zip contains more than one file or folder\\n print('Extracting {} to {}'.format(path, dest))\\n archive.extractall(dest)\\n if root_of_folder:\\n if root_of_folder != folder_name:\\n # move root to match folder name\\n os.rename(path_join(dest, root_of_folder), path_join(dest, folder_name))\\n dest = path_join(dest, folder_name)\\n elif len(namelist) == 1:\\n dest = path_join(dest, namelist[0])\\n except Exception as e:\\n remove_file(path)\\n if os.path.exists(prefix):\\n if os.path.isfile(prefix):\\n os.remove(prefix)\\n elif os.path.isdir(prefix):\\n shutil.rmtree(prefix)\\n raise e\\n if remove:\\n remove_file(path)\\n return dest\",\n \"def unzip_and_untar(item):\\n print(\\\"Unpacking %s\\\" % item)\\n\\n f = tarfile.open(item, mode=\\\"r\\\")\\n f.extractall(path=\\\"working\\\")\\n f.close()\",\n \"def unarchive(self, target: str, output_target: str = None):\\n\\t\\t\\\"\\\"\\\"An unsucessful decompression will result in a False status, and the header will be None\\\"\\\"\\\"\\n\\t\\ttry:\\n\\t\\t\\ttarget = os.path.abspath(target)\\n\\t\\t\\tprint(f\\\"Decompressing archive {target}\\\")\\n\\t\\t\\tif output_target:\\n\\t\\t\\t\\tprint(f\\\"Using specified output dir {output_target}\\\")\\n\\t\\t\\t\\toutdir = output_target\\n\\t\\t\\telse:\\n\\t\\t\\t\\toutdir = os.path.dirname(target)\\n\\t\\t\\t\\tprint(f\\\"Decompressing archive in place at {outdir}\\\")\\n\\n\\t\\t\\tprint(\\\"Opening archive...\\\")\\n\\t\\t\\twith open(target, \\\"rb+\\\") as archive:\\n\\t\\t\\t\\tprint(f\\\"Reading header...\\\")\\n\\t\\t\\t\\theader = archive.read(HEADER_LENGTH)\\n\\t\\t\\t\\tprint(f\\\"Reading archive contents...\\\")\\n\\t\\t\\t\\tzip_contents = BytesIO(archive.read())\\n\\t\\t\\t\\\"Loading archive...\\\"\\n\\t\\t\\tzip = zipfile.ZipFile(zip_contents, \\\"r\\\", zipfile.ZIP_DEFLATED)\\n\\t\\t\\tprint(\\\"Extracting...\\\")\\n\\t\\t\\tzip.extractall(outdir)\\n\\t\\t\\tprint(\\\"Sucess!\\\")\\n\\t\\t\\tstatus = True\\n\\n\\t\\texcept Exception as e:\\n\\t\\t\\tprint(f\\\"Error decompressing archive {target} - {e}\\\")\\n\\t\\t\\tstatus = False\\n\\t\\t\\theader = None\\n\\n\\t\\treturn (status, header)\",\n \"def unzip(file_loc, extract_loc=None):\\n try:\\n with zipfile.ZipFile(\\n file_loc, \\\"r\\\"\\n ) as file: # opening the zip file using 'zipfile.ZipFile' class\\n print(\\\"Ok\\\")\\n # ZipFile.infolist() returns a list containing all the members of an archive file\\n print(file.infolist())\\n\\n # ZipFile.namelist() returns a list containing all the members with names of an archive file\\n print(file.namelist())\\n\\n # ZipFile.getinfo(path = filepath) returns the information about a member of Zip file.\\n # It raises a KeyError if it doesn't contain the mentioned file\\n print(file.getinfo(file.namelist()[-1]))\\n\\n # If extraction directory not given, extracted to 'data/processed/file_name'\\n if extract_loc == None:\\n base = os.path.dirname(file_loc)\\n folder_name = os.path.basename(base)\\n extract_loc = \\\"data/processed/\\\" + folder_name\\n\\n # ZipFile.extractall(path = filepath, pwd = password) extracts all\\n # the files to current directory\\n file.extractall(path=extract_loc)\\n # after executing check the directory to see extracted files\\n\\n except zipfile.BadZipFile: # if the zip file has any errors then it prints the\\n # error message which you wrote under the 'except' block\\n print(\\\"Error: Zip file is corrupted\\\")\\n\\n except zipfile.LargeZipFile:\\n print(\\\"Error: File size if too large\\\") # if the file size is too large to\\n # open it prints the error you have written\\n except FileNotFoundError:\\n print(\\\"Error: File not found\\\")\",\n \"def unzip_nested_zip(dataset_zip, path_unzip):\\r\\n\\r\\n with zipfile.ZipFile(dataset_zip, \\\"r\\\") as zfile:\\r\\n try:\\r\\n zfile.extractall(path=path_unzip)\\r\\n except OSError as e:\\r\\n logging.warning(\\r\\n \\\"Please check the unzipped files manually. There may be some missed important files.\\\"\\r\\n )\\r\\n logging.warning(\\\"The directory is: \\\" + path_unzip)\\r\\n for root, dirs, files in os.walk(path_unzip):\\r\\n for filename in files:\\r\\n if re.search(r\\\"\\\\.zip$\\\", filename):\\r\\n file_spec = os.path.join(root, filename)\\r\\n new_dir = os.path.join(root, filename[0:-4])\\r\\n unzip_nested_zip(file_spec, new_dir)\",\n \"def unzipArchives(zip_file, password):\\n with ZipFile(zip_file) as archive:\\n archive.extractall(pwd=bytes(password, \\\"utf8\\\"))\",\n \"def unpack(file_path, extraction_path, remove):\\n print(file_path)\\n Archive(file_path).extractall(extraction_path, auto_create_dir=True)\\n # remove original compressed file???\\n if remove is True:\\n os.remove(file_path)\",\n \"def fromZip(self, zip_location,extract_location):\\n zip_file = zipfile.ZipFile(zip_location,'r')\\n zip_file.extractall(extract_location)\",\n \"def Unzip(fullPath,installDirectory, quietMode):\\n with zipfile.ZipFile(fullPath, 'r') as zip:\\n # TODO - check zipfile contents for file number;\\n # should always be 1 binary file unless Hashicorp jumps the shark on the build\\n extractedFile = zip.namelist()[0]\\n if not quietMode:\\n print(\\\"[-] - Extracting (unzip) -> [{0}] ...\\\".format(extractedFile))\\n zip.extractall(installDirectory)\\n return extractedFile\",\n \"def _extract_file(dest_path, root_dir):\\n logger.info(\\\"Unzipping the dataset file.\\\")\\n with zipfile.ZipFile(dest_path, \\\"r\\\") as zip_dir:\\n zip_dir.extractall(root_dir)\",\n \"def unzip_file(zip_path, directory_to_extract_to):\\n ensure_dir(directory_to_extract_to)\\n with zipfile.ZipFile(file=zip_path) as zip_file:\\n # Loop over each file\\n for file in tqdm(iterable=zip_file.namelist(), total=len(zip_file.namelist())):\\n try:\\n zip_file.extract(member=file, path=directory_to_extract_to)\\n except BadZipFile as e:\\n print(e)\",\n \"def extract_file(self, filename):\\n unp_bin = os.path.join(self.modulebin, 'unp')\\n\\n filepath = os.path.dirname(filename)\\n uncompressed = ['fasta', 'fa', 'fastq', 'fq', 'fna', 'h5' ]\\n supported = ['tar.gz', 'tar.bz2', 'bz2', 'gz', 'lz',\\n 'rar', 'tar', 'tgz','zip']\\n for ext in uncompressed:\\n if filename.endswith('.'+ext):\\n return filename\\n for ext in supported:\\n if filename.endswith('.'+ext):\\n extracted_file = filename[:filename.index(ext)-1]\\n if os.path.exists(extracted_file): # Check extracted already\\n return extracted_file\\n logger.info(\\\"Extracting {}...\\\".format(filename))\\n # p = subprocess.Popen([unp_bin, filename],\\n # cwd=filepath, stderr=subprocess.STDOUT)\\n # p.wait()\\n # Hide the \\\"broken pipe\\\" message from unp\\n out = subprocess.Popen([unp_bin, filename],\\n cwd=filepath,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.STDOUT).communicate()[0]\\n if os.path.exists(extracted_file):\\n return extracted_file\\n else:\\n logger.error(\\\"Extraction of {} failed: {}\\\".format(filename, out))\\n raise Exception('Archive structure error')\\n logger.error(\\\"Could not extract {}\\\".format(filename))\\n return filename\",\n \"def unzip() -> None:\\n logger = logging.getLogger(__name__)\\n logger.info('Download the dataset')\\n\\n # define the destination\\n destination = project_dir / 'data' / 'raw'\\n\\n # extract zip\\n zip_file = ZipFile(destination / \\\"original.zip\\\")\\n zip_file.extractall(destination)\",\n \"def x_unzip(xid=None):\\n\\t_loadconfig()\\n\\tnavimport.conf.print_zips()\\n\\n\\txrec = None\\n\\tif xid == None:\\n\\t\\txrec = _prompt_xid(\\\"No to unzip >\\\")\\n\\telse:\\n\\t\\txrec = navimport.conf.get_xplane_zip_info(0)\\n\\n\\tif xrec != None:\\n\\t\\tprint xrec\\n\\n\\t\\ts = \\\"unzip \\\"\\n\\t\\ts += \\\" -d \\\" + navimport.conf.work_dir(\\\"/xplane_unzipped/%s\\\" % xrec['zip_dir'])\\n\\t\\ts += \\\" \\\"\\n\\t\\ts += navimport.conf.work_dir(\\\"/xplane_zips/%s\\\" % xrec['file_name'])\\n\\t\\tlocal(s)\",\n \"def ungzip(path):\\n unzip_path = \\\"\\\".join(path.split(\\\".\\\")[0]+\\\".fna\\\")\\n with gzip.open(path, 'rb') as f_in:\\n with open(unzip_path, 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n os.remove(path)\\n return unzip_path\",\n \"def extract_zip(zip_path: pathlib.Path, output_path: pathlib.Path, flatten: bool = True) -> None:\\n try:\\n with zipfile.ZipFile(zip_path) as zf:\\n if flatten:\\n for member_info in zf.infolist():\\n member_name = member_info.filename\\n if member_name.startswith('__MACOSX'):\\n # Ignore Mac OS X metadata\\n continue\\n\\n member_base_name = os.path.basename(member_name)\\n if not member_base_name:\\n # Skip directories\\n continue\\n\\n member_output_path = output_path / member_base_name\\n\\n with zf.open(member_info) as input_stream, member_output_path.open(\\n 'wb'\\n ) as output_stream:\\n shutil.copyfileobj(input_stream, output_stream)\\n else:\\n zf.extractall(output_path)\\n except zipfile.BadZipfile as e:\\n raise ScoreError(f'Could not read ZIP file \\\"{zip_path.name}\\\": {str(e)}.')\",\n \"def _do_unzip(zipped_file, output_directory):\\n z = zipfile.ZipFile(zipped_file)\\n for path in z.namelist():\\n relative_path = os.path.join(output_directory, path)\\n dirname, dummy = os.path.split(relative_path)\\n try:\\n if relative_path.endswith(os.sep) and not os.path.exists(dirname):\\n os.makedirs(relative_path)\\n elif not os.path.exists(relative_path):\\n dirname = os.path.join(output_directory, os.path.dirname(path))\\n if os.path.dirname(path) and not os.path.exists(dirname):\\n os.makedirs(dirname)\\n fd = open(relative_path, \\\"w\\\")\\n fd.write(z.read(path))\\n fd.close()\\n except IOError, e:\\n raise e\\n return output_directory\",\n \"def main(self, line):\\n # filename with optional destination\\n args = bash(line)\\n if args is None:\\n return\\n elif not (1 <= len(args) <= 2):\\n print \\\"unzip: Usage: unzip file [destination]\\\"\\n else:\\n filename = os.path.abspath(args[0])\\n if not os.path.isfile(filename):\\n print \\\"unzip: %s: No such file\\\" % args[0]\\n else:\\n # PK magic marker check\\n f = open(filename)\\n try:\\n pk_check = f.read(2)\\n except Exception:\\n pk_check = ''\\n finally:\\n f.close()\\n if pk_check != 'PK':\\n print \\\"unzip: %s: does not appear to be a zip file\\\" % args[0]\\n else:\\n if (os.path.basename(filename).lower().endswith('.zip')):\\n altpath = os.path.splitext(os.path.basename(filename))[0]\\n else:\\n altpath = os.path.basename(filename) + '_unzipped'\\n altpath = os.path.join(os.path.dirname(filename), altpath)\\n location = (args[1:2] or [altpath])[0]\\n if (os.path.exists(location)) and not (os.path.isdir(location)):\\n print \\\"unzip: %s: destination is not a directory\\\" % location\\n return\\n elif not os.path.exists(location):\\n os.makedirs(location)\\n zipfp = open(filename, 'rb')\\n try:\\n zipf = zipfile.ZipFile(zipfp)\\n # check for a leading directory common to all files and remove it\\n dirnames = [os.path.join(os.path.dirname(x), '') for x in zipf.namelist()]\\n common_dir = os.path.commonprefix(dirnames or ['/'])\\n # Check to make sure there aren't 2 or more sub directories with the same prefix\\n if not common_dir.endswith('/'):\\n common_dir = os.path.join(os.path.dirname(common_dir), '')\\n for name in zipf.namelist():\\n data = zipf.read(name)\\n fn = name\\n if common_dir:\\n if fn.startswith(common_dir):\\n fn = fn.split(common_dir, 1)[-1]\\n elif fn.startswith('/' + common_dir):\\n fn = fn.split('/' + common_dir, 1)[-1]\\n fn = fn.lstrip('/')\\n fn = os.path.join(location, fn)\\n dirf = os.path.dirname(fn)\\n if not os.path.exists(dirf):\\n os.makedirs(dirf)\\n if fn.endswith('/'):\\n # A directory\\n if not os.path.exists(fn):\\n os.makedirs(fn)\\n else:\\n fp = open(fn, 'wb')\\n try:\\n fp.write(data)\\n finally:\\n fp.close()\\n except Exception:\\n zipfp.close()\\n print \\\"unzip: %s: zip file is corrupt\\\" % args[0]\\n return\\n finally:\\n zipfp.close()\",\n \"def remove_zip(self, file_name, callback=None):\\n\\n if not file_name:\\n return\\n\\n def _cb(*args):\\n if callback:\\n callback(*args)\\n\\n file_name_no_ext = os.path.splitext(file_name)[0]\\n abs_path_file_name = self.get_abs_path(file_name_no_ext)\\n\\n try:\\n # remove folder and contents\\n os.remove(abs_path_file_name)\\n if callback:\\n try:\\n _cb('removed-zip', True)\\n except:\\n pass\\n finally:\\n return\",\n \"def __unzip(self, data):\\n compressed = StringIO.StringIO(data)\\n gzipper = gzip.GzipFile(fileobj=compressed)\\n return gzipper.read()\",\n \"def _unzip(save_path, _, database_name, data_path):\\r\\n print('Extracting {}...'.format(database_name))\\r\\n with zipfile.ZipFile(save_path) as zf:\\r\\n zf.extractall(data_path)\",\n \"def unzip (file, path_unzip = None, outfile = None) :\\n if path_unzip is None : path_unzip = GetPath ()\\n fLOG (\\\"unzip file\\\", file)\\n file = _check_source (file, path_unzip = path_unzip, outfile = outfile)\\n \\n nb = 0\\n while not os.path.exists (file) and nb < 10 :\\n time.sleep(0.5)\\n nb += 1\\n \\n if not os.path.exists (file) :\\n raise FileNotFoundError(file)\\n \\n return file\",\n \"def unzip(source_archive_path, target_path):\\n assert zipfile.is_zipfile(source_archive_path), 'Not a valid ZIP archive'\\n print('Decompressing archive {} into {}'.format(source_archive_path, target_path))\\n with zipfile.ZipFile(source_archive_path) as zf:\\n zf.extractall(target_path)\\n print('Done')\",\n \"def extract_zip(zip_path, target_folder):\\n with zipfile.ZipFile(zip_path) as archive:\\n archive.extractall(target_folder)\",\n \"def extract_zip_contents(zip_file, destination):\\n logging.info(\\\"Extracting ZIP File\\\")\\n if os.path.isfile(zip_file):\\n with zipfile.ZipFile(zip_file, \\\"r\\\") as zip_ref:\\n zip_ref.extractall(destination)\\n else:\\n logging.error(\\\"%s not found.\\\", zip_file)\\n sys.exit(\\\"ZIP is not the filesystem.\\\")\",\n \"def unzip(file_path: str) -> str:\\n destination_directory, zip_file = os.path.split(file_path)\\n extracted_path, _ = os.path.splitext(file_path)\\n\\n if file_path.endswith('tar.gz') or file_path.endswith('tgz'):\\n handle_tar(file_path, 'r:gz', extracted_path, destination_directory)\\n elif file_path.endswith('tar'):\\n handle_tar(file_path, 'r:', extracted_path, destination_directory)\\n return extracted_path\",\n \"def extract_file(self):\\n shutil.unpack_archive(os.path.join(self.root, self.resources), self.root)\\n os.remove(os.path.join(self.root, self.resources))\",\n \"def unzip_archive(archive):\\n tmpdir = os.path.join(tempfile.gettempdir(),\\n os.path.basename(archive))\\n assert tmpdir != archive # That wouldn't work out\\n\\n if os.path.exists(tmpdir):\\n # files are already extracted\\n pass\\n else:\\n if tarfile.is_tarfile(archive):\\n print 'Extracting tarfile ...'\\n with tarfile.open(archive) as tf:\\n tf.extractall(path=tmpdir)\\n elif zipfile.is_zipfile(archive):\\n print 'Extracting zipfile ...'\\n with zipfile.ZipFile(archive) as zf:\\n zf.extractall(path=tmpdir)\\n else:\\n raise ValueError('Unknown file type for %s' % os.path.basename(archive))\\n return tmpdir\",\n \"def unzip_file(zipfilename, unziptodir):\\n\\tunziptodir = unziptodir.replace(cfg.SEP_DCOMM, cfg.SEP_COMM)\\n\\tmake_dirs(unziptodir)\\n\\tzfobj = zipfile.ZipFile(zipfilename)\\n\\tfor name in zfobj.namelist():\\n\\t\\tname = name.replace(cfg.SEP_DCOMM,cfg.SEP_COMM)\\n\\t\\tif name.endswith(cfg.SEP_COMM):\\n\\t\\t\\tos.makedirs(os.path.join(unziptodir, name))\\n\\t\\telse:\\n\\t\\t\\text_filename = os.path.join(unziptodir, name)\\n\\t\\t\\text_filename = ext_filename.replace(cfg.SEP_DCOMM,cfg.SEP_COMM)\\n\\t\\t\\text_dir= os.path.dirname(ext_filename)\\n\\t\\t\\tmake_dirs(ext_dir)\\n\\t\\t\\toutfile = open(ext_filename, 'wb')\\n\\t\\t\\toutfile.write(zfobj.read(name))\\n\\t\\t\\toutfile.close()\",\n \"def unzip_file(path_to_zip_file: str, dir_to_extract_to: str) -> str:\\n with zipfile.ZipFile(path_to_zip_file, 'r') as zip_ref:\\n zip_ref.extractall(dir_to_extract_to)\\n return f'{dir_to_extract_to}/{zip_ref.namelist()[0]}'\",\n \"def unzipper(data_address, target_directory):\\n import zipfile\\n data = \\\"/home/sharoonsaxena/Datasets/dogs-vs-cats.zip\\\"\\n zip_ref = zipfile.ZipFile(data, \\\"r\\\")\\n zip_ref.extractall(\\\"/home/sharoonsaxena/Datasets/extracted/\\\")\\n zip_ref.close()\",\n \"def testZipUrl(self):\\n try:\\n remoteLocator = self.__zipFileUrl\\n # fn = self.__fileU.getFileName(remoteLocator)\\n ok = self.__fileU.isLocal(remoteLocator)\\n self.assertFalse(ok)\\n #\\n lPath = os.path.join(self.__workPath, self.__fileU.getFileName(self.__zipFileUrl))\\n ok = self.__fileU.get(remoteLocator, lPath)\\n self.assertTrue(ok)\\n ok = self.__fileU.exists(lPath)\\n self.assertTrue(ok)\\n ok = self.__fileU.isLocal(lPath)\\n self.assertTrue(ok)\\n tPath = self.__fileU.getFilePath(lPath)\\n self.assertEqual(lPath, tPath)\\n fp = self.__fileU.uncompress(lPath, outputDir=self.__workPath)\\n ok = fp.endswith(\\\"Food_Display_Table.xlsx\\\")\\n self.assertTrue(ok)\\n\\n except Exception as e:\\n logger.exception(\\\"Failing with %s\\\", str(e))\\n self.fail()\",\n \"def unzip_file(filename, location, flatten=True):\\n if not os.path.exists(location):\\n os.makedirs(location)\\n zipfp = open(filename, 'rb')\\n try:\\n zip = zipfile.ZipFile(zipfp)\\n leading = has_leading_dir(zip.namelist()) and flatten\\n for name in zip.namelist():\\n data = zip.read(name)\\n fn = name\\n if leading:\\n fn = split_leading_dir(name)[1]\\n fn = os.path.join(location, fn)\\n dir = os.path.dirname(fn)\\n if not os.path.exists(dir):\\n os.makedirs(dir)\\n if fn.endswith('/') or fn.endswith('\\\\\\\\'):\\n # A directory\\n if not os.path.exists(fn):\\n os.makedirs(fn)\\n else:\\n fp = open(fn, 'wb')\\n try:\\n fp.write(data)\\n finally:\\n fp.close()\\n finally:\\n zipfp.close()\",\n \"def unzip(filename,destination=None,force=False):\\n if not destination:\\n destination=os.path.splitext(os.path.basename(filename))[0]\\n destination = os.path.join(tmpdir,destination)\\n if os.path.exists(destination):\\n if force:\\n shutil.rmtree(destination)\\n else:\\n zipname = filename.split('/')[-1]\\n zip_url = \\\"https://geo.colorado.edu/apps/geolibrary/datasets/{0}\\\".format(zipname)\\n if not os.path.isfile(\\\"/data/static/geolibrary/datasets/{0}\\\".format(zipname)):\\n shutil.copy(filename,\\\"/data/static/geolibrary/datasets/{0}\\\".format(zipname))\\n os.remove(filename)\\n return {\\\"folder\\\": destination,\\\"zipdata\\\":False,\\\"zipurl\\\":zip_url}\\n zip_ref = zipfile.ZipFile(filename,'r')\\n zip_ref.extractall(destination)\\n zipname = filename.split('/')[-1]\\n shutil.copy(filename,\\\"/data/static/geolibrary/datasets/{0}\\\".format(zipname))\\n zip_url = \\\"https://geo.colorado.edu/apps/geolibrary/datasets/{0}\\\".format(zipname)\\n os.remove(filename)\\n return {\\\"folder\\\": destination,\\\"zipdata\\\":True,\\\"zipurl\\\":zip_url}\",\n \"def ZipExtract(zipname, filename, path=os.getcwd()):\\n try:\\n zpf = zipfile.ZipFile(zipname)\\n zpf.extract(filename, path)\\n zpf.close()\\n return True\\n except KeyError:\\n logging.warning('Could not find %s to extract from %s.',\\n (filename, zipname))\\n return False\",\n \"def unzip(checkpoint_path: pathlib.Path, archive_path: pathlib.Path) -> None:\\n checkpoint_path.mkdir(parents=True, exist_ok=True)\\n with ZipFile(archive_path, \\\"r\\\") as zf:\\n zf.extractall(path=checkpoint_path)\\n archive_path.unlink()\",\n \"def extract_zip(file, extract_location):\\n\\n with zipfile.ZipFile(file, \\\"r\\\") as zip_ref:\\n zip_ref.extractall(extract_location)\\n\\n print(f\\\"Extracted file to {extract_location}\\\")\",\n \"def Extract_zip_file (path_to_zip,dir_to_save_into):\\n with zipfile.ZipFile(path_to_zip) as zf:\\n \\n for member in tqdm(zf.namelist(), desc='Extracting'):\\n try:\\n if ('annotations' in member) and (member.endswith('.json')): \\n zf.extract(member, dir_to_save_into)\\n shutil.move(os.path.join(dir_to_save_into,member),dir_to_save_into)\\n if ('train' in member):\\n zf.extract(member, dir_to_save_into)\\n if ('test' in member):\\n zf.extract(member, dir_to_save_into)\\n if ('val' in member):\\n zf.extract(member, dir_to_save_into)\\n except zipfile.error as e:\\n pass\\n\\n #delete zip\\n os.remove(path_to_zip)\\n if(os.path.isdir(os.path.join(dir_to_save_into,'annotations'))):\\n # remove the tmp annotations directory\\n shutil.rmtree(os.path.join(dir_to_save_into,'annotations'))\",\n \"def unzip_citibike_data(zip_dir):\\n# zip_dir = \\\"data/citibike-tripdata-nyc/\\\"\\n# csv_dir = \\\"data/citibike-tripdata-nyc/csv\\\"\\n extension = \\\".zip\\\"\\n\\n # for each zip file in zip_dir extract data\\n for item in os.listdir(zip_dir):\\n if item.endswith(extension):\\n\\n # create zipfile object and extract\\n file_name = zip_dir + item\\n with zipfile.ZipFile(file_name, \\\"r\\\") as zip_ref:\\n zip_ref.extractall(zip_dir)\\n print(item + \\\" done\\\")\",\n \"def uncompress_file(location, decompressor):\\n # FIXME: do not create a sub-directory and instead strip the \\\"compression\\\"\\n # extension such gz, etc. or introspect the archive header to get the file\\n # name when present.\\n assert location\\n assert decompressor\\n\\n warnings = []\\n base_name = fileutils.file_base_name(location)\\n target_location = os.path.join(fileutils.get_temp_dir(\\n prefix='extractcode-extract-'), base_name)\\n\\n with decompressor(location, 'rb') as compressed:\\n with open(target_location, 'wb') as uncompressed:\\n buffer_size = 32 * 1024 * 1024\\n while True:\\n chunk = compressed.read(buffer_size)\\n if not chunk:\\n break\\n uncompressed.write(chunk)\\n\\n if getattr(decompressor, 'has_trailing_garbage', False):\\n warnings.append(location + ': Trailing garbage found and ignored.')\\n\\n return target_location, warnings\",\n \"def extract_file(self):\\n shutil.unpack_archive(os.path.join(\\n self.root, self.resources), f\\\"{self.root}\\\")\\n os.remove(os.path.join(self.root, self.resources))\",\n \"def unzip_file(zip_path: str, output_dir: str) -> UnzipFiles:\\n files = []\\n with zipfile.ZipFile(zip_path, 'r') as zip_ref:\\n zip_ref.extractall(output_dir)\\n for file_path in os.listdir(output_dir):\\n files.append(f\\\"{output_dir}/{file_path}\\\")\\n return files\",\n \"def unzip(zipped):\\n return zip(*zipped)\",\n \"def unzip_item(source_path, destination_path, password):\\n\\n if not destination_path:\\n destination_path = source_path.replace(\\\".zip\\\", \\\"\\\")\\n if not os.path.isdir(destination_path):\\n os.makedirs(destination_path)\\n else:\\n destination_path += \\\"_unzipped\\\"\\n if not os.path.isdir(destination_path):\\n os.makedirs(destination_path)\\n\\n try:\\n with pyzipper.AESZipFile(source_path) as z:\\n members = z.infolist()\\n for i, member in enumerate(members):\\n z.extract(member, destination_path, pwd=password)\\n print(f\\\"Unpacked {member.filename} from archive.\\\")\\n print(f\\\"{source_path} unpacked successfully to {destination_path}.\\\")\\n except Exception:\\n tb = traceback.format_exc()\\n print(\\\"Something went wrong\\\")\\n print(tb)\",\n \"def fetch(self) -> None:\\n archive_path = os.path.join(self._output_dir, self._archive_name)\\n self._download_file(self._parsed_url.original_url, archive_path)\\n try:\\n with zipfile.ZipFile(archive_path, \\\"r\\\") as zip_file:\\n zip_file.extractall(path=self._output_dir)\\n except zipfile.BadZipfile:\\n raise REANAFetcherError(\\\"The provided zip file is not valid\\\")\\n\\n os.remove(archive_path)\\n\\n if not self._discover_workflow_specs():\\n top_level_entries = [\\n os.path.join(self._output_dir, entry)\\n for entry in os.listdir(self._output_dir)\\n ]\\n # Some zip archives contain a single directory with all the files.\\n if len(top_level_entries) == 1 and os.path.isdir(top_level_entries[0]):\\n top_level_dir = top_level_entries[0]\\n # Move all entries inside the top level directory\\n # to the output directory.\\n for entry in os.listdir(top_level_dir):\\n shutil.move(os.path.join(top_level_dir, entry), self._output_dir)\\n os.rmdir(top_level_dir)\",\n \"def untar(input_filename, extract_dir):\\n try:\\n tar_ds = tarfile.open(input_filename)\\n except tarfile.TarError:\\n raise ValueError(\\\"%s is not a tar file\\\" % (input_filename))\\n tar_ds.extractall(path=extract_dir)\\n tar_ds.close()\",\n \"def ExtractZip(zip_path, dest_dir):\\n zip_path = GetWindowsPathWithUNCPrefix(zip_path)\\n dest_dir = GetWindowsPathWithUNCPrefix(dest_dir)\\n with zipfile.ZipFile(zip_path) as zf:\\n for info in zf.infolist():\\n zf.extract(info, dest_dir)\\n # UNC-prefixed paths must be absolute/normalized. See\\n # https://docs.microsoft.com/en-us/windows/desktop/fileio/naming-a-file#maximum-path-length-limitation\\n file_path = os.path.abspath(os.path.join(dest_dir, info.filename))\\n # The Unix st_mode bits (see \\\"man 7 inode\\\") are stored in the upper 16\\n # bits of external_attr. Of those, we set the lower 12 bits, which are the\\n # file mode bits (since the file type bits can't be set by chmod anyway).\\n attrs = info.external_attr >> 16\\n if attrs != 0: # Rumor has it these can be 0 for zips created on Windows.\\n os.chmod(file_path, attrs & 0o7777)\",\n \"def unpack_first(input_filename: str, extract_dir: str) -> str:\\n if not is_archive_file(input_filename):\\n raise AttributeError(\\\"Input_filename must be an archive (ex: .tar.gz, .zip)\\\")\\n if zipfile.is_zipfile(input_filename):\\n return unzip_first(input_filename, extract_dir)\\n else:\\n return untar_first(input_filename, extract_dir)\",\n \"def uncompress(self, compressed):\\n\\t\\traise Exception(NotImplemented)\",\n \"def unzip_file(\\n file_path:str,\\n unzip_dest: str,\\n rgb_raw_zip: bool = False,\\n keep_zip: bool = False\\n) -> None:\\n\\n print('Unzipping: {}'.format(file_path))\\n with zipfile.ZipFile(file_path, 'r') as z:\\n for f in z.filelist:\\n if rgb_raw_zip:\\n if f.filename.endswith('.png'):\\n date, drive, img_idx, _, img_name = f.filename.split('/')\\n if img_idx in ['image_02', 'image_03']:\\n f.filename = os.path.basename(f.filename)\\n z.extract(f, '/'.join([unzip_dest, drive, 'image', img_idx]))\\n else:\\n z.extract(f, unzip_dest)\\n \\n if not keep_zip:\\n os.remove(file_path)\",\n \"def getzip(url, zipfile, unzipdir):\\n done_file = os.path.join(unzipdir, '.'+os.path.basename(zipfile)+'.done')\\n if file_exists(done_file):\\n print('{} already downloaded and extracted; skipping. To reinstall \\\"rm {}\\\"'.format(os.path.basename(zipfile), done_file))\\n else:\\n print('Downloading {} as {}.'.format(url, zipfile))\\n urlretrieve(url, zipfile)\\n print('Extracting {} into {}.'.format(zipfile, unzipdir))\\n with ZipFile(zipfile, 'r') as zip:\\n zip.extractall(unzipdir)\\n os.remove(zipfile)\\n with open(done_file, 'w'):\\n pass\",\n \"def test_unarchive_run(self):\\n pass\",\n \"def ExtractFile(self, dest_dir):\\n self.__get_packed_xwalk_app_template(dest_dir)\\n file_path = os.path.join(dest_dir, self.file_name)\\n tar = tarfile.open(file_path, 'r:gz')\\n tar.extractall(dest_dir)\\n tar.close()\\n file_path = os.path.join(dest_dir, self.file_name)\\n if os.path.isfile(file_path):\\n os.remove(file_path)\",\n \"def unzip_oxygen_files(zip_file):\\n name_main_content = None\\n name_left_menu = None\\n list_img_files_to_save = list()\\n\\n files_unzipped = ZipFile(zip_file)\\n for file_unzipped_name in files_unzipped.namelist():\\n if not file_unzipped_name.startswith('__MACOSX'):\\n if file_unzipped_name.endswith(\\\".jpeg\\\"):\\n list_img_files_to_save.append(file_unzipped_name)\\n elif file_unzipped_name.endswith(\\\".indexList.html\\\"):\\n name_left_menu = file_unzipped_name\\n elif file_unzipped_name.endswith(\\\"_xsd.html\\\"):\\n name_main_content = file_unzipped_name\\n\\n return files_unzipped, name_left_menu, name_main_content, list_img_files_to_save\",\n \"def unzip_first(input_filename: str, extract_dir: str) -> str:\\n with zipfile.ZipFile(input_filename) as zip_file:\\n zip_file_list = zip_file.infolist()\\n zip_index = 0\\n while zip_index < len(zip_file_list) and zip_file_list[zip_index].is_dir():\\n zip_index += 1\\n if zip_index == len(zip_file_list):\\n res = ''\\n else:\\n file_to_extract = zip_file_list[zip_index]\\n zip_file.extract(file_to_extract, extract_dir)\\n res = os.path.join(extract_dir, file_to_extract.filename)\\n return res\",\n \"def close(self):\\n self.myzip.close()\",\n \"def extractSourceToDestination(self, strZipFile: str):\\n with zipfile.ZipFile(strZipFile, 'r') as zipRef:\\n zipRef.extractall(self.strDataDir)\\n\\n os.remove(strZipFile)\",\n \"def unzip_all(input_file: pathlib.Path) -> Tuple[pathlib.Path, tempfile.TemporaryDirectory]:\\n output_temp_dir = tempfile.TemporaryDirectory()\\n output_path = pathlib.Path(output_temp_dir.name)\\n\\n extract_zip(input_file, output_path)\\n\\n return output_path, output_temp_dir\",\n \"def unzipfile(filename, passcode):\\n # Password is SHA-256 hash of the pass code received\\n password = hashlib.sha256(passcode.encode('utf-8')).hexdigest()\\n # Unzip with password\\n with ZipFile(filename) as zf:\\n zf.extractall(pwd=bytes(password, 'utf-8'))\",\n \"def unpack_archive(\\r\\n file_path: str, unpack_path: str = None, remove_if_exists: bool = False\\r\\n) -> Optional[str]:\\r\\n import tarfile\\r\\n import zipfile\\r\\n\\r\\n if not os.path.isfile(file_path):\\r\\n log.warning(\\\"File does not exist: \\\" + file_path)\\r\\n return None\\r\\n\\r\\n if zipfile.is_zipfile(file_path):\\r\\n unpack_path = extract_zip(file_path, unpack_path, remove_if_exists)\\r\\n elif tarfile.is_tarfile(file_path):\\r\\n unpack_path = extract_tar(file_path, unpack_path, remove_if_exists)\\r\\n else:\\r\\n unpack_path = extract_via_patoolib(file_path, unpack_path, remove_if_exists)\\r\\n\\r\\n if unpack_path and os.path.isdir(unpack_path):\\r\\n unpack_folder_name = os.path.basename(unpack_path)\\r\\n if len(os.listdir(unpack_path)) == 1 and unpack_folder_name in os.listdir(\\r\\n unpack_path\\r\\n ):\\r\\n # unpacked folder contains one folder with same name -> move content to higher up folder\\r\\n folder_to_move = os.path.join(unpack_path, unpack_folder_name)\\r\\n files = os.listdir(folder_to_move)\\r\\n for f in files:\\r\\n shutil.move(os.path.join(folder_to_move, f), unpack_path)\\r\\n\\r\\n # Remove empty folder\\r\\n if len(os.listdir(folder_to_move)) == 0:\\r\\n os.rmdir(folder_to_move)\\r\\n else:\\r\\n log.info(\\\"Folder content was moved but folder is not empty.\\\")\\r\\n\\r\\n return unpack_path\",\n \"def unzip_to_temp_dir(zip_file_name):\\n if not zip_file_name or not os.path.exists(zip_file_name):\\n return None\\n\\n zf = zipfile.ZipFile(zip_file_name)\\n\\n if zf.testzip() is not None:\\n return None\\n\\n # Unzip the files into a temporary directory\\n LOGGER.info(\\\"Extracting zipped file: %s\\\" % zip_file_name)\\n tempdir = tempfile.mkdtemp()\\n\\n try:\\n # Create directories that don't exist\\n for zip_name in zf.namelist():\\n # We have no knowledge on the os where the zipped file was\\n # created, so we restrict to zip files with paths without\\n # charactor \\\"\\\\\\\" and \\\"/\\\".\\n name = (zip_name.replace(\\\"\\\\\\\\\\\", os.path.sep).\\n replace(\\\"/\\\", os.path.sep))\\n dest = os.path.join(tempdir, name)\\n if (name.endswith(os.path.sep) and not os.path.exists(dest)):\\n os.mkdir(dest)\\n LOGGER.debug(\\\"Directory %s created.\\\" % dest)\\n\\n # Copy files\\n for zip_name in zf.namelist():\\n # We have no knowledge on the os where the zipped file was\\n # created, so we restrict to zip files with paths without\\n # charactor \\\"\\\\\\\" and \\\"/\\\".\\n name = (zip_name.replace(\\\"\\\\\\\\\\\", os.path.sep).\\n replace(\\\"/\\\", os.path.sep))\\n dest = os.path.join(tempdir, name)\\n if not (name.endswith(os.path.sep)):\\n LOGGER.debug(\\\"Copying file %s......\\\" % dest)\\n outfile = open(dest, 'wb')\\n outfile.write(zf.read(zip_name))\\n outfile.close()\\n LOGGER.debug(\\\"File %s copied.\\\" % dest)\\n\\n LOGGER.info(\\\"Unzipped file can be found at %s\\\" % tempdir)\\n return tempdir\\n\\n except IOError as err:\\n LOGGER.error(\\\"Error in extracting webdriver.xpi: %s\\\" % err)\\n return None\",\n \"def ExtractZip(filename, output_dir, verbose=True):\\n MaybeMakeDirectory(output_dir)\\n\\n # On Linux and Mac, we use the unzip command as it will\\n # handle links and file bits (executable), which is much\\n # easier then trying to do that with ZipInfo options.\\n #\\n # On Windows, try to use 7z if it is installed, otherwise fall back to python\\n # zip module and pray we don't have files larger than 512MB to unzip.\\n unzip_cmd = None\\n if IsLinux():\\n unzip_cmd = ['unzip', '-o']\\n elif IsMac():\\n # The Mac version of unzip does not have LARGE_FILE_SUPPORT until\\n # macOS 10.12, so use ditto instead. The Python ZipFile fallback\\n # used on Windows does not support symbolic links, which makes it\\n # unsuitable for Mac builds.\\n unzip_cmd = ['ditto', '-x', '-k']\\n elif IsWindows() and os.path.exists('C:\\\\\\\\Program Files\\\\\\\\7-Zip\\\\\\\\7z.exe'):\\n unzip_cmd = ['C:\\\\\\\\Program Files\\\\\\\\7-Zip\\\\\\\\7z.exe', 'x', '-y']\\n\\n if unzip_cmd:\\n # Make sure path is absolute before changing directories.\\n filepath = os.path.abspath(filename)\\n saved_dir = os.getcwd()\\n os.chdir(output_dir)\\n command = unzip_cmd + [filepath]\\n # When using ditto, a destination is required.\\n if command[0] == 'ditto':\\n command += ['.']\\n result = RunCommand(command)\\n os.chdir(saved_dir)\\n if result:\\n raise ExternalError('unzip failed: %s => %s' % (str(command), result))\\n else:\\n assert IsWindows()\\n zf = zipfile.ZipFile(filename)\\n # TODO(hinoka): This can be multiprocessed.\\n for name in zf.namelist():\\n if verbose:\\n print 'Extracting %s' % name\\n zf.extract(name, output_dir)\\n if IsMac():\\n # Restore permission bits.\\n os.chmod(os.path.join(output_dir, name),\\n zf.getinfo(name).external_attr >> 16L)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73103154","0.72895694","0.7225283","0.7122829","0.7118282","0.6995884","0.69455594","0.6819211","0.67483294","0.67109257","0.66977614","0.664706","0.66354054","0.6634382","0.6603002","0.65897787","0.6585848","0.6585062","0.6572348","0.65660316","0.6530245","0.6523112","0.6503361","0.64414275","0.6409911","0.6409746","0.6401949","0.6401197","0.6394012","0.6393351","0.6379961","0.63570267","0.63542354","0.63524413","0.6305892","0.62767684","0.6264928","0.6247261","0.6246786","0.6229677","0.62290007","0.6226695","0.61739606","0.61606264","0.61573035","0.61414903","0.6132832","0.6130039","0.6128049","0.61262625","0.6099491","0.6088866","0.60653937","0.6059614","0.6052317","0.6025927","0.6018121","0.60146815","0.59732574","0.5966839","0.5923043","0.58956","0.5894454","0.58886033","0.58875984","0.58857924","0.58780104","0.58651006","0.5849854","0.5846572","0.5845361","0.5835051","0.58278036","0.58186597","0.581216","0.5795237","0.57791936","0.57751125","0.5770973","0.57699114","0.5762765","0.5754161","0.57254434","0.57203066","0.56958514","0.56921655","0.56848377","0.5673297","0.56555766","0.56346875","0.56180555","0.5588762","0.5575736","0.5574444","0.5569999","0.5556847","0.55396193","0.5538172","0.5528578","0.5511258","0.55096316"],"string":"[\n \"0.73103154\",\n \"0.72895694\",\n \"0.7225283\",\n \"0.7122829\",\n \"0.7118282\",\n \"0.6995884\",\n \"0.69455594\",\n \"0.6819211\",\n \"0.67483294\",\n \"0.67109257\",\n \"0.66977614\",\n \"0.664706\",\n \"0.66354054\",\n \"0.6634382\",\n \"0.6603002\",\n \"0.65897787\",\n \"0.6585848\",\n \"0.6585062\",\n \"0.6572348\",\n \"0.65660316\",\n \"0.6530245\",\n \"0.6523112\",\n \"0.6503361\",\n \"0.64414275\",\n \"0.6409911\",\n \"0.6409746\",\n \"0.6401949\",\n \"0.6401197\",\n \"0.6394012\",\n \"0.6393351\",\n \"0.6379961\",\n \"0.63570267\",\n \"0.63542354\",\n \"0.63524413\",\n \"0.6305892\",\n \"0.62767684\",\n \"0.6264928\",\n \"0.6247261\",\n \"0.6246786\",\n \"0.6229677\",\n \"0.62290007\",\n \"0.6226695\",\n \"0.61739606\",\n \"0.61606264\",\n \"0.61573035\",\n \"0.61414903\",\n \"0.6132832\",\n \"0.6130039\",\n \"0.6128049\",\n \"0.61262625\",\n \"0.6099491\",\n \"0.6088866\",\n \"0.60653937\",\n \"0.6059614\",\n \"0.6052317\",\n \"0.6025927\",\n \"0.6018121\",\n \"0.60146815\",\n \"0.59732574\",\n \"0.5966839\",\n \"0.5923043\",\n \"0.58956\",\n \"0.5894454\",\n \"0.58886033\",\n \"0.58875984\",\n \"0.58857924\",\n \"0.58780104\",\n \"0.58651006\",\n \"0.5849854\",\n \"0.5846572\",\n \"0.5845361\",\n \"0.5835051\",\n \"0.58278036\",\n \"0.58186597\",\n \"0.581216\",\n \"0.5795237\",\n \"0.57791936\",\n \"0.57751125\",\n \"0.5770973\",\n \"0.57699114\",\n \"0.5762765\",\n \"0.5754161\",\n \"0.57254434\",\n \"0.57203066\",\n \"0.56958514\",\n \"0.56921655\",\n \"0.56848377\",\n \"0.5673297\",\n \"0.56555766\",\n \"0.56346875\",\n \"0.56180555\",\n \"0.5588762\",\n \"0.5575736\",\n \"0.5574444\",\n \"0.5569999\",\n \"0.5556847\",\n \"0.55396193\",\n \"0.5538172\",\n \"0.5528578\",\n \"0.5511258\",\n \"0.55096316\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83187,"cells":{"query":{"kind":"string","value":"Gzip file if requested."},"document":{"kind":"string","value":"def gzip_and_name(fname, gzip_file=True) -> str:\n if gzip_file:\n with open(fname, \"rb\") as f_in:\n with gzip.open(fname + \".gz\", \"wb\") as f_out:\n shutil.copyfileobj(f_in, f_out)\n os.unlink(fname)\n fname += \".gz\"\n return fname"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def handle_file(self, path):\n\n if path:\n if not matches_patterns(path, self.gzip_patterns):\n return\n\n try:\n original_file = self.open(path, mode=\"rb\")\n except FileNotFoundError:\n pass\n else:\n gzipped_path = \"{0}.gz\".format(path)\n\n if self.exists(gzipped_path):\n self.delete(gzipped_path)\n\n gzipped_file = self._compress(original_file)\n gzipped_path = self.save(gzipped_path, gzipped_file)\n\n return gzipped_path, gzipped_path, True","def _gzip_file(filename):\n gzip_filename = filename + '.gz'\n with open(filename, 'rb') as f_in, gzip.open(gzip_filename, 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)","def save_to_gzip(data,fname):\n with gzip.open(fname + '.gz', 'wb',compresslevel = 9) as f:\n f.write(data.tobytes())","def do_gzip(fileobj):\r\n sio = cStringIO.StringIO()\r\n gzf = gzip.GzipFile(fileobj = sio, mode = \"wb\")\r\n while True:\r\n data = fileobj.read(buf_size)\r\n if not data:\r\n break\r\n gzf.write(data)\r\n gzf.close()\r\n return sio","def test_compress_file_response(self):\n with open(__file__, \"rb\") as file1:\n\n def get_response(req):\n file_resp = FileResponse(file1)\n file_resp[\"Content-Type\"] = \"text/html; charset=UTF-8\"\n return file_resp\n\n r = GZipMiddleware(get_response)(self.req)\n with open(__file__, \"rb\") as file2:\n self.assertEqual(self.decompress(b\"\".join(r)), file2.read())\n self.assertEqual(r.get(\"Content-Encoding\"), \"gzip\")\n self.assertIsNot(r.file_to_stream, file1)","def tar_gz_compress(self, destination):\n\n if destination is not None and isinstance(destination, str):\n with tarfile_open(destination, \"w:gz\") as tar:\n tar.add(self.file)","def is_gzipped(response):\n ctype = response.headers.get('Content-Type', b'').lower()\n cenc = response.headers.get('Content-Encoding', b'').lower()\n return (_is_gzipped(ctype) or\n (_is_octetstream(ctype) and cenc in (b'gzip', b'x-gzip')))","def test_gzip(handler,config):\r\n if not config.gzip:\r\n return False\r\n if not gzip_support:\r\n return False\r\n accept_encoding = handler.headers.get('accept-encoding','').split(',')\r\n accept_encoding = [ x.strip() for x in accept_encoding ]\r\n ctype = handler.resp_headers[\"Content-type\"]\r\n # if gzip is supported by the user agent,\r\n # and if the option gzip in the configuration file is set, \r\n # and content type is text/ or javascript, \r\n # set Content-Encoding to 'gzip' and return True\r\n if 'gzip' in accept_encoding and \\\r\n ctype and (ctype.startswith('text/') or \r\n ctype=='application/x-javascript'):\r\n return True\r\n return False","def _gz(filename):\n \n with open(filename, 'rb') as f:\n return binascii.hexlify(f.read(2)) == b'1f8b'","def open_gz(filename, mode):\n return gzip.open(filename, mode)","def prepare_gz(self, filename, *args, **kwargs):\n\n return '/vsigzip/' + filename, args, kwargs","def open_gzip(fn):\n magic = b'\\x1f\\x8b\\x08'\n l = len(magic)\n with open(fn, 'rb') as f:\n file_start = f.read(l)\n f.seek(0)\n # check if the file is compressed\n if file_start.startswith(magic):\n return gzip.open(fn, 'rt')\n # not compressed\n return open(fn, 'rt')","def gzip_compress(data):\n s = BytesIO()\n g = gzip.GzipFile(fileobj=s, mode='wb')\n g.write(data)\n g.close()\n return s.getvalue()","def isGzippable(self, css=0, js=0, REQUEST=None):\n # force: force http compression even if the browser doesn't send an accept\n # debug: return compression state (0: no, 1: yes, 2: force)\n # css: set this to 1 inside a css file (for later use)\n # js: set this to 1 inside a js file (for later use)\n\n if REQUEST is None:\n REQUEST = self.REQUEST\n use_gzip = self.getGzip()\n if not self.getEnabled():\n use_gzip = 'never'\n\n force = 0\n if use_gzip == 'never':\n enable_compression = 0\n elif use_gzip == 'always':\n enable_compression = 1\n force = 1\n elif use_gzip == 'accept-encoding':\n # compress everything except css and js\n enable_compression = 1\n elif use_gzip == 'accept-encoding+user-agent':\n # gzip compatibility info courtesy of\n # http://httpd.apache.org/docs/2.2/mod/mod_deflate.html\n user_agent = REQUEST.get('HTTP_USER_AGENT', '')\n if user_agent.startswith('Mozilla/4'):\n # Netscape 4.x can't handle gzipped css and js\n enable_compression = (css==0 and js==0)\n # Netscape 4.0.6-4.0.8 has some gzip-related bugs\n if user_agent[len('Mozilla/4.')] in ('6','7','8'):\n enable_compression = 0\n # Some versions of MSIE pretend to be Netscape 4.x but are OK with gzipping\n if user_agent.find('MSIE'):\n enable_compression = 1\n\n return (enable_compression, force, REQUEST.get('HTTP_ACCEPT_ENCODING', '').find('gzip') != -1)","def compress(filename, remove=False):\n import gzip\n fin = open(filename, 'rb')\n fout = gzip.open(filename+'.gz', 'wb')\n fout.writelines(fin)\n fout.close()\n fin.close()\n if remove == True:\n os.remove(filename)\n return","def extracted_file(fname: str):\n new_fname = extract_gzip(fname)\n gzipped = True\n if new_fname is None:\n new_fname = fname\n gzipped = False\n\n try:\n yield new_fname\n finally:\n if gzipped:\n try:\n bgzip_and_name(new_fname)\n except Exception:\n gzip_and_name(new_fname)","def skip_gzip_check(self):\r\n _read_eof = gzip._GzipReader._read_eof\r\n gzip.GzipFile._read_eof = lambda *args, **kwargs: None\r\n yield\r\n gzip.GzipFile._read_eof = _read_eof","def _compress_content(self, content):\n zbuf = io.BytesIO()\n zfile = gzip.GzipFile(mode=\"wb\", compresslevel=9, fileobj=zbuf)\n\n try:\n zfile.write(content.read())\n finally:\n zfile.close()\n\n content.file = zbuf\n content.seek(0)\n\n return content","def isgzip(filename):\n magic_number = b'\\x1f\\x8b\\x08'\n with open(filename, 'rb') as f:\n file_start = f.read(len(magic_number))\n\n if magic_number == file_start:\n return True\n return False","def is_gzip_result(self):\n return self.__aceQLHttpApi.is_gzip_result()","def gzipFile(aFile):\n f_in = open(aFile, \"rb\")\n f_out = gzip.open(aFile + \".gz\", \"wb\")\n f_out.writelines(f_in)\n f_out.close()\n f_in.close()\n os.remove(aFile)","def fixture_filled_gzip_file(non_existing_gzipped_file_path: Path, content: str) -> Path:\n with gzip.open(non_existing_gzipped_file_path, \"wb\") as outfile:\n with io.TextIOWrapper(outfile, encoding=\"utf-8\") as enc:\n enc.write(content)\n return non_existing_gzipped_file_path","def clean_gzip():\n this_dir = os.getcwd()\n os.chdir(\"/data/COHERENT2/data/CrystalChar/raw\")\n all_files = glob.glob(\"./**\", recursive=True)\n for f in all_files:\n if \".gz\" in f and \"tar\" not in f:\n print(f)\n sh(\"gunzip \" + f)\n os.chdir(this_dir)","def _determine_compression_safe_file_opener(self):\n f = gzip.open(self.input_fname, \"r\")\n try:\n f.read(1)\n self._compression_safe_file_opener = gzip.open\n except IOError:\n self._compression_safe_file_opener = open\n finally:\n f.close()","def is_gz_file(f):\n with open(f, \"rb\") as fin:\n return binascii.hexlify(fin.read(2)) == b\"1f8b\"","def extract_gzip(fname: str, outfile: Optional[str] = None) -> Union[str, None]:\n if not outfile:\n outfile = fname[:-3]\n\n if fname.endswith(\".gz\"):\n with gzip.open(fname, \"rb\") as f_in:\n with open(outfile, \"wb\") as f_out:\n shutil.copyfileobj(f_in, f_out)\n os.unlink(fname)\n return outfile","def gzopen(f):\n return gzip.open(f, 'rb') if f.endswith('.gz') else open(f, 'r')","def test_no_compress_compressed_response(self):\n self.resp[\"Content-Encoding\"] = \"deflate\"\n r = GZipMiddleware(self.get_response)(self.req)\n self.assertEqual(r.content, self.compressible_string)\n self.assertEqual(r.get(\"Content-Encoding\"), \"deflate\")","def test_gzip_page(self):\n content = self.unique_gzip()\n self.assertViewBehavior(\n {\"get\": content},\n headers={\"HTTP_ACCEPT_ENCODING\": \"gzip\"},\n status_code=200,\n content=self.compress(content),\n headers_exact={\"Content-Encoding\": \"gzip\"})","def is_gzipped(infile):\n logger = logging.getLogger(__name__)\n\n magic_number = b'\\x1f\\x8b'\n f = open(infile, 'rb')\n with f:\n try:\n assert f.read(2) == magic_number\n except AssertionError as e:\n logger.info(f'{infile} is not gzipped')\n return False\n else:\n logger.debug(f'{infile} is gzipped')\n return True","def zip_file(file_path: str) -> str:\n zip_file_path: str = file_path + \".gz\"\n\n print(f\"Compressing {file_path} into {zip_file_path}\")\n timestamp=path.getmtime(file_path)\n with open(file_path, \"rb\") as read_stream:\n with gzip.open(zip_file_path, \"wb\") as write_stream:\n shutil.copyfileobj(read_stream, write_stream)\n os.utime(zip_file_path, (timestamp,timestamp) )\n\n return zip_file_path","def gzip_assets():\n run('cd %(repo_path)s; python gzip_assets.py' % env)","def test_compress_response(self):\n r = GZipMiddleware(self.get_response)(self.req)\n self.assertEqual(self.decompress(r.content), self.compressible_string)\n self.assertEqual(r.get(\"Content-Encoding\"), \"gzip\")\n self.assertEqual(r.get(\"Content-Length\"), str(len(r.content)))","def maybe_compress(filename, compress_minsize=config.COMPRESS_MINSIZE):\n size = os.path.getsize(filename)\n if size < compress_minsize:\n return open(filename, 'rb'), False\n\n compressed_size, compressed_fobj = compress_file(filename)\n if compressed_size >= size:\n # Compressed file was larger\n log.info(\"%s was larger when compressed; using uncompressed version\", filename)\n return open(filename, 'rb'), False\n\n return compressed_fobj, True","def test_compress_deterministic(self):\n\n class DeterministicGZipMiddleware(GZipMiddleware):\n max_random_bytes = 0\n\n r1 = DeterministicGZipMiddleware(self.get_response)(self.req)\n r2 = DeterministicGZipMiddleware(self.get_response)(self.req)\n self.assertEqual(r1.content, r2.content)\n self.assertEqual(self.get_mtime(r1.content), 0)\n self.assertEqual(self.get_mtime(r2.content), 0)","def write_to_gzip(fname, html_body):\n dir_path = os.path.dirname(fname)\n ensure_dir_exists(dir_path)\n\n with gzip.open(fname, 'wb') as html_file:\n html_file.write(html_body)","def is_gzip(fp):\r\n return open(fp, 'rb').read(2) == '\\x1f\\x8b'","def _serve_asset(self, path, gzipped_asset_bytes, request):\n mimetype = mimetypes.guess_type(path)[0] or 'application/octet-stream'\n return http_util.Respond(\n request, gzipped_asset_bytes, mimetype, content_encoding='gzip')","def org_apache_felix_jetty_gziphandler_enable(self) -> ConfigNodePropertyBoolean:\n return self._org_apache_felix_jetty_gziphandler_enable","def compress_file(map_, name, save_path):\n size = os.path.getsize(save_path)\n temp = subprocess.run([\"gzip\", \"-k\", save_path])\n cr_size = os.path.getsize(save_path+\".gz\")\n try:\n map_[name] = cr_size / size\n except Exception as e:\n print(f\"File: {save_path}, Ori:{size}, Compr:{cr_size}\")\n print(e)\n raise ZeroDivisionError\n temp = subprocess.run([\"rm\", save_path])\n temp = subprocess.run([\"rm\", save_path+\".gz\"])","def test_compress_non_200_response(self):\n self.resp.status_code = 404\n r = GZipMiddleware(self.get_response)(self.req)\n self.assertEqual(self.decompress(r.content), self.compressible_string)\n self.assertEqual(r.get(\"Content-Encoding\"), \"gzip\")","def zipfile(filepath, cleanup=False):\n\tzfile = filepath+\".gz\"\n\twith open(filepath, 'rb') as f_in:\n\t\twith gzip.open(zfile, 'wb') as f_out:\n\t\t\tf_out.writelines(f_in)\t\n\t\n\tif cleanup and file_exists(zfile):\n\t\tos.remove(filepath)\n\treturn zfile","def _gzipencode(content):\n import gzip\n out = BytesIO()\n f = gzip.GzipFile(fileobj=out, mode='w', compresslevel=5)\n f.write(content)\n f.close()\n return out.getvalue()","def ungz(filepath, compression='rb', deletesource=False):\n\n import gzip\n\n with gzip.open(filepath, compression) as f:\n outF = open(filepath[:-3], 'wb')\n outF.write(f.read())\n f.close()\n outF.close()\n if deletesource:\n try:\n os.remove(filepath)\n except:\n raise Exception(\"Could not delete gz archive {0}.\".format(filepath))\n\n return filepath[:-3]","def archive_file(filename, maxsize):#{{{\n if not os.path.exists(filename):\n print(filename, \"does not exist. ignore.\", file=sys.stderr)\n return 1\n\n filesize = os.path.getsize(filename)\n if filesize > maxsize:\n cnt = 0\n zipfile = \"\"\n while 1:\n cnt += 1\n zipfile = \"%s.%d.gz\"%(filename, cnt)\n if not os.path.exists(zipfile):\n break\n # write zip file\n try:\n f_in = open(filename, 'rb')\n except IOError:\n print(\"Failed to read %s\"%(filename), file=sys.stderr)\n return 1\n try:\n f_out = gzip.open(zipfile, 'wb')\n except IOError:\n print(\"Failed to write to %s\"%(zipfile), file=sys.stderr)\n return 1\n\n f_out.writelines(f_in)\n f_out.close()\n f_in.close()\n print(\"%s is archived to %s\"%(filename, zipfile))\n os.remove(filename)\n return 0","def _compress_string(content):\n zbuf = StringIO()\n zfile = GzipFile(mode='wb', compresslevel=6, fileobj=zbuf)\n zfile.write(content)\n zfile.close()\n return zbuf.getvalue()","def gunzip(data):\n return gzip.GzipFile(fileobj=StringIO(data)).read()","def chk_for_gz(filenm):\n import os\n from os.path import expanduser\n filenm = expanduser(filenm)\n\n # File exist?\n if os.path.lexists(filenm):\n chk=True\n return filenm, chk\n\n # .gz already\n if filenm.find('.gz') > 0:\n chk=0\n return filenm, chk\n\n # Add .gz\n if os.path.lexists(filenm+'.gz'):\n chk=True\n return filenm+'.gz', chk\n else:\n chk=False\n return None, chk","def compress_file(path):\n\n process = Popen([\"xz\", \"--compress\", \"--force\", \"--stdout\", path], stdout=PIPE)\n return process.communicate()[0]","def compress_file(path):\n\n process = Popen([\"xz\", \"--compress\", \"--force\", \"--stdout\", path], stdout=PIPE)\n return process.communicate()[0]","def test_no_compress_incompressible_response(self):\n self.resp.content = self.incompressible_string\n r = GZipMiddleware(self.get_response)(self.req)\n self.assertEqual(r.content, self.incompressible_string)\n self.assertIsNone(r.get(\"Content-Encoding\"))","def __init__(self, input_stream, level=9):\n super(Gzip, self).__init__(input_stream)\n\n self._level = level","def gzip_worker(args):\n\tp = multiprocessing.current_process()\n\tprint('Start zipping %s: %s %s' %(args[1], p.name, p.pid))\n\tpath = args[0]\n\tfilename = args[1]\n\tassert os.path.splitext(filename)[1] == '.fastq', '%s is not a fastq file' %filename \n\t\n\tcall = 'gzip -c ' + os.path.join(path, filename) + ' > ' + os.path.join(path, filename) + '.gz'\n\tsubprocess.call(call, shell=True)\n\tprint('Completed zipping %s: %s %s' %(filename, p.name, p.pid))","def gunzip_file(gzip_file, base_dir):\n full_gzip_file = os.path.join(base_dir, gzip_file)\n if not gzip_file.endswith(\".gz\"):\n return gzip_file\n gunzip_file = full_gzip_file.replace(\".gz\", \"\")\n with gzip.open(full_gzip_file, 'rb') as f_in:\n with open(gunzip_file, 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)\n # Now that file is extracted. Remove file\n os.remove(full_gzip_file)\n\n return os.path.basename(gunzip_file)","def compress_stream(src, dst):\n with gzip.GzipFile(fileobj=dst, mode='wb') as gz:\n for block in iterfile(src):\n gz.write(block)","def test_decompress_file():\n gz_file = os.path.join(\n tempfile.gettempdir(),\n \"jade-unit-test-file.gz\",\n )\n with gzip.open(gz_file, \"wb\") as f:\n f.write(b\"Hello World\")\n assert os.path.exists(gz_file)\n\n new_file = decompress_file(gz_file)\n assert os.path.exists(new_file)\n with open(new_file, \"r\") as f:\n data = f.read()\n assert data == \"Hello World\"\n\n if os.path.exists(gz_file):\n os.remove(gz_file)\n\n if os.path.exists(new_file):\n os.remove(new_file)","def gunzip_file(gz_path, new_path):\n print(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def compressIfNeeded(self):\n\n if self._mode == \"zip\":\n zip_folder(self._rootExportPath, self.getZipArchiveFullPath())","def uncompress_gzip(location, target_dir):\n\n return uncompress(location, target_dir, decompressor=gzip.GzipFile)","def test_gzip_file_no_extension(self):\n # Write the data to a file\n temp_file = tempfile.NamedTemporaryFile()\n with gzip.open(temp_file.name, 'wb') as out:\n for item in self.data:\n serialzed = json.dumps(item).encode()\n out.write(serialzed + b'\\n')\n\n # Load from file, ensure it is correct\n actual_data = []\n with JsonlReader(temp_file.name) as f:\n for item in f:\n actual_data.append(item)\n self.assertEqual(self.data, actual_data)","def _check_zip_file (filename, path_unzip, outfile) :\n assert path_unzip is not None\n file,ext = os.path.splitext (filename)\n ext = ext.lower ()\n if ext == \".gz\" :\n \n import gzip\n \n if outfile is None :\n dest = filename.split (\"!\")\n dest = dest [ len(dest)-1 ]\n ext = os.path.splitext (dest) [1]\n dest = dest.replace (ext, \".txt\")\n path = os.path.split (filename)\n path = \"/\".join (path [:len (path)-1])\n dest = path + \"/\" + dest\n else :\n dest = outfile\n \n if not os.path.exists (dest) :\n file = gzip.GzipFile (filename, \"r\")\n if outfile is None :\n dest = os.path.split (dest) [1]\n dest = os.path.join (path_unzip, dest)\n \n if os.path.exists (dest) :\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\n if st2 > st1 : \n fLOG (\"ungzipping file (already done)\", dest)\n return dest\n \n fLOG (\"ungzipping file\", dest)\n f = open (dest, \"w\")\n data = file.read (2**27)\n size = 0\n while len (data) > 0 :\n size += len (data)\n fLOG (\"ungzipping \", size, \"bytes\")\n if isinstance (data, bytes) : f.write (bytes.decode (data))\n else : f.write (data)\n data = file.read (2**27)\n f.close ()\n file.close ()\n \n return dest\n \n if ext == \".zip\" :\n \n import zipfile\n try :\n file = zipfile.ZipFile (filename, \"r\")\n except Exception as e :\n fLOG (\"problem with \", filename)\n raise e\n \n if len (file.infolist()) != 1:\n if outfile is not None :\n raise PQHException (\"the archive contains %d files and not one as you expected by filling outfile\" % len (file.infolist()))\n fLOG (\"unzip file (multiple) \", filename)\n #message = \"\\n\".join ([ fi.filename for fi in file.infolist() ] )\n #raise Exception.YstException(\"ColumnInfoSet.load_from_file: file %s contains no file or more than one file\\n\" + message)\n folder = os.path.split (filename) [0]\n todo = 0\n _zip7_path = r\"c:\\Program Files\\7-Zip\"\n zip7 = os.path.exists (_zip7_path)\n wait = [ ]\n for info in file.infolist () :\n fileinside = info.filename\n dest = os.path.join (folder, fileinside)\n if not os.path.exists (dest) :\n fol = os.path.split (dest) [0]\n if not os.path.exists (fol) : os.makedirs (fol)\n if os.path.exists (dest) :\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\n if st2 > st1 : \n continue\n \n if not sys.platform.startswith(\"win\") or not zip7 :\n data = file.read (fileinside)\n dest = os.path.split (dest) [1]\n dest = os.path.join (path_unzip, dest)\n fLOG (\"unzipping file\", dest)\n wait.append(dest)\n f = open (dest, \"w\")\n if isinstance (data, bytes) :\n f.write (str (data))\n else :\n f.write (data)\n f.close ()\n else :\n todo += 1\n \n if todo > 0 and zip7 :\n dest = os.path.realpath (path_unzip)\n cmd = '\"' + _zip7_path + '\\\\7z.exe\" e -y -o\"%s\" \"%s\"' % (dest, os.path.realpath (filename)) \n out,err = run_cmd (cmd, wait = True)\n if len (err) > 0 : raise PQHException (\"command {0} failed\\n{1}\".format(cmd,err))\n if \"Error\" in out : raise PQHException (\"command {0} failed\\n{1}\".format(cmd,out))\n else :\n dest = path_unzip\n \n file.close ()\n \n ch = False\n while not ch :\n ch = True\n for a in wait :\n if not os.path.exists(a) : \n ch = False\n break\n time.sleep(0.5)\n \n return dest\n \n else :\n for info in file.infolist () :\n fileinside = info.filename\n \n path = os.path.split (filename)\n dest = outfile if outfile is not None else path [0] + \"/\" + fileinside\n if not os.path.exists (dest) :\n data = file.read (fileinside)\n if outfile is None :\n dest = os.path.split (dest) [1]\n dest = os.path.join (path_unzip, dest)\n \n if os.path.exists (dest) :\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\n if st2 > st1 : \n fLOG(\"unzipping one file (already done)\", dest)\n return dest\n \n fLOG(\"unzipping one file\", dest)\n f = open (dest, \"w\")\n if isinstance (data, bytes) :\n f.write (bytes.decode (data))\n else :\n f.write (data)\n f.close ()\n file.close ()\n return dest\n \n return filename","def create_compressed_file(self):\n\t\tself._compressed_file_name = 'c_' + self.file_name\n\t\tself._compressed_save_path = self.full_path.replace(self.file_name, self._compressed_file_name)\n\t\tself._is_png = 'png' in self.file_extension\n\t\tself._is_jpg = 'jpg' in self.file_extension\n\n\t\timage = Image.open(self.full_path)\n\n\t\tif self._is_png:\n\t\t\timage.save(self._compressed_save_path, quality=85, optimize=False, compress_level=9)\n\t\telif self._is_jpg:\n\t\t\timage.save(self._compressed_save_path, quality=85, progressive=False)\n\t\telse:\n\t\t\tprint('Non-recognized asset format!!')\n\t\t\texit()\n\n\t\tself._compressed_file_size = ufo.get_file_size_in_bytes(self._compressed_save_path)\n\n\n\t\ttransfer_path = self._compressed_save_path.replace('c_' + self.file_name, self.file_name).replace('/configuration_files/', '/quasar_site_django/')\n\t\tufo.copy_file_to_path(self._compressed_save_path, transfer_path)","def gunzip_file(gz_path, new_path):\n logging.info(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def _newfile(counter):\n name = '%s/sitemap-%s.xml.gz' % (settings.SITEMAPS_DIR,\n counter)\n fp = gzip.open(name, 'wb')\n fp.write(\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\\n\"\"\")\n return fp","def __handle_compression(self, x):\n if self.__compress:\n return zlib.compress(x)\n return x","def compressFile(source, target):\n data = cake.filesys.readFile(source)\n try:\n data = zlib.compress(data, 1)\n except zlib.error, e:\n raise EnvironmentError(str(e))\n cake.filesys.writeFile(target, data)","def open_gzipped(infile, mode='rt'):\n import gzip\n import bz2\n if mode.startswith('r'):\n tmode = 'rt'\n bmode = 'r'\n elif mode.startswith('w'):\n tmode = 'wt'\n bmode = 'w'\n elif mode.startswith('a'):\n tmode = 'at'\n bmode = 'a'\n if hasattr(infile, 'write'):\n return infile\n if isinstance(infile, str):\n if infile.endswith('.gz'):\n return gzip.open(infile, tmode)\n if infile.endswith('.bz2'):\n if hasattr(bz2, 'open'):\n return bz2.open(infile, tmode)\n else:\n return bz2.BZ2File(infile, bmode)\n return open(infile, tmode)","def is_zip(filepath):\n\treturn os.path.splitext(filepath)[1] == '.gz'","def gunzip_file(gz_path, new_path):\n print(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def to_gzip_response(response, gzip_flag):\n headers = \"Content-Type: application/json\\n\"\n if gzip_flag:\n out = StringIO.StringIO()\n with gzip.GzipFile(fileobj=out, mode=\"w\") as f:\n f.write(response)\n headers += \"Vary: Accept-Encoding\\n\"\n headers += \"Content-Encoding: gzip\\r\\n\\r\\n\"\n response = out.getvalue()\n del out\n else:\n headers += \"\\r\\n\"\n return [response, headers]","def compress():\n run_manage_cmd('compress_assets')","def test_no_compress_short_response(self):\n self.resp.content = self.short_string\n r = GZipMiddleware(self.get_response)(self.req)\n self.assertEqual(r.content, self.short_string)\n self.assertIsNone(r.get(\"Content-Encoding\"))","def org_apache_felix_jetty_gzip_sync_flush(self) -> ConfigNodePropertyBoolean:\n return self._org_apache_felix_jetty_gzip_sync_flush","def read_gzip_file_content(self, s3_path):\n s3_object = self._get_s3_object(s3_path)\n\n bytestream = BytesIO(s3_object.get()['Body'].read())\n\n gzip_file = GzipFile(mode=\"rb\", fileobj=bytestream)\n output = gzip_file.read().decode(\"utf-8\")\n\n return output","def read_gzipped(response):\r\n if response.info().get('Content-Encoding') == 'gzip':\r\n with io.BytesIO(response.read()) as buf:\r\n with gzip.GzipFile(fileobj=buf) as unzipped:\r\n data = unzipped.read()\r\n else:\r\n data = response.read()\r\n return data","def de_gzip(data):\n cmps = StringIO.StringIO(data)\n gzipper = gzip.GzipFile(fileobj=cmps)\n return gzipper.read()","def de_gzip(data):\n cmps = StringIO.StringIO(data)\n gzipper = gzip.GzipFile(fileobj=cmps)\n return gzipper.read()","def gunzip_file(gz_path, new_path):\n print(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def write_header_in_gz_file(self):\r\n if self.arguments['--out']:\r\n self.file = gzip.open(self.arguments['--out'] + '.gz', \"w+b\")\r\n self.file.write(self.version.encode('utf-8'))\r\n for list_item in self.list_of_header_objects:\r\n self.file.write(list_item.line.encode('utf-8'))\r\n self.file.write(self.body_header_line.line)\r\n self.file.close()\r\n else:\r\n for list_item in self.list_of_header_objects:\r\n print(list_item.line.encode('utf-8'))","def _downloadWGS(WGSurl) :\n gzipContent = urllib2.urlopen(WGSurl).read()\n gzipFile = StringIO.StringIO(gzipContent)\n o = gzip.GzipFile(fileobj = gzipFile)\n output = None\n try :\n output = o.read()\n except IOError as e:\n print(e)\n o.close()\n return output","def gzipPage(page):\n #if not hasattr(page,\"info\"):\n # return(\"\")\n data = object()\n # Check if content encoding is gzip\n if page.info().get('Content-Encoding') == 'gzip':\n buf = StringIO(page.read())\n f = gzip.GzipFile(fileobj=buf)\n data = f.read()\n else :\n data = page.read()\n return(data)","def gzip_files(topDir, afni_file,localizerfile):\n\n print 'GZIPPING FILES...'\n\n command1 = \"gzip %s*BRIK\" % (topDir)\n command2 = \"gzip %s*HEAD\" % (topDir)\n command3 = \"gzip %s%s/pb00*\" % (topDir,afni_file)\n command4 = \"gzip %s%s/errts*\" % (topDir,afni_file)\n command5 = \"gzip %s%s/fitts*\" % (topDir,afni_file)\n command6 = \"gzip %s%s/*al*\" % (topDir,afni_file)\n command7 = \"gzip %s%s/*ns*\" % (topDir,afni_file)\n command8 = \"gzip %s%s/all_runs*\" % (topDir,afni_file)\n command9 = \"gzip %s%s/*mask*\" % (topDir,afni_file)\n command10 = \"gzip %s*nii\" % (topDir)\n command11 = \"gzip %s%s/pb01*\" % (topDir,afni_file)\n command12 = \"gzip %s%s/pb03*\" % (topDir,afni_file)\n command13 = \"gzip %s%s/pb02*\" % (topDir,afni_file)\n\n os.system(command1)\n os.system(command2)\n os.system(command3)\n os.system(command4)\n os.system(command5)\n os.system(command6)\n os.system(command7)\n os.system(command8)\n #os.system(command9)\n os.system(command10)\n os.system(command11)\n try:\n os.system(command12)\n except:\n print 'Could not gzip pb03 files'\n\n if localizerfile == 'facescene_loc':\n os.system(command13)","def zip_compress(self, destination):\n\n if destination is not None and isinstance(destination, str):\n with ZipFile(destination, \"w\") as thezip:\n thezip.write(self.file)","def test_file_gzip_utf8_readwrite(self):\n if state.py2:\n FileWriter(self.unicode_path).gzip(self.unicode_string)\n gzip_contents = FileReader(self.unicode_path + \".gz\").read_gzip() # when read without explicit utf-8 decoding, the strings will not match\n self.assertNotEqual(gzip_contents, self.unicode_string)\n elif state.py3:\n FileWriter(self.unicode_path).gzip(bytes(self.unicode_string, 'utf-8'))\n gzip_contents = FileReader(self.unicode_path + \".gz\").read_gzip() # when read without explicit utf-8 decoding, the strings will not match\n self.assertNotEqual(gzip_contents, self.unicode_string)","def test_args_gzip(testapp):\n\n timepoint = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\n stream = sitemap.process(\n testapp,\n [\n holocron.WebSiteItem(\n {\n \"destination\": pathlib.Path(\"1.html\"),\n \"updated\": timepoint,\n \"baseurl\": testapp.metadata[\"url\"],\n }\n )\n ],\n gzip=True,\n )\n\n assert isinstance(stream, collections.abc.Iterable)\n assert list(stream) == [\n holocron.WebSiteItem(\n {\n \"destination\": pathlib.Path(\"1.html\"),\n \"updated\": timepoint,\n \"baseurl\": testapp.metadata[\"url\"],\n }\n ),\n holocron.WebSiteItem(\n {\n \"source\": pathlib.Path(\"sitemap://sitemap.xml.gz\"),\n \"destination\": pathlib.Path(\"sitemap.xml.gz\"),\n \"content\": _pytest_xmlasdict(\n {\n \"urlset\": {\n \"@xmlns\": \"http://www.sitemaps.org/schemas/sitemap/0.9\",\n \"url\": {\n \"loc\": \"https://yoda.ua/1.html\",\n \"lastmod\": \"1970-01-01T00:00:00+00:00\",\n },\n }\n },\n ungzip=True,\n ),\n \"baseurl\": testapp.metadata[\"url\"],\n }\n ),\n ]","def bgzip_and_name(fname, bgzip_file=True) -> str:\n if bgzip_file:\n ret = sp.check_call(f\"bgzip {fname}\", shell=True)\n fname += \".gz\"\n if ret != 0:\n raise Exception(f\"Error bgzipping genome {fname}. Is pysam installed?\")\n return fname","def gz_tar(full_prefix):\n tarfile = os.path.join(outputdir, full_prefix + '.tar')\n try:\n with open(tarfile, 'rb') as f_in, gzip.open(tarfile + '.gz', 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)\n os.remove(tarfile)\n except Exception as e:\n log.error(\"Tarfile {0} was not generated. Module(s) run collected no info?\".format(tarfile))\n log.error(e)\n\n return tarfile + '.gz'","def compressBuffer(self, buffer):\r\n # http://jython.xhaus.com/http-compression-in-python-and-jython/\r\n zbuf = cStringIO.StringIO()\r\n zfile = gzip.GzipFile(mode='wb', fileobj=zbuf, compresslevel=9)\r\n zfile.write(buffer)\r\n zfile.close()\r\n return zbuf.getvalue()","def are_files_gzipped(raw_files):\n files_are_gzipped = None\n for file_name in raw_files:\n if re.search(r\"\\.gz$\", file_name) is not None:\n if files_are_gzipped is False:\n raise Exception(\n \"It seems one file is compressed and the \"\n \"other is \"\n \"not:\\n{}\".format(\"\\n\".join(raw_files))\n )\n files_are_gzipped = True\n else:\n if files_are_gzipped:\n raise Exception(\n \"It seems one file is compressed and the \"\n \"other is \"\n \"not:\\n{}\".format(\"\\n\".join(raw_files))\n )\n files_are_gzipped = False\n return files_are_gzipped","def _extract_gz(src, dst):\n assert src.endswith(\".gz\"), \"{} is not a valid .gz file.\".format(src)\n assert os.path.exists(src), \"{} does not exist.\".format(src)\n\n with gzip.open(src, \"rb\") as f_src:\n # xxx.postfix.gz --> xxx.postfix\n file_name = os.path.basename(src)[:-3]\n with open(os.path.join(dst, file_name), \"wb\") as f_dst:\n shutil.copyfileobj(f_src, f_dst)","def org_apache_felix_jetty_gzip_compression_level(self, org_apache_felix_jetty_gzip_compression_level: ConfigNodePropertyInteger):\n\n self._org_apache_felix_jetty_gzip_compression_level = org_apache_felix_jetty_gzip_compression_level","def write_body_in_gz_file(self):\r\n if self.arguments['--out']:\r\n self.file = gzip.open(self.arguments['--out'] + '.gz', \"a+b\")\r\n for list_item in self.list_of_body_objects:\r\n self.file.write(list_item.line.encode('utf-8'))\r\n self.file.close()\r\n else:\r\n for list_item in self.list_of_body_objects:\r\n print(list_item.line.encode('utf-8'))\r\n\r\n self.file.close()","def save_as_pickle_gz(df, filepath):\n\n print('saving file:', filepath)\n df.to_pickle(filepath, compression='gzip')","def org_apache_felix_jetty_gzip_compression_level(self) -> ConfigNodePropertyInteger:\n return self._org_apache_felix_jetty_gzip_compression_level","def compress_file(compression, pretty, src, dst):\n str_tail = \"sed 1d\"\n str_cleanup = \";exit\"\n if pretty:\n str_tail = \"tail -n+2\"\n str_cleanup = \";rm ~;exit\"\n if \"lzma\" == compression:\n command = [\"xz\", \"--format=lzma\", \"--lzma1=preset=9e,lc=1,lp=0,pb=0\", \"--stdout\"]\n header = \"HOME=/tmp/i;%s $0|lzcat>~;chmod +x ~;~%s\" % (str_tail, str_cleanup)\n elif \"raw\" == compression:\n command = [\"xz\", \"-9\", \"--extreme\", \"--format=raw\", \"--stdout\"]\n header = \"HOME=/tmp/i;%s $0|xzcat -F raw>~;chmod +x ~;~%s\" % (str_tail, str_cleanup)\n elif \"xz\" == compression:\n command = [\"xz\", \"--format=xz\", \"--lzma2=preset=9e,lc=1,pb=0\", \"--stdout\"]\n header = \"HOME=/tmp/i;%s $0|xzcat>~;chmod +x ~;~%s\" % (str_tail, str_cleanup)\n else:\n raise RuntimeError(\"unknown compression format '%s'\" % compression)\n (compressed, se) = run_command(command + [src], False)\n wfd = open(dst, \"wb\")\n wfd.write((header + \"\\n\").encode())\n wfd.write(compressed)\n wfd.close()\n make_executable(dst)\n print(\"Wrote '%s': %i bytes\" % (dst, os.path.getsize(dst)))","def test_random_bytes(self):\n with mock.patch(\n \"django.utils.text.secrets.randbelow\", autospec=True, return_value=3\n ):\n r = GZipMiddleware(self.get_response)(self.req)\n # The fourth byte of a gzip stream contains flags.\n self.assertEqual(r.content[3], gzip.FNAME)\n # A 3 byte filename \"aaa\" and a null byte are added.\n self.assertEqual(r.content[10:14], b\"aaa\\x00\")\n self.assertEqual(self.decompress(r.content), self.compressible_string)","def data_zip(self, data):\n stringio = StringIO.StringIO()\n gzip_file = gzip.GzipFile(fileobj=stringio, mode='wb')\n gzip_file.write(data)\n gzip_file.close()\n return stringio.getvalue()","def vcf_compress(fn):\n ret = cmd_exe(f\"vcf-sort {fn} | bgzip > {fn}.gz && tabix {fn}.gz\")","def test_gzip_page_disabled(self):\n content = self.unique_gzip()\n self.assertViewBehavior(\n {\"gzip_page\": False, \"get\": content},\n headers={\"HTTP_ACCEPT_ENCODING\": \"gzip\"},\n status_code=200,\n content=content,\n headers_exclude=\"Content-Encoding\")","def _files_from_json(self, file_json):\n self.compressed_file_json = zlib.compress(json.dumps(file_json).encode('utf-8'))\n self.compression_algorithm = 'gzip'\n self.compressed_content_hash = hashlib.sha256(self.compressed_file_json).hexdigest()"],"string":"[\n \"def handle_file(self, path):\\n\\n if path:\\n if not matches_patterns(path, self.gzip_patterns):\\n return\\n\\n try:\\n original_file = self.open(path, mode=\\\"rb\\\")\\n except FileNotFoundError:\\n pass\\n else:\\n gzipped_path = \\\"{0}.gz\\\".format(path)\\n\\n if self.exists(gzipped_path):\\n self.delete(gzipped_path)\\n\\n gzipped_file = self._compress(original_file)\\n gzipped_path = self.save(gzipped_path, gzipped_file)\\n\\n return gzipped_path, gzipped_path, True\",\n \"def _gzip_file(filename):\\n gzip_filename = filename + '.gz'\\n with open(filename, 'rb') as f_in, gzip.open(gzip_filename, 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\",\n \"def save_to_gzip(data,fname):\\n with gzip.open(fname + '.gz', 'wb',compresslevel = 9) as f:\\n f.write(data.tobytes())\",\n \"def do_gzip(fileobj):\\r\\n sio = cStringIO.StringIO()\\r\\n gzf = gzip.GzipFile(fileobj = sio, mode = \\\"wb\\\")\\r\\n while True:\\r\\n data = fileobj.read(buf_size)\\r\\n if not data:\\r\\n break\\r\\n gzf.write(data)\\r\\n gzf.close()\\r\\n return sio\",\n \"def test_compress_file_response(self):\\n with open(__file__, \\\"rb\\\") as file1:\\n\\n def get_response(req):\\n file_resp = FileResponse(file1)\\n file_resp[\\\"Content-Type\\\"] = \\\"text/html; charset=UTF-8\\\"\\n return file_resp\\n\\n r = GZipMiddleware(get_response)(self.req)\\n with open(__file__, \\\"rb\\\") as file2:\\n self.assertEqual(self.decompress(b\\\"\\\".join(r)), file2.read())\\n self.assertEqual(r.get(\\\"Content-Encoding\\\"), \\\"gzip\\\")\\n self.assertIsNot(r.file_to_stream, file1)\",\n \"def tar_gz_compress(self, destination):\\n\\n if destination is not None and isinstance(destination, str):\\n with tarfile_open(destination, \\\"w:gz\\\") as tar:\\n tar.add(self.file)\",\n \"def is_gzipped(response):\\n ctype = response.headers.get('Content-Type', b'').lower()\\n cenc = response.headers.get('Content-Encoding', b'').lower()\\n return (_is_gzipped(ctype) or\\n (_is_octetstream(ctype) and cenc in (b'gzip', b'x-gzip')))\",\n \"def test_gzip(handler,config):\\r\\n if not config.gzip:\\r\\n return False\\r\\n if not gzip_support:\\r\\n return False\\r\\n accept_encoding = handler.headers.get('accept-encoding','').split(',')\\r\\n accept_encoding = [ x.strip() for x in accept_encoding ]\\r\\n ctype = handler.resp_headers[\\\"Content-type\\\"]\\r\\n # if gzip is supported by the user agent,\\r\\n # and if the option gzip in the configuration file is set, \\r\\n # and content type is text/ or javascript, \\r\\n # set Content-Encoding to 'gzip' and return True\\r\\n if 'gzip' in accept_encoding and \\\\\\r\\n ctype and (ctype.startswith('text/') or \\r\\n ctype=='application/x-javascript'):\\r\\n return True\\r\\n return False\",\n \"def _gz(filename):\\n \\n with open(filename, 'rb') as f:\\n return binascii.hexlify(f.read(2)) == b'1f8b'\",\n \"def open_gz(filename, mode):\\n return gzip.open(filename, mode)\",\n \"def prepare_gz(self, filename, *args, **kwargs):\\n\\n return '/vsigzip/' + filename, args, kwargs\",\n \"def open_gzip(fn):\\n magic = b'\\\\x1f\\\\x8b\\\\x08'\\n l = len(magic)\\n with open(fn, 'rb') as f:\\n file_start = f.read(l)\\n f.seek(0)\\n # check if the file is compressed\\n if file_start.startswith(magic):\\n return gzip.open(fn, 'rt')\\n # not compressed\\n return open(fn, 'rt')\",\n \"def gzip_compress(data):\\n s = BytesIO()\\n g = gzip.GzipFile(fileobj=s, mode='wb')\\n g.write(data)\\n g.close()\\n return s.getvalue()\",\n \"def isGzippable(self, css=0, js=0, REQUEST=None):\\n # force: force http compression even if the browser doesn't send an accept\\n # debug: return compression state (0: no, 1: yes, 2: force)\\n # css: set this to 1 inside a css file (for later use)\\n # js: set this to 1 inside a js file (for later use)\\n\\n if REQUEST is None:\\n REQUEST = self.REQUEST\\n use_gzip = self.getGzip()\\n if not self.getEnabled():\\n use_gzip = 'never'\\n\\n force = 0\\n if use_gzip == 'never':\\n enable_compression = 0\\n elif use_gzip == 'always':\\n enable_compression = 1\\n force = 1\\n elif use_gzip == 'accept-encoding':\\n # compress everything except css and js\\n enable_compression = 1\\n elif use_gzip == 'accept-encoding+user-agent':\\n # gzip compatibility info courtesy of\\n # http://httpd.apache.org/docs/2.2/mod/mod_deflate.html\\n user_agent = REQUEST.get('HTTP_USER_AGENT', '')\\n if user_agent.startswith('Mozilla/4'):\\n # Netscape 4.x can't handle gzipped css and js\\n enable_compression = (css==0 and js==0)\\n # Netscape 4.0.6-4.0.8 has some gzip-related bugs\\n if user_agent[len('Mozilla/4.')] in ('6','7','8'):\\n enable_compression = 0\\n # Some versions of MSIE pretend to be Netscape 4.x but are OK with gzipping\\n if user_agent.find('MSIE'):\\n enable_compression = 1\\n\\n return (enable_compression, force, REQUEST.get('HTTP_ACCEPT_ENCODING', '').find('gzip') != -1)\",\n \"def compress(filename, remove=False):\\n import gzip\\n fin = open(filename, 'rb')\\n fout = gzip.open(filename+'.gz', 'wb')\\n fout.writelines(fin)\\n fout.close()\\n fin.close()\\n if remove == True:\\n os.remove(filename)\\n return\",\n \"def extracted_file(fname: str):\\n new_fname = extract_gzip(fname)\\n gzipped = True\\n if new_fname is None:\\n new_fname = fname\\n gzipped = False\\n\\n try:\\n yield new_fname\\n finally:\\n if gzipped:\\n try:\\n bgzip_and_name(new_fname)\\n except Exception:\\n gzip_and_name(new_fname)\",\n \"def skip_gzip_check(self):\\r\\n _read_eof = gzip._GzipReader._read_eof\\r\\n gzip.GzipFile._read_eof = lambda *args, **kwargs: None\\r\\n yield\\r\\n gzip.GzipFile._read_eof = _read_eof\",\n \"def _compress_content(self, content):\\n zbuf = io.BytesIO()\\n zfile = gzip.GzipFile(mode=\\\"wb\\\", compresslevel=9, fileobj=zbuf)\\n\\n try:\\n zfile.write(content.read())\\n finally:\\n zfile.close()\\n\\n content.file = zbuf\\n content.seek(0)\\n\\n return content\",\n \"def isgzip(filename):\\n magic_number = b'\\\\x1f\\\\x8b\\\\x08'\\n with open(filename, 'rb') as f:\\n file_start = f.read(len(magic_number))\\n\\n if magic_number == file_start:\\n return True\\n return False\",\n \"def is_gzip_result(self):\\n return self.__aceQLHttpApi.is_gzip_result()\",\n \"def gzipFile(aFile):\\n f_in = open(aFile, \\\"rb\\\")\\n f_out = gzip.open(aFile + \\\".gz\\\", \\\"wb\\\")\\n f_out.writelines(f_in)\\n f_out.close()\\n f_in.close()\\n os.remove(aFile)\",\n \"def fixture_filled_gzip_file(non_existing_gzipped_file_path: Path, content: str) -> Path:\\n with gzip.open(non_existing_gzipped_file_path, \\\"wb\\\") as outfile:\\n with io.TextIOWrapper(outfile, encoding=\\\"utf-8\\\") as enc:\\n enc.write(content)\\n return non_existing_gzipped_file_path\",\n \"def clean_gzip():\\n this_dir = os.getcwd()\\n os.chdir(\\\"/data/COHERENT2/data/CrystalChar/raw\\\")\\n all_files = glob.glob(\\\"./**\\\", recursive=True)\\n for f in all_files:\\n if \\\".gz\\\" in f and \\\"tar\\\" not in f:\\n print(f)\\n sh(\\\"gunzip \\\" + f)\\n os.chdir(this_dir)\",\n \"def _determine_compression_safe_file_opener(self):\\n f = gzip.open(self.input_fname, \\\"r\\\")\\n try:\\n f.read(1)\\n self._compression_safe_file_opener = gzip.open\\n except IOError:\\n self._compression_safe_file_opener = open\\n finally:\\n f.close()\",\n \"def is_gz_file(f):\\n with open(f, \\\"rb\\\") as fin:\\n return binascii.hexlify(fin.read(2)) == b\\\"1f8b\\\"\",\n \"def extract_gzip(fname: str, outfile: Optional[str] = None) -> Union[str, None]:\\n if not outfile:\\n outfile = fname[:-3]\\n\\n if fname.endswith(\\\".gz\\\"):\\n with gzip.open(fname, \\\"rb\\\") as f_in:\\n with open(outfile, \\\"wb\\\") as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n os.unlink(fname)\\n return outfile\",\n \"def gzopen(f):\\n return gzip.open(f, 'rb') if f.endswith('.gz') else open(f, 'r')\",\n \"def test_no_compress_compressed_response(self):\\n self.resp[\\\"Content-Encoding\\\"] = \\\"deflate\\\"\\n r = GZipMiddleware(self.get_response)(self.req)\\n self.assertEqual(r.content, self.compressible_string)\\n self.assertEqual(r.get(\\\"Content-Encoding\\\"), \\\"deflate\\\")\",\n \"def test_gzip_page(self):\\n content = self.unique_gzip()\\n self.assertViewBehavior(\\n {\\\"get\\\": content},\\n headers={\\\"HTTP_ACCEPT_ENCODING\\\": \\\"gzip\\\"},\\n status_code=200,\\n content=self.compress(content),\\n headers_exact={\\\"Content-Encoding\\\": \\\"gzip\\\"})\",\n \"def is_gzipped(infile):\\n logger = logging.getLogger(__name__)\\n\\n magic_number = b'\\\\x1f\\\\x8b'\\n f = open(infile, 'rb')\\n with f:\\n try:\\n assert f.read(2) == magic_number\\n except AssertionError as e:\\n logger.info(f'{infile} is not gzipped')\\n return False\\n else:\\n logger.debug(f'{infile} is gzipped')\\n return True\",\n \"def zip_file(file_path: str) -> str:\\n zip_file_path: str = file_path + \\\".gz\\\"\\n\\n print(f\\\"Compressing {file_path} into {zip_file_path}\\\")\\n timestamp=path.getmtime(file_path)\\n with open(file_path, \\\"rb\\\") as read_stream:\\n with gzip.open(zip_file_path, \\\"wb\\\") as write_stream:\\n shutil.copyfileobj(read_stream, write_stream)\\n os.utime(zip_file_path, (timestamp,timestamp) )\\n\\n return zip_file_path\",\n \"def gzip_assets():\\n run('cd %(repo_path)s; python gzip_assets.py' % env)\",\n \"def test_compress_response(self):\\n r = GZipMiddleware(self.get_response)(self.req)\\n self.assertEqual(self.decompress(r.content), self.compressible_string)\\n self.assertEqual(r.get(\\\"Content-Encoding\\\"), \\\"gzip\\\")\\n self.assertEqual(r.get(\\\"Content-Length\\\"), str(len(r.content)))\",\n \"def maybe_compress(filename, compress_minsize=config.COMPRESS_MINSIZE):\\n size = os.path.getsize(filename)\\n if size < compress_minsize:\\n return open(filename, 'rb'), False\\n\\n compressed_size, compressed_fobj = compress_file(filename)\\n if compressed_size >= size:\\n # Compressed file was larger\\n log.info(\\\"%s was larger when compressed; using uncompressed version\\\", filename)\\n return open(filename, 'rb'), False\\n\\n return compressed_fobj, True\",\n \"def test_compress_deterministic(self):\\n\\n class DeterministicGZipMiddleware(GZipMiddleware):\\n max_random_bytes = 0\\n\\n r1 = DeterministicGZipMiddleware(self.get_response)(self.req)\\n r2 = DeterministicGZipMiddleware(self.get_response)(self.req)\\n self.assertEqual(r1.content, r2.content)\\n self.assertEqual(self.get_mtime(r1.content), 0)\\n self.assertEqual(self.get_mtime(r2.content), 0)\",\n \"def write_to_gzip(fname, html_body):\\n dir_path = os.path.dirname(fname)\\n ensure_dir_exists(dir_path)\\n\\n with gzip.open(fname, 'wb') as html_file:\\n html_file.write(html_body)\",\n \"def is_gzip(fp):\\r\\n return open(fp, 'rb').read(2) == '\\\\x1f\\\\x8b'\",\n \"def _serve_asset(self, path, gzipped_asset_bytes, request):\\n mimetype = mimetypes.guess_type(path)[0] or 'application/octet-stream'\\n return http_util.Respond(\\n request, gzipped_asset_bytes, mimetype, content_encoding='gzip')\",\n \"def org_apache_felix_jetty_gziphandler_enable(self) -> ConfigNodePropertyBoolean:\\n return self._org_apache_felix_jetty_gziphandler_enable\",\n \"def compress_file(map_, name, save_path):\\n size = os.path.getsize(save_path)\\n temp = subprocess.run([\\\"gzip\\\", \\\"-k\\\", save_path])\\n cr_size = os.path.getsize(save_path+\\\".gz\\\")\\n try:\\n map_[name] = cr_size / size\\n except Exception as e:\\n print(f\\\"File: {save_path}, Ori:{size}, Compr:{cr_size}\\\")\\n print(e)\\n raise ZeroDivisionError\\n temp = subprocess.run([\\\"rm\\\", save_path])\\n temp = subprocess.run([\\\"rm\\\", save_path+\\\".gz\\\"])\",\n \"def test_compress_non_200_response(self):\\n self.resp.status_code = 404\\n r = GZipMiddleware(self.get_response)(self.req)\\n self.assertEqual(self.decompress(r.content), self.compressible_string)\\n self.assertEqual(r.get(\\\"Content-Encoding\\\"), \\\"gzip\\\")\",\n \"def zipfile(filepath, cleanup=False):\\n\\tzfile = filepath+\\\".gz\\\"\\n\\twith open(filepath, 'rb') as f_in:\\n\\t\\twith gzip.open(zfile, 'wb') as f_out:\\n\\t\\t\\tf_out.writelines(f_in)\\t\\n\\t\\n\\tif cleanup and file_exists(zfile):\\n\\t\\tos.remove(filepath)\\n\\treturn zfile\",\n \"def _gzipencode(content):\\n import gzip\\n out = BytesIO()\\n f = gzip.GzipFile(fileobj=out, mode='w', compresslevel=5)\\n f.write(content)\\n f.close()\\n return out.getvalue()\",\n \"def ungz(filepath, compression='rb', deletesource=False):\\n\\n import gzip\\n\\n with gzip.open(filepath, compression) as f:\\n outF = open(filepath[:-3], 'wb')\\n outF.write(f.read())\\n f.close()\\n outF.close()\\n if deletesource:\\n try:\\n os.remove(filepath)\\n except:\\n raise Exception(\\\"Could not delete gz archive {0}.\\\".format(filepath))\\n\\n return filepath[:-3]\",\n \"def archive_file(filename, maxsize):#{{{\\n if not os.path.exists(filename):\\n print(filename, \\\"does not exist. ignore.\\\", file=sys.stderr)\\n return 1\\n\\n filesize = os.path.getsize(filename)\\n if filesize > maxsize:\\n cnt = 0\\n zipfile = \\\"\\\"\\n while 1:\\n cnt += 1\\n zipfile = \\\"%s.%d.gz\\\"%(filename, cnt)\\n if not os.path.exists(zipfile):\\n break\\n # write zip file\\n try:\\n f_in = open(filename, 'rb')\\n except IOError:\\n print(\\\"Failed to read %s\\\"%(filename), file=sys.stderr)\\n return 1\\n try:\\n f_out = gzip.open(zipfile, 'wb')\\n except IOError:\\n print(\\\"Failed to write to %s\\\"%(zipfile), file=sys.stderr)\\n return 1\\n\\n f_out.writelines(f_in)\\n f_out.close()\\n f_in.close()\\n print(\\\"%s is archived to %s\\\"%(filename, zipfile))\\n os.remove(filename)\\n return 0\",\n \"def _compress_string(content):\\n zbuf = StringIO()\\n zfile = GzipFile(mode='wb', compresslevel=6, fileobj=zbuf)\\n zfile.write(content)\\n zfile.close()\\n return zbuf.getvalue()\",\n \"def gunzip(data):\\n return gzip.GzipFile(fileobj=StringIO(data)).read()\",\n \"def chk_for_gz(filenm):\\n import os\\n from os.path import expanduser\\n filenm = expanduser(filenm)\\n\\n # File exist?\\n if os.path.lexists(filenm):\\n chk=True\\n return filenm, chk\\n\\n # .gz already\\n if filenm.find('.gz') > 0:\\n chk=0\\n return filenm, chk\\n\\n # Add .gz\\n if os.path.lexists(filenm+'.gz'):\\n chk=True\\n return filenm+'.gz', chk\\n else:\\n chk=False\\n return None, chk\",\n \"def compress_file(path):\\n\\n process = Popen([\\\"xz\\\", \\\"--compress\\\", \\\"--force\\\", \\\"--stdout\\\", path], stdout=PIPE)\\n return process.communicate()[0]\",\n \"def compress_file(path):\\n\\n process = Popen([\\\"xz\\\", \\\"--compress\\\", \\\"--force\\\", \\\"--stdout\\\", path], stdout=PIPE)\\n return process.communicate()[0]\",\n \"def test_no_compress_incompressible_response(self):\\n self.resp.content = self.incompressible_string\\n r = GZipMiddleware(self.get_response)(self.req)\\n self.assertEqual(r.content, self.incompressible_string)\\n self.assertIsNone(r.get(\\\"Content-Encoding\\\"))\",\n \"def __init__(self, input_stream, level=9):\\n super(Gzip, self).__init__(input_stream)\\n\\n self._level = level\",\n \"def gzip_worker(args):\\n\\tp = multiprocessing.current_process()\\n\\tprint('Start zipping %s: %s %s' %(args[1], p.name, p.pid))\\n\\tpath = args[0]\\n\\tfilename = args[1]\\n\\tassert os.path.splitext(filename)[1] == '.fastq', '%s is not a fastq file' %filename \\n\\t\\n\\tcall = 'gzip -c ' + os.path.join(path, filename) + ' > ' + os.path.join(path, filename) + '.gz'\\n\\tsubprocess.call(call, shell=True)\\n\\tprint('Completed zipping %s: %s %s' %(filename, p.name, p.pid))\",\n \"def gunzip_file(gzip_file, base_dir):\\n full_gzip_file = os.path.join(base_dir, gzip_file)\\n if not gzip_file.endswith(\\\".gz\\\"):\\n return gzip_file\\n gunzip_file = full_gzip_file.replace(\\\".gz\\\", \\\"\\\")\\n with gzip.open(full_gzip_file, 'rb') as f_in:\\n with open(gunzip_file, 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n # Now that file is extracted. Remove file\\n os.remove(full_gzip_file)\\n\\n return os.path.basename(gunzip_file)\",\n \"def compress_stream(src, dst):\\n with gzip.GzipFile(fileobj=dst, mode='wb') as gz:\\n for block in iterfile(src):\\n gz.write(block)\",\n \"def test_decompress_file():\\n gz_file = os.path.join(\\n tempfile.gettempdir(),\\n \\\"jade-unit-test-file.gz\\\",\\n )\\n with gzip.open(gz_file, \\\"wb\\\") as f:\\n f.write(b\\\"Hello World\\\")\\n assert os.path.exists(gz_file)\\n\\n new_file = decompress_file(gz_file)\\n assert os.path.exists(new_file)\\n with open(new_file, \\\"r\\\") as f:\\n data = f.read()\\n assert data == \\\"Hello World\\\"\\n\\n if os.path.exists(gz_file):\\n os.remove(gz_file)\\n\\n if os.path.exists(new_file):\\n os.remove(new_file)\",\n \"def gunzip_file(gz_path, new_path):\\n print(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def compressIfNeeded(self):\\n\\n if self._mode == \\\"zip\\\":\\n zip_folder(self._rootExportPath, self.getZipArchiveFullPath())\",\n \"def uncompress_gzip(location, target_dir):\\n\\n return uncompress(location, target_dir, decompressor=gzip.GzipFile)\",\n \"def test_gzip_file_no_extension(self):\\n # Write the data to a file\\n temp_file = tempfile.NamedTemporaryFile()\\n with gzip.open(temp_file.name, 'wb') as out:\\n for item in self.data:\\n serialzed = json.dumps(item).encode()\\n out.write(serialzed + b'\\\\n')\\n\\n # Load from file, ensure it is correct\\n actual_data = []\\n with JsonlReader(temp_file.name) as f:\\n for item in f:\\n actual_data.append(item)\\n self.assertEqual(self.data, actual_data)\",\n \"def _check_zip_file (filename, path_unzip, outfile) :\\n assert path_unzip is not None\\n file,ext = os.path.splitext (filename)\\n ext = ext.lower ()\\n if ext == \\\".gz\\\" :\\n \\n import gzip\\n \\n if outfile is None :\\n dest = filename.split (\\\"!\\\")\\n dest = dest [ len(dest)-1 ]\\n ext = os.path.splitext (dest) [1]\\n dest = dest.replace (ext, \\\".txt\\\")\\n path = os.path.split (filename)\\n path = \\\"/\\\".join (path [:len (path)-1])\\n dest = path + \\\"/\\\" + dest\\n else :\\n dest = outfile\\n \\n if not os.path.exists (dest) :\\n file = gzip.GzipFile (filename, \\\"r\\\")\\n if outfile is None :\\n dest = os.path.split (dest) [1]\\n dest = os.path.join (path_unzip, dest)\\n \\n if os.path.exists (dest) :\\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\\n if st2 > st1 : \\n fLOG (\\\"ungzipping file (already done)\\\", dest)\\n return dest\\n \\n fLOG (\\\"ungzipping file\\\", dest)\\n f = open (dest, \\\"w\\\")\\n data = file.read (2**27)\\n size = 0\\n while len (data) > 0 :\\n size += len (data)\\n fLOG (\\\"ungzipping \\\", size, \\\"bytes\\\")\\n if isinstance (data, bytes) : f.write (bytes.decode (data))\\n else : f.write (data)\\n data = file.read (2**27)\\n f.close ()\\n file.close ()\\n \\n return dest\\n \\n if ext == \\\".zip\\\" :\\n \\n import zipfile\\n try :\\n file = zipfile.ZipFile (filename, \\\"r\\\")\\n except Exception as e :\\n fLOG (\\\"problem with \\\", filename)\\n raise e\\n \\n if len (file.infolist()) != 1:\\n if outfile is not None :\\n raise PQHException (\\\"the archive contains %d files and not one as you expected by filling outfile\\\" % len (file.infolist()))\\n fLOG (\\\"unzip file (multiple) \\\", filename)\\n #message = \\\"\\\\n\\\".join ([ fi.filename for fi in file.infolist() ] )\\n #raise Exception.YstException(\\\"ColumnInfoSet.load_from_file: file %s contains no file or more than one file\\\\n\\\" + message)\\n folder = os.path.split (filename) [0]\\n todo = 0\\n _zip7_path = r\\\"c:\\\\Program Files\\\\7-Zip\\\"\\n zip7 = os.path.exists (_zip7_path)\\n wait = [ ]\\n for info in file.infolist () :\\n fileinside = info.filename\\n dest = os.path.join (folder, fileinside)\\n if not os.path.exists (dest) :\\n fol = os.path.split (dest) [0]\\n if not os.path.exists (fol) : os.makedirs (fol)\\n if os.path.exists (dest) :\\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\\n if st2 > st1 : \\n continue\\n \\n if not sys.platform.startswith(\\\"win\\\") or not zip7 :\\n data = file.read (fileinside)\\n dest = os.path.split (dest) [1]\\n dest = os.path.join (path_unzip, dest)\\n fLOG (\\\"unzipping file\\\", dest)\\n wait.append(dest)\\n f = open (dest, \\\"w\\\")\\n if isinstance (data, bytes) :\\n f.write (str (data))\\n else :\\n f.write (data)\\n f.close ()\\n else :\\n todo += 1\\n \\n if todo > 0 and zip7 :\\n dest = os.path.realpath (path_unzip)\\n cmd = '\\\"' + _zip7_path + '\\\\\\\\7z.exe\\\" e -y -o\\\"%s\\\" \\\"%s\\\"' % (dest, os.path.realpath (filename)) \\n out,err = run_cmd (cmd, wait = True)\\n if len (err) > 0 : raise PQHException (\\\"command {0} failed\\\\n{1}\\\".format(cmd,err))\\n if \\\"Error\\\" in out : raise PQHException (\\\"command {0} failed\\\\n{1}\\\".format(cmd,out))\\n else :\\n dest = path_unzip\\n \\n file.close ()\\n \\n ch = False\\n while not ch :\\n ch = True\\n for a in wait :\\n if not os.path.exists(a) : \\n ch = False\\n break\\n time.sleep(0.5)\\n \\n return dest\\n \\n else :\\n for info in file.infolist () :\\n fileinside = info.filename\\n \\n path = os.path.split (filename)\\n dest = outfile if outfile is not None else path [0] + \\\"/\\\" + fileinside\\n if not os.path.exists (dest) :\\n data = file.read (fileinside)\\n if outfile is None :\\n dest = os.path.split (dest) [1]\\n dest = os.path.join (path_unzip, dest)\\n \\n if os.path.exists (dest) :\\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\\n if st2 > st1 : \\n fLOG(\\\"unzipping one file (already done)\\\", dest)\\n return dest\\n \\n fLOG(\\\"unzipping one file\\\", dest)\\n f = open (dest, \\\"w\\\")\\n if isinstance (data, bytes) :\\n f.write (bytes.decode (data))\\n else :\\n f.write (data)\\n f.close ()\\n file.close ()\\n return dest\\n \\n return filename\",\n \"def create_compressed_file(self):\\n\\t\\tself._compressed_file_name = 'c_' + self.file_name\\n\\t\\tself._compressed_save_path = self.full_path.replace(self.file_name, self._compressed_file_name)\\n\\t\\tself._is_png = 'png' in self.file_extension\\n\\t\\tself._is_jpg = 'jpg' in self.file_extension\\n\\n\\t\\timage = Image.open(self.full_path)\\n\\n\\t\\tif self._is_png:\\n\\t\\t\\timage.save(self._compressed_save_path, quality=85, optimize=False, compress_level=9)\\n\\t\\telif self._is_jpg:\\n\\t\\t\\timage.save(self._compressed_save_path, quality=85, progressive=False)\\n\\t\\telse:\\n\\t\\t\\tprint('Non-recognized asset format!!')\\n\\t\\t\\texit()\\n\\n\\t\\tself._compressed_file_size = ufo.get_file_size_in_bytes(self._compressed_save_path)\\n\\n\\n\\t\\ttransfer_path = self._compressed_save_path.replace('c_' + self.file_name, self.file_name).replace('/configuration_files/', '/quasar_site_django/')\\n\\t\\tufo.copy_file_to_path(self._compressed_save_path, transfer_path)\",\n \"def gunzip_file(gz_path, new_path):\\n logging.info(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def _newfile(counter):\\n name = '%s/sitemap-%s.xml.gz' % (settings.SITEMAPS_DIR,\\n counter)\\n fp = gzip.open(name, 'wb')\\n fp.write(\\\"\\\"\\\"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\n<urlset xmlns=\\\"http://www.sitemaps.org/schemas/sitemap/0.9\\\">\\\\n\\\"\\\"\\\")\\n return fp\",\n \"def __handle_compression(self, x):\\n if self.__compress:\\n return zlib.compress(x)\\n return x\",\n \"def compressFile(source, target):\\n data = cake.filesys.readFile(source)\\n try:\\n data = zlib.compress(data, 1)\\n except zlib.error, e:\\n raise EnvironmentError(str(e))\\n cake.filesys.writeFile(target, data)\",\n \"def open_gzipped(infile, mode='rt'):\\n import gzip\\n import bz2\\n if mode.startswith('r'):\\n tmode = 'rt'\\n bmode = 'r'\\n elif mode.startswith('w'):\\n tmode = 'wt'\\n bmode = 'w'\\n elif mode.startswith('a'):\\n tmode = 'at'\\n bmode = 'a'\\n if hasattr(infile, 'write'):\\n return infile\\n if isinstance(infile, str):\\n if infile.endswith('.gz'):\\n return gzip.open(infile, tmode)\\n if infile.endswith('.bz2'):\\n if hasattr(bz2, 'open'):\\n return bz2.open(infile, tmode)\\n else:\\n return bz2.BZ2File(infile, bmode)\\n return open(infile, tmode)\",\n \"def is_zip(filepath):\\n\\treturn os.path.splitext(filepath)[1] == '.gz'\",\n \"def gunzip_file(gz_path, new_path):\\n print(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def to_gzip_response(response, gzip_flag):\\n headers = \\\"Content-Type: application/json\\\\n\\\"\\n if gzip_flag:\\n out = StringIO.StringIO()\\n with gzip.GzipFile(fileobj=out, mode=\\\"w\\\") as f:\\n f.write(response)\\n headers += \\\"Vary: Accept-Encoding\\\\n\\\"\\n headers += \\\"Content-Encoding: gzip\\\\r\\\\n\\\\r\\\\n\\\"\\n response = out.getvalue()\\n del out\\n else:\\n headers += \\\"\\\\r\\\\n\\\"\\n return [response, headers]\",\n \"def compress():\\n run_manage_cmd('compress_assets')\",\n \"def test_no_compress_short_response(self):\\n self.resp.content = self.short_string\\n r = GZipMiddleware(self.get_response)(self.req)\\n self.assertEqual(r.content, self.short_string)\\n self.assertIsNone(r.get(\\\"Content-Encoding\\\"))\",\n \"def org_apache_felix_jetty_gzip_sync_flush(self) -> ConfigNodePropertyBoolean:\\n return self._org_apache_felix_jetty_gzip_sync_flush\",\n \"def read_gzip_file_content(self, s3_path):\\n s3_object = self._get_s3_object(s3_path)\\n\\n bytestream = BytesIO(s3_object.get()['Body'].read())\\n\\n gzip_file = GzipFile(mode=\\\"rb\\\", fileobj=bytestream)\\n output = gzip_file.read().decode(\\\"utf-8\\\")\\n\\n return output\",\n \"def read_gzipped(response):\\r\\n if response.info().get('Content-Encoding') == 'gzip':\\r\\n with io.BytesIO(response.read()) as buf:\\r\\n with gzip.GzipFile(fileobj=buf) as unzipped:\\r\\n data = unzipped.read()\\r\\n else:\\r\\n data = response.read()\\r\\n return data\",\n \"def de_gzip(data):\\n cmps = StringIO.StringIO(data)\\n gzipper = gzip.GzipFile(fileobj=cmps)\\n return gzipper.read()\",\n \"def de_gzip(data):\\n cmps = StringIO.StringIO(data)\\n gzipper = gzip.GzipFile(fileobj=cmps)\\n return gzipper.read()\",\n \"def gunzip_file(gz_path, new_path):\\n print(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def write_header_in_gz_file(self):\\r\\n if self.arguments['--out']:\\r\\n self.file = gzip.open(self.arguments['--out'] + '.gz', \\\"w+b\\\")\\r\\n self.file.write(self.version.encode('utf-8'))\\r\\n for list_item in self.list_of_header_objects:\\r\\n self.file.write(list_item.line.encode('utf-8'))\\r\\n self.file.write(self.body_header_line.line)\\r\\n self.file.close()\\r\\n else:\\r\\n for list_item in self.list_of_header_objects:\\r\\n print(list_item.line.encode('utf-8'))\",\n \"def _downloadWGS(WGSurl) :\\n gzipContent = urllib2.urlopen(WGSurl).read()\\n gzipFile = StringIO.StringIO(gzipContent)\\n o = gzip.GzipFile(fileobj = gzipFile)\\n output = None\\n try :\\n output = o.read()\\n except IOError as e:\\n print(e)\\n o.close()\\n return output\",\n \"def gzipPage(page):\\n #if not hasattr(page,\\\"info\\\"):\\n # return(\\\"\\\")\\n data = object()\\n # Check if content encoding is gzip\\n if page.info().get('Content-Encoding') == 'gzip':\\n buf = StringIO(page.read())\\n f = gzip.GzipFile(fileobj=buf)\\n data = f.read()\\n else :\\n data = page.read()\\n return(data)\",\n \"def gzip_files(topDir, afni_file,localizerfile):\\n\\n print 'GZIPPING FILES...'\\n\\n command1 = \\\"gzip %s*BRIK\\\" % (topDir)\\n command2 = \\\"gzip %s*HEAD\\\" % (topDir)\\n command3 = \\\"gzip %s%s/pb00*\\\" % (topDir,afni_file)\\n command4 = \\\"gzip %s%s/errts*\\\" % (topDir,afni_file)\\n command5 = \\\"gzip %s%s/fitts*\\\" % (topDir,afni_file)\\n command6 = \\\"gzip %s%s/*al*\\\" % (topDir,afni_file)\\n command7 = \\\"gzip %s%s/*ns*\\\" % (topDir,afni_file)\\n command8 = \\\"gzip %s%s/all_runs*\\\" % (topDir,afni_file)\\n command9 = \\\"gzip %s%s/*mask*\\\" % (topDir,afni_file)\\n command10 = \\\"gzip %s*nii\\\" % (topDir)\\n command11 = \\\"gzip %s%s/pb01*\\\" % (topDir,afni_file)\\n command12 = \\\"gzip %s%s/pb03*\\\" % (topDir,afni_file)\\n command13 = \\\"gzip %s%s/pb02*\\\" % (topDir,afni_file)\\n\\n os.system(command1)\\n os.system(command2)\\n os.system(command3)\\n os.system(command4)\\n os.system(command5)\\n os.system(command6)\\n os.system(command7)\\n os.system(command8)\\n #os.system(command9)\\n os.system(command10)\\n os.system(command11)\\n try:\\n os.system(command12)\\n except:\\n print 'Could not gzip pb03 files'\\n\\n if localizerfile == 'facescene_loc':\\n os.system(command13)\",\n \"def zip_compress(self, destination):\\n\\n if destination is not None and isinstance(destination, str):\\n with ZipFile(destination, \\\"w\\\") as thezip:\\n thezip.write(self.file)\",\n \"def test_file_gzip_utf8_readwrite(self):\\n if state.py2:\\n FileWriter(self.unicode_path).gzip(self.unicode_string)\\n gzip_contents = FileReader(self.unicode_path + \\\".gz\\\").read_gzip() # when read without explicit utf-8 decoding, the strings will not match\\n self.assertNotEqual(gzip_contents, self.unicode_string)\\n elif state.py3:\\n FileWriter(self.unicode_path).gzip(bytes(self.unicode_string, 'utf-8'))\\n gzip_contents = FileReader(self.unicode_path + \\\".gz\\\").read_gzip() # when read without explicit utf-8 decoding, the strings will not match\\n self.assertNotEqual(gzip_contents, self.unicode_string)\",\n \"def test_args_gzip(testapp):\\n\\n timepoint = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\\n stream = sitemap.process(\\n testapp,\\n [\\n holocron.WebSiteItem(\\n {\\n \\\"destination\\\": pathlib.Path(\\\"1.html\\\"),\\n \\\"updated\\\": timepoint,\\n \\\"baseurl\\\": testapp.metadata[\\\"url\\\"],\\n }\\n )\\n ],\\n gzip=True,\\n )\\n\\n assert isinstance(stream, collections.abc.Iterable)\\n assert list(stream) == [\\n holocron.WebSiteItem(\\n {\\n \\\"destination\\\": pathlib.Path(\\\"1.html\\\"),\\n \\\"updated\\\": timepoint,\\n \\\"baseurl\\\": testapp.metadata[\\\"url\\\"],\\n }\\n ),\\n holocron.WebSiteItem(\\n {\\n \\\"source\\\": pathlib.Path(\\\"sitemap://sitemap.xml.gz\\\"),\\n \\\"destination\\\": pathlib.Path(\\\"sitemap.xml.gz\\\"),\\n \\\"content\\\": _pytest_xmlasdict(\\n {\\n \\\"urlset\\\": {\\n \\\"@xmlns\\\": \\\"http://www.sitemaps.org/schemas/sitemap/0.9\\\",\\n \\\"url\\\": {\\n \\\"loc\\\": \\\"https://yoda.ua/1.html\\\",\\n \\\"lastmod\\\": \\\"1970-01-01T00:00:00+00:00\\\",\\n },\\n }\\n },\\n ungzip=True,\\n ),\\n \\\"baseurl\\\": testapp.metadata[\\\"url\\\"],\\n }\\n ),\\n ]\",\n \"def bgzip_and_name(fname, bgzip_file=True) -> str:\\n if bgzip_file:\\n ret = sp.check_call(f\\\"bgzip {fname}\\\", shell=True)\\n fname += \\\".gz\\\"\\n if ret != 0:\\n raise Exception(f\\\"Error bgzipping genome {fname}. Is pysam installed?\\\")\\n return fname\",\n \"def gz_tar(full_prefix):\\n tarfile = os.path.join(outputdir, full_prefix + '.tar')\\n try:\\n with open(tarfile, 'rb') as f_in, gzip.open(tarfile + '.gz', 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n os.remove(tarfile)\\n except Exception as e:\\n log.error(\\\"Tarfile {0} was not generated. Module(s) run collected no info?\\\".format(tarfile))\\n log.error(e)\\n\\n return tarfile + '.gz'\",\n \"def compressBuffer(self, buffer):\\r\\n # http://jython.xhaus.com/http-compression-in-python-and-jython/\\r\\n zbuf = cStringIO.StringIO()\\r\\n zfile = gzip.GzipFile(mode='wb', fileobj=zbuf, compresslevel=9)\\r\\n zfile.write(buffer)\\r\\n zfile.close()\\r\\n return zbuf.getvalue()\",\n \"def are_files_gzipped(raw_files):\\n files_are_gzipped = None\\n for file_name in raw_files:\\n if re.search(r\\\"\\\\.gz$\\\", file_name) is not None:\\n if files_are_gzipped is False:\\n raise Exception(\\n \\\"It seems one file is compressed and the \\\"\\n \\\"other is \\\"\\n \\\"not:\\\\n{}\\\".format(\\\"\\\\n\\\".join(raw_files))\\n )\\n files_are_gzipped = True\\n else:\\n if files_are_gzipped:\\n raise Exception(\\n \\\"It seems one file is compressed and the \\\"\\n \\\"other is \\\"\\n \\\"not:\\\\n{}\\\".format(\\\"\\\\n\\\".join(raw_files))\\n )\\n files_are_gzipped = False\\n return files_are_gzipped\",\n \"def _extract_gz(src, dst):\\n assert src.endswith(\\\".gz\\\"), \\\"{} is not a valid .gz file.\\\".format(src)\\n assert os.path.exists(src), \\\"{} does not exist.\\\".format(src)\\n\\n with gzip.open(src, \\\"rb\\\") as f_src:\\n # xxx.postfix.gz --> xxx.postfix\\n file_name = os.path.basename(src)[:-3]\\n with open(os.path.join(dst, file_name), \\\"wb\\\") as f_dst:\\n shutil.copyfileobj(f_src, f_dst)\",\n \"def org_apache_felix_jetty_gzip_compression_level(self, org_apache_felix_jetty_gzip_compression_level: ConfigNodePropertyInteger):\\n\\n self._org_apache_felix_jetty_gzip_compression_level = org_apache_felix_jetty_gzip_compression_level\",\n \"def write_body_in_gz_file(self):\\r\\n if self.arguments['--out']:\\r\\n self.file = gzip.open(self.arguments['--out'] + '.gz', \\\"a+b\\\")\\r\\n for list_item in self.list_of_body_objects:\\r\\n self.file.write(list_item.line.encode('utf-8'))\\r\\n self.file.close()\\r\\n else:\\r\\n for list_item in self.list_of_body_objects:\\r\\n print(list_item.line.encode('utf-8'))\\r\\n\\r\\n self.file.close()\",\n \"def save_as_pickle_gz(df, filepath):\\n\\n print('saving file:', filepath)\\n df.to_pickle(filepath, compression='gzip')\",\n \"def org_apache_felix_jetty_gzip_compression_level(self) -> ConfigNodePropertyInteger:\\n return self._org_apache_felix_jetty_gzip_compression_level\",\n \"def compress_file(compression, pretty, src, dst):\\n str_tail = \\\"sed 1d\\\"\\n str_cleanup = \\\";exit\\\"\\n if pretty:\\n str_tail = \\\"tail -n+2\\\"\\n str_cleanup = \\\";rm ~;exit\\\"\\n if \\\"lzma\\\" == compression:\\n command = [\\\"xz\\\", \\\"--format=lzma\\\", \\\"--lzma1=preset=9e,lc=1,lp=0,pb=0\\\", \\\"--stdout\\\"]\\n header = \\\"HOME=/tmp/i;%s $0|lzcat>~;chmod +x ~;~%s\\\" % (str_tail, str_cleanup)\\n elif \\\"raw\\\" == compression:\\n command = [\\\"xz\\\", \\\"-9\\\", \\\"--extreme\\\", \\\"--format=raw\\\", \\\"--stdout\\\"]\\n header = \\\"HOME=/tmp/i;%s $0|xzcat -F raw>~;chmod +x ~;~%s\\\" % (str_tail, str_cleanup)\\n elif \\\"xz\\\" == compression:\\n command = [\\\"xz\\\", \\\"--format=xz\\\", \\\"--lzma2=preset=9e,lc=1,pb=0\\\", \\\"--stdout\\\"]\\n header = \\\"HOME=/tmp/i;%s $0|xzcat>~;chmod +x ~;~%s\\\" % (str_tail, str_cleanup)\\n else:\\n raise RuntimeError(\\\"unknown compression format '%s'\\\" % compression)\\n (compressed, se) = run_command(command + [src], False)\\n wfd = open(dst, \\\"wb\\\")\\n wfd.write((header + \\\"\\\\n\\\").encode())\\n wfd.write(compressed)\\n wfd.close()\\n make_executable(dst)\\n print(\\\"Wrote '%s': %i bytes\\\" % (dst, os.path.getsize(dst)))\",\n \"def test_random_bytes(self):\\n with mock.patch(\\n \\\"django.utils.text.secrets.randbelow\\\", autospec=True, return_value=3\\n ):\\n r = GZipMiddleware(self.get_response)(self.req)\\n # The fourth byte of a gzip stream contains flags.\\n self.assertEqual(r.content[3], gzip.FNAME)\\n # A 3 byte filename \\\"aaa\\\" and a null byte are added.\\n self.assertEqual(r.content[10:14], b\\\"aaa\\\\x00\\\")\\n self.assertEqual(self.decompress(r.content), self.compressible_string)\",\n \"def data_zip(self, data):\\n stringio = StringIO.StringIO()\\n gzip_file = gzip.GzipFile(fileobj=stringio, mode='wb')\\n gzip_file.write(data)\\n gzip_file.close()\\n return stringio.getvalue()\",\n \"def vcf_compress(fn):\\n ret = cmd_exe(f\\\"vcf-sort {fn} | bgzip > {fn}.gz && tabix {fn}.gz\\\")\",\n \"def test_gzip_page_disabled(self):\\n content = self.unique_gzip()\\n self.assertViewBehavior(\\n {\\\"gzip_page\\\": False, \\\"get\\\": content},\\n headers={\\\"HTTP_ACCEPT_ENCODING\\\": \\\"gzip\\\"},\\n status_code=200,\\n content=content,\\n headers_exclude=\\\"Content-Encoding\\\")\",\n \"def _files_from_json(self, file_json):\\n self.compressed_file_json = zlib.compress(json.dumps(file_json).encode('utf-8'))\\n self.compression_algorithm = 'gzip'\\n self.compressed_content_hash = hashlib.sha256(self.compressed_file_json).hexdigest()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7143728","0.6788087","0.654219","0.6520567","0.6455454","0.6441658","0.64261234","0.6391219","0.6348747","0.6328026","0.63114715","0.6300965","0.6233786","0.6195819","0.6182347","0.61750174","0.61693275","0.61632836","0.6142787","0.61406815","0.61263895","0.61121637","0.60998726","0.6072605","0.6062446","0.6036365","0.59987634","0.59959614","0.5988952","0.59784263","0.5957376","0.59519005","0.590136","0.5870764","0.5862149","0.5846724","0.5841294","0.5837773","0.58310086","0.5813516","0.58080095","0.5792809","0.57855594","0.5767307","0.575854","0.57549125","0.5742395","0.5740816","0.57350725","0.57350725","0.5714096","0.5694135","0.56828946","0.5669396","0.5642499","0.56407535","0.5624641","0.56101954","0.5607616","0.56018656","0.5601626","0.5586754","0.5586046","0.55468446","0.55421275","0.5541262","0.5515568","0.54946864","0.54910856","0.5490335","0.54892004","0.5484631","0.54689246","0.5460883","0.54585654","0.54474235","0.54474235","0.5444328","0.5439082","0.54003423","0.53818846","0.53784555","0.5376125","0.5373596","0.5369959","0.5369155","0.5367822","0.5362507","0.53447384","0.5343306","0.5341919","0.5335264","0.5328162","0.53277546","0.532217","0.53149766","0.5303343","0.53014106","0.5298879","0.52930087"],"string":"[\n \"0.7143728\",\n \"0.6788087\",\n \"0.654219\",\n \"0.6520567\",\n \"0.6455454\",\n \"0.6441658\",\n \"0.64261234\",\n \"0.6391219\",\n \"0.6348747\",\n \"0.6328026\",\n \"0.63114715\",\n \"0.6300965\",\n \"0.6233786\",\n \"0.6195819\",\n \"0.6182347\",\n \"0.61750174\",\n \"0.61693275\",\n \"0.61632836\",\n \"0.6142787\",\n \"0.61406815\",\n \"0.61263895\",\n \"0.61121637\",\n \"0.60998726\",\n \"0.6072605\",\n \"0.6062446\",\n \"0.6036365\",\n \"0.59987634\",\n \"0.59959614\",\n \"0.5988952\",\n \"0.59784263\",\n \"0.5957376\",\n \"0.59519005\",\n \"0.590136\",\n \"0.5870764\",\n \"0.5862149\",\n \"0.5846724\",\n \"0.5841294\",\n \"0.5837773\",\n \"0.58310086\",\n \"0.5813516\",\n \"0.58080095\",\n \"0.5792809\",\n \"0.57855594\",\n \"0.5767307\",\n \"0.575854\",\n \"0.57549125\",\n \"0.5742395\",\n \"0.5740816\",\n \"0.57350725\",\n \"0.57350725\",\n \"0.5714096\",\n \"0.5694135\",\n \"0.56828946\",\n \"0.5669396\",\n \"0.5642499\",\n \"0.56407535\",\n \"0.5624641\",\n \"0.56101954\",\n \"0.5607616\",\n \"0.56018656\",\n \"0.5601626\",\n \"0.5586754\",\n \"0.5586046\",\n \"0.55468446\",\n \"0.55421275\",\n \"0.5541262\",\n \"0.5515568\",\n \"0.54946864\",\n \"0.54910856\",\n \"0.5490335\",\n \"0.54892004\",\n \"0.5484631\",\n \"0.54689246\",\n \"0.5460883\",\n \"0.54585654\",\n \"0.54474235\",\n \"0.54474235\",\n \"0.5444328\",\n \"0.5439082\",\n \"0.54003423\",\n \"0.53818846\",\n \"0.53784555\",\n \"0.5376125\",\n \"0.5373596\",\n \"0.5369959\",\n \"0.5369155\",\n \"0.5367822\",\n \"0.5362507\",\n \"0.53447384\",\n \"0.5343306\",\n \"0.5341919\",\n \"0.5335264\",\n \"0.5328162\",\n \"0.53277546\",\n \"0.532217\",\n \"0.53149766\",\n \"0.5303343\",\n \"0.53014106\",\n \"0.5298879\",\n \"0.52930087\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.608778"},"document_rank":{"kind":"string","value":"23"}}},{"rowIdx":83188,"cells":{"query":{"kind":"string","value":"Bgzip file if requested."},"document":{"kind":"string","value":"def bgzip_and_name(fname, bgzip_file=True) -> str:\n if bgzip_file:\n ret = sp.check_call(f\"bgzip {fname}\", shell=True)\n fname += \".gz\"\n if ret != 0:\n raise Exception(f\"Error bgzipping genome {fname}. Is pysam installed?\")\n return fname"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def compressIfNeeded(self):\n\n if self._mode == \"zip\":\n zip_folder(self._rootExportPath, self.getZipArchiveFullPath())","def zipFasta(self):\n utils.log(\"zipping {} ...\".format(self.fastaFileName))\n cmd = \"bgzip -f {}\".format(self.fastaFileName)\n utils.runCommand(cmd)","def _check_zip_file (filename, path_unzip, outfile) :\n assert path_unzip is not None\n file,ext = os.path.splitext (filename)\n ext = ext.lower ()\n if ext == \".gz\" :\n \n import gzip\n \n if outfile is None :\n dest = filename.split (\"!\")\n dest = dest [ len(dest)-1 ]\n ext = os.path.splitext (dest) [1]\n dest = dest.replace (ext, \".txt\")\n path = os.path.split (filename)\n path = \"/\".join (path [:len (path)-1])\n dest = path + \"/\" + dest\n else :\n dest = outfile\n \n if not os.path.exists (dest) :\n file = gzip.GzipFile (filename, \"r\")\n if outfile is None :\n dest = os.path.split (dest) [1]\n dest = os.path.join (path_unzip, dest)\n \n if os.path.exists (dest) :\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\n if st2 > st1 : \n fLOG (\"ungzipping file (already done)\", dest)\n return dest\n \n fLOG (\"ungzipping file\", dest)\n f = open (dest, \"w\")\n data = file.read (2**27)\n size = 0\n while len (data) > 0 :\n size += len (data)\n fLOG (\"ungzipping \", size, \"bytes\")\n if isinstance (data, bytes) : f.write (bytes.decode (data))\n else : f.write (data)\n data = file.read (2**27)\n f.close ()\n file.close ()\n \n return dest\n \n if ext == \".zip\" :\n \n import zipfile\n try :\n file = zipfile.ZipFile (filename, \"r\")\n except Exception as e :\n fLOG (\"problem with \", filename)\n raise e\n \n if len (file.infolist()) != 1:\n if outfile is not None :\n raise PQHException (\"the archive contains %d files and not one as you expected by filling outfile\" % len (file.infolist()))\n fLOG (\"unzip file (multiple) \", filename)\n #message = \"\\n\".join ([ fi.filename for fi in file.infolist() ] )\n #raise Exception.YstException(\"ColumnInfoSet.load_from_file: file %s contains no file or more than one file\\n\" + message)\n folder = os.path.split (filename) [0]\n todo = 0\n _zip7_path = r\"c:\\Program Files\\7-Zip\"\n zip7 = os.path.exists (_zip7_path)\n wait = [ ]\n for info in file.infolist () :\n fileinside = info.filename\n dest = os.path.join (folder, fileinside)\n if not os.path.exists (dest) :\n fol = os.path.split (dest) [0]\n if not os.path.exists (fol) : os.makedirs (fol)\n if os.path.exists (dest) :\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\n if st2 > st1 : \n continue\n \n if not sys.platform.startswith(\"win\") or not zip7 :\n data = file.read (fileinside)\n dest = os.path.split (dest) [1]\n dest = os.path.join (path_unzip, dest)\n fLOG (\"unzipping file\", dest)\n wait.append(dest)\n f = open (dest, \"w\")\n if isinstance (data, bytes) :\n f.write (str (data))\n else :\n f.write (data)\n f.close ()\n else :\n todo += 1\n \n if todo > 0 and zip7 :\n dest = os.path.realpath (path_unzip)\n cmd = '\"' + _zip7_path + '\\\\7z.exe\" e -y -o\"%s\" \"%s\"' % (dest, os.path.realpath (filename)) \n out,err = run_cmd (cmd, wait = True)\n if len (err) > 0 : raise PQHException (\"command {0} failed\\n{1}\".format(cmd,err))\n if \"Error\" in out : raise PQHException (\"command {0} failed\\n{1}\".format(cmd,out))\n else :\n dest = path_unzip\n \n file.close ()\n \n ch = False\n while not ch :\n ch = True\n for a in wait :\n if not os.path.exists(a) : \n ch = False\n break\n time.sleep(0.5)\n \n return dest\n \n else :\n for info in file.infolist () :\n fileinside = info.filename\n \n path = os.path.split (filename)\n dest = outfile if outfile is not None else path [0] + \"/\" + fileinside\n if not os.path.exists (dest) :\n data = file.read (fileinside)\n if outfile is None :\n dest = os.path.split (dest) [1]\n dest = os.path.join (path_unzip, dest)\n \n if os.path.exists (dest) :\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\n if st2 > st1 : \n fLOG(\"unzipping one file (already done)\", dest)\n return dest\n \n fLOG(\"unzipping one file\", dest)\n f = open (dest, \"w\")\n if isinstance (data, bytes) :\n f.write (bytes.decode (data))\n else :\n f.write (data)\n f.close ()\n file.close ()\n return dest\n \n return filename","def handle_file(self, path):\n\n if path:\n if not matches_patterns(path, self.gzip_patterns):\n return\n\n try:\n original_file = self.open(path, mode=\"rb\")\n except FileNotFoundError:\n pass\n else:\n gzipped_path = \"{0}.gz\".format(path)\n\n if self.exists(gzipped_path):\n self.delete(gzipped_path)\n\n gzipped_file = self._compress(original_file)\n gzipped_path = self.save(gzipped_path, gzipped_file)\n\n return gzipped_path, gzipped_path, True","def is_zip(filepath):\n\treturn os.path.splitext(filepath)[1] == '.gz'","def _open_zip(self):\n self.buffer = io.BytesIO()\n self.zf = zipfile.ZipFile(self.buffer, \"w\", zipfile.ZIP_DEFLATED)","def zip_compress(self, destination):\n\n if destination is not None and isinstance(destination, str):\n with ZipFile(destination, \"w\") as thezip:\n thezip.write(self.file)","def finalize_zip(zip, filename):\n zip.close()\n with open(filename, 'wb') as file:\n file.write(zipbytes.getvalue())","def load_file_in_archive(req_path, archive, archive_ext, zip_path, name, ext):\n BASE_DIR = ROOT\n full_path = u\"%s/%s.%s\" % (req_path, archive, archive_ext)\n zip_path = u\"%s/%s.%s\" % (zip_path, name, ext)\n full_real_path = get_real_path(BASE_DIR, full_path)\n logger.info(\"%s, %s\", full_real_path, [to_hex(c) for c in full_real_path])\n try:\n zip_path = unquote(zip_path).encode('utf-8')\n except Exception as e:\n logger.info(\"Failed to encode: %s\", zip_path)\n\n if ext == 'thm' or archive_ext not in archive_exts:\n logger.info(\"Unsupported file\")\n return ('', 204)\n\n if os.path.exists(full_real_path.encode('utf-8')):\n logger.info(\"File doesn't exist: %s\", full_real_path)\n return ('', 204)\n\n #Only zip files are supported <path>/file.zip/1/01.jpg\n ## Render single file\n with zipfile.ZipFile(full_real_path) as zf:\n for name in zf.namelist():\n encoded_name = name.decode('euc-kr').encode('utf-8')\n logger.info(\"%s(%s), %s(%s), %s, %s\", encoded_name, type(encoded_name), zip_path, type(zip_path),\n [to_hex(c) for c in name], [to_hex(c) for c in zip_path])\n if encoded_name == zip_path:\n with zf.open(name) as f:\n bytesIO = BytesIO()\n bytesIO.write(f.read())\n bytesIO.seek(0)\n return flask.send_file(bytesIO, attachment_filename=os.path.basename(zip_path), as_attachment=True)\n logger.error(\"No file Name: %s\", zip_path)\n return ('', 204)","def write_zip(self, zip_file, callback=None):\n\n def _cb(*args):\n if callback:\n callback(*args)\n\n try:\n _cb('zip-in-progress', True)\n curr_path = os.path.dirname(os.path.abspath(__file__))\n save_path = curr_path + \"/user_downloads\"\n\n if not os.path.exists(save_path):\n os.makedirs(save_path)\n\n name_of_file = \"gmail_images.zip\"\n full_file_name = os.path.join(save_path, name_of_file)\n fp = open(full_file_name, \"w\")\n fp.write(zip_file)\n fp.close()\n zip_file.close()\n _cb('zip-complete, True')\n _cb('write-zip', True, name_of_file)\n\n return True\n\n except:\n\n _cb('write-zip', False)\n\n return False","def _iszip(self, filename):\n fname, ext = os.path.splitext(filename)\n return ext in _file_openers.keys()","def _determine_compression_safe_file_opener(self):\n f = gzip.open(self.input_fname, \"r\")\n try:\n f.read(1)\n self._compression_safe_file_opener = gzip.open\n except IOError:\n self._compression_safe_file_opener = open\n finally:\n f.close()","def extracted_file(fname: str):\n new_fname = extract_gzip(fname)\n gzipped = True\n if new_fname is None:\n new_fname = fname\n gzipped = False\n\n try:\n yield new_fname\n finally:\n if gzipped:\n try:\n bgzip_and_name(new_fname)\n except Exception:\n gzip_and_name(new_fname)","def zipfile(filepath, cleanup=False):\n\tzfile = filepath+\".gz\"\n\twith open(filepath, 'rb') as f_in:\n\t\twith gzip.open(zfile, 'wb') as f_out:\n\t\t\tf_out.writelines(f_in)\t\n\t\n\tif cleanup and file_exists(zfile):\n\t\tos.remove(filepath)\n\treturn zfile","def make_zip(self, project):\n return None","def zipfiles (downloadable, name):\n\n print \"compressing files. almost done.\"\n import zipfile\n for book in downloadable:\n if (os.path.exists(os.path.join(name, book[1]))):\n files = os.listdir(os.path.join(name, book[1]))\n cbz = zipfile.ZipFile(os.path.join(name, name + '-' + book[1] + '.cbz'), 'w')\n for file in files:\n cbz.write(os.path.join(name, book[1],file))\n cbz.close()","def extract_file(self):\n# path_destination = os.path.join(\n# self.root, self.resources.replace(\".zip\", \"\"))\n# os.makedirs(path_destination, exist_ok=True)\n shutil.unpack_archive(os.path.join(\n self.root, self.resources), self.root)\n os.remove(os.path.join(self.root, self.resources))","def archive_file(filename, maxsize):#{{{\n if not os.path.exists(filename):\n print(filename, \"does not exist. ignore.\", file=sys.stderr)\n return 1\n\n filesize = os.path.getsize(filename)\n if filesize > maxsize:\n cnt = 0\n zipfile = \"\"\n while 1:\n cnt += 1\n zipfile = \"%s.%d.gz\"%(filename, cnt)\n if not os.path.exists(zipfile):\n break\n # write zip file\n try:\n f_in = open(filename, 'rb')\n except IOError:\n print(\"Failed to read %s\"%(filename), file=sys.stderr)\n return 1\n try:\n f_out = gzip.open(zipfile, 'wb')\n except IOError:\n print(\"Failed to write to %s\"%(zipfile), file=sys.stderr)\n return 1\n\n f_out.writelines(f_in)\n f_out.close()\n f_in.close()\n print(\"%s is archived to %s\"%(filename, zipfile))\n os.remove(filename)\n return 0","def make_zip_file(self, post_content):\n file_path, file_url = self.save_file(post_content['shortcode'] + '.zip', self.make_empty_zip())\n with ZipFile(file_path, 'w') as zipf:\n if post_content['igtv'] is True:\n zipf.writestr('igtv_link.txt', post_content['urls'][0][2])\n else:\n for url in post_content['urls']:\n zipf.writestr(self.get_content_name(url[2]), requests.get(url[2]).content)\n\n if 'text' in post_content:\n zipf.writestr('caption.txt', post_content['text'])\n return file_url","def process(self, event):\n # the file will be processed there\n print event.src_path, event.event_type\n\n if os.path.isfile(\"/Users/filename.zip\") == True:\n os.remove(\"/Users/filename.zip\")\n print (\"existing file is removed \")\n shutil.make_archive(\"directory\", \"zip\", \"/Users/directory/\")\n print (\"delete existing zip file and created a new zip file\")\n else:\n print (\"There is no zip file at the moment\")\n shutil.make_archive(\"directory\",\"zip\", \"/Users/directory\")\n print (\" A new zip file is created now \")","def zip_file(file_path: str) -> str:\n zip_file_path: str = file_path + \".gz\"\n\n print(f\"Compressing {file_path} into {zip_file_path}\")\n timestamp=path.getmtime(file_path)\n with open(file_path, \"rb\") as read_stream:\n with gzip.open(zip_file_path, \"wb\") as write_stream:\n shutil.copyfileobj(read_stream, write_stream)\n os.utime(zip_file_path, (timestamp,timestamp) )\n\n return zip_file_path","def zip_mail(self, comp_filename, zip_path, destination=''):\r\n\r\n pass\r\n # TODO Remodel this.\r","def _get_compressed_file(files, password=None):\n multiple_files = len(files) > 1\n # Replace the data and report type with just `.zip`.\n zipfile = re.sub(r'(_(\\w+))?\\.(\\w+)$', '.zip', files[0].name)\n compression = pyminizip.compress_multiple if multiple_files else pyminizip.compress\n compression([f.name for f in files] if multiple_files else files[0].name, zipfile, password, COMPRESSION_LEVEL)\n return zipfile","def make_zip(self):\n shutil.make_archive(self.name, 'zip', self.name)","def gzip_worker(args):\n\tp = multiprocessing.current_process()\n\tprint('Start zipping %s: %s %s' %(args[1], p.name, p.pid))\n\tpath = args[0]\n\tfilename = args[1]\n\tassert os.path.splitext(filename)[1] == '.fastq', '%s is not a fastq file' %filename \n\t\n\tcall = 'gzip -c ' + os.path.join(path, filename) + ' > ' + os.path.join(path, filename) + '.gz'\n\tsubprocess.call(call, shell=True)\n\tprint('Completed zipping %s: %s %s' %(filename, p.name, p.pid))","def download(request):\n \n\n def make_archive(source, destination):\n print(source, destination)\n base = os.path.basename(destination)\n name = base.split('.')[0]\n format = base.split('.')[1]\n archive_from = os.path.dirname(source)\n archive_to = os.path.basename(source.strip(os.sep))\n print(source, destination, archive_from, archive_to)\n shutil.make_archive(name, format, archive_from, archive_to)\n shutil.move('%s.%s' % (name, format), destination)\n\n user_id = request.session['user_id']\n user_root = request.session['user_root']\n search_id = request.session['search_id']\n logger = Logger(user_root,user_id)\n logger.write(\"start compressing images..\")\n t_start_zip=time.time()\n zip_target = os.path.join(user_root, search_id)\n zip_path = os.path.join(user_root, search_id, \"Color_images.zip\")\n make_archive(zip_target, zip_path)\n print(\"finish zip.\")\n zip_file = open(zip_path, '+rb')\n response = HttpResponse(zip_file, content_type='application/zip')\n response[\n 'Content-Disposition'] = 'attachment; filename=%s' % \"dataset.zip\"\n response['Content-Length'] = os.path.getsize(zip_path)\n zip_file.close()\n logger.write(\"compressing images finished (\"+convert_duration_time(time.time(),t_start_zip)+\"s)\")\n\n return response","def isZipArchive(filepath):\r\n return zipfile.is_zipfile(filepath)","def create_compressed_file(self):\n\t\tself._compressed_file_name = 'c_' + self.file_name\n\t\tself._compressed_save_path = self.full_path.replace(self.file_name, self._compressed_file_name)\n\t\tself._is_png = 'png' in self.file_extension\n\t\tself._is_jpg = 'jpg' in self.file_extension\n\n\t\timage = Image.open(self.full_path)\n\n\t\tif self._is_png:\n\t\t\timage.save(self._compressed_save_path, quality=85, optimize=False, compress_level=9)\n\t\telif self._is_jpg:\n\t\t\timage.save(self._compressed_save_path, quality=85, progressive=False)\n\t\telse:\n\t\t\tprint('Non-recognized asset format!!')\n\t\t\texit()\n\n\t\tself._compressed_file_size = ufo.get_file_size_in_bytes(self._compressed_save_path)\n\n\n\t\ttransfer_path = self._compressed_save_path.replace('c_' + self.file_name, self.file_name).replace('/configuration_files/', '/quasar_site_django/')\n\t\tufo.copy_file_to_path(self._compressed_save_path, transfer_path)","def gzip_assets():\n run('cd %(repo_path)s; python gzip_assets.py' % env)","def prepare_gz(self, filename, *args, **kwargs):\n\n return '/vsigzip/' + filename, args, kwargs","def check_request_and_create_zipfile() -> None:\n\n session = DBSession()\n\n for site_page in session.query(SitePage).filter(SitePage.status != STATUS_ARCHIVE_READY):\n data = create_zipfile(url_page=site_page.url)\n\n site_page.zipfile = pickle.dumps(data)\n site_page.status = STATUS_ARCHIVE_READY\n session.add(site_page)\n session.commit()\n\n session.close()","def unzip_single_file(zip_file_name, output_file_name):\n if not os.path.isfile(output_file_name):\n with open(output_file_name, 'wb') as out_file:\n with zipfile.ZipFile(zip_file_name) as zipped:\n for info in zipped.infolist():\n if output_file_name in info.filename:\n with zipped.open(info) as requested_file:\n out_file.write(requested_file.read())\n return","def _zip_files(self):\n\n zip_file = Path(self.build_directory.parent).joinpath(\n self.package_name + '.zip'\n )\n logger.info('Creating zip file: %s', zip_file)\n\n shutil.make_archive(zip_file.with_suffix(''), 'zip', self.build_directory)\n shutil.move(str(zip_file), self.build_directory)","def prepare_zip_file(self):\n # need the following:\n # 1. readme\n # 2. cleaned features file\n # 3. gene map\n # 4. clean response file\n # 5. run.yml\n # 6. combined viz scores files\n # 7. all top_genes_per_phenotype* files\n # 8. network metadata\n zip_path = os.path.join(\\\n self.job_dir_path, 'download.zip')\n with ZipFile(zip_path, 'w', ZIP_DEFLATED) as zipout:\n\n zipout.write(\\\n '/zip_readmes/README-GP.txt', 'README-GP.txt')\n\n cleaned_features_path = os.path.join(\\\n self.userfiles_dir, self.features_file_relative_path)\n zipout.write(\\\n cleaned_features_path, 'clean_genomic_matrix.txt')\n\n gene_names_map_path = os.path.join(\\\n self.userfiles_dir, self.gene_names_map_relative_path)\n zipout.write(\\\n gene_names_map_path, 'gene_map.txt')\n\n cleaned_response_path = os.path.join(\\\n self.userfiles_dir, self.response_file_relative_path)\n zipout.write(\\\n cleaned_response_path, 'clean_phenotypic_matrix.txt')\n\n zipout.write(\\\n self.yml_path, 'run_params.yml')\n\n # combine viz files\n combined_viz_path = os.path.join(self.job_dir_path, \\\n 'combined_viz.tsv')\n with open(combined_viz_path, 'w') as combo:\n for fidx, fname in enumerate(sorted(self.get_response_files())):\n fpath = os.path.join(self.results_dir_path, fname)\n with open(fpath, 'r') as vizfile:\n for lidx, line in enumerate(vizfile):\n if lidx == 0 and fidx > 0:\n # only print the column labels once\n pass\n else:\n combo.write(line)\n zipout.write(combined_viz_path, 'genes_ranked_per_phenotype.txt')\n\n top_genes_files = [f for f in os.listdir(self.results_dir_path) \\\n if f.startswith('top_genes_per_phenotype')]\n if len(top_genes_files) == 1:\n top_genes_file_path = os.path.join(\\\n self.results_dir_path, top_genes_files[0])\n zipout.write(\\\n top_genes_file_path, 'top_genes_per_phenotype_matrix.txt')\n\n if self.gg_network_metadata_full_path is not None:\n zipout.write(self.gg_network_metadata_full_path, \\\n 'interaction_network.metadata')","def run(self):\n \n try:\n with zipfile.ZipFile(self.tmpArchiveFilePath, 'w', zipfile.ZIP_DEFLATED) as z:\n z.write(self.resultFilePath, self.fileType+'.tif')\n if os.path.isfile(self.resultPrjFilePath):\n z.write(self.resultPrjFilePath, self.fileType+'.prj')\n except:\n msg = traceback.format_exc()\n self.emit( SIGNAL('failed(QString)'), msg)\n return\n \n with open(self.tmpArchiveFilePath, \"rb\") as binFile:\n base64Data = base64.b64encode(binFile.read())\n fileData = ('file_data', self.tmpArchiveFilePath, base64Data)\n \n self.emit( SIGNAL('prep_completed(int, QString, QString, QString, QString)'), self.eventId, self.fileType, fileData[0], fileData[1], fileData[2])\n return","def zip_campaign_files(): # pylint: disable=too-many-locals\n try:\n build_tag = env.get('BUILD_TAG')\n assert Campaign.dump_db() == Campaign.EX_OK\n assert Campaign.dump_artifacts() == Campaign.EX_OK\n with zipfile.ZipFile(f'{build_tag}.zip',\n 'w', zipfile.ZIP_DEFLATED) as zfile:\n zfile.write(f\"{build_tag}.json\")\n for root, _, files in os.walk(build_tag):\n for filename in files:\n zfile.write(os.path.join(root, filename))\n b3resource = boto3.resource(\n 's3', endpoint_url=os.environ[\"S3_ENDPOINT_URL\"])\n dst_s3_url = os.environ[\"S3_DST_URL\"]\n multipart_threshold = 5 * 1024 ** 5 if \"google\" in os.environ[\n \"S3_ENDPOINT_URL\"] else 8 * 1024 * 1024\n tconfig = TransferConfig(multipart_threshold=multipart_threshold)\n bucket_name = urllib.parse.urlparse(dst_s3_url).netloc\n mime_type = mimetypes.guess_type(f'{build_tag}.zip')\n path = urllib.parse.urlparse(dst_s3_url).path.strip(\"/\")\n # pylint: disable=no-member\n b3resource.Bucket(bucket_name).upload_file(\n f'{build_tag}.zip',\n os.path.join(path, f'{build_tag}.zip'),\n Config=tconfig,\n ExtraArgs={'ContentType': mime_type[\n 0] or 'application/octet-stream'})\n dst_http_url = os.environ[\"HTTP_DST_URL\"]\n link = os.path.join(dst_http_url, f'{build_tag}.zip')\n Campaign.__logger.info(\n \"All data were successfully published:\\n\\n%s\", link)\n return Campaign.EX_OK\n except KeyError as ex:\n Campaign.__logger.error(\"Please check env var: %s\", str(ex))\n return Campaign.EX_ZIP_CAMPAIGN_FILES_ERROR\n except botocore.exceptions.NoCredentialsError:\n Campaign.__logger.error(\n \"Please fill ~/.aws/credentials, ~/.boto or set \"\n \"AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY in env\")\n return Campaign.EX_ZIP_CAMPAIGN_FILES_ERROR\n except Exception: # pylint: disable=broad-except\n Campaign.__logger.exception(\"Cannot publish the artifacts\")\n return Campaign.EX_ZIP_CAMPAIGN_FILES_ERROR","def download(self, download) -> None:\n path_cifarh = path.join(self.root, self.filename_cifarh)\n path_cifar = path.join(self.root, self.filename_cifar)\n is_there = path.isfile(path_cifarh) and path.isfile(path_cifar)\n if is_there:\n print(\"Files already exist.\")\n if download == \"force\" or not is_there:\n download_and_extract_archive(\n self.url_cifar, self.root, filename=self.filename_cifar\n )\n download_and_extract_archive(\n self.url_cifarh, self.root, filename=self.filename_cifarh\n )","def test_deferred_close_by_archive(self):\n z = ZipFile(self.f, 'r')\n self.assertIsNotNone(z._a)\n self.assertIsNone(z._stream)\n z.close()\n self.assertIsNone(z._a)","def add(self):\r\n f_name=self.REQUEST.form.get('my_file').filename\r\n if len(f_name.split('\\\\'))>1:\r\n\tf_name=f_name.split('\\\\')[-1]\r\n if f_name:\r\n format=str(f_name).split('.')[-1].upper()\r\n if (format == 'JPG' or format=='JPEG' or format =='GIF' or format=='PNG'):\r\n ret = add_image(self.this(),f_name,self.REQUEST.form.get('my_file'),search_id(self,self.this().objectValues('Image')))\r\n elif format=='ZIP':\r\n val=''\r\n zip_folder=tempfile.mktemp()\r\n os.mkdir(zip_folder)\r\n zip_datei=open(zip_folder+'/'+f_name,'w+')\r\n zip_datei.write(self.REQUEST.form.get('my_file').read())\r\n zip_datei.close()\r\n zip_datei=open(zip_folder+'/'+f_name,'r+')\r\n zf = ZipFile(zip_datei)\r\n for extracted_file in zf.namelist():\r\n format=str(extracted_file).split('.')[-1].upper()\r\n\t if (format == 'JPG' or format=='JPEG' or format =='GIF' or format=='PNG'):\r\n\t extracted=open(zip_folder+'/'+extracted_file,'w+')\r\n\t extracted.write(zf.read(extracted_file))\r\n\t extracted.close()\r\n\t extracted=open(zip_folder+'/'+extracted_file,'r+')\r\n\t val=val+add_image(self.this(),extracted_file,extracted,search_id(self,self.this().objectValues('Image')))\r\n\t extracted.close()\r\n\t os.remove(zip_folder+'/'+extracted_file)\r\n zip_datei.close()\r\n os.remove(zip_folder+'/'+f_name)\r\n os.rmdir(zip_folder)\r\n ret=\"<br>Datei Hochgeladet und entpacket!\"\r\n else:\r\n ret= \"Nur jpg, jpeg, gif, png, oder zip Datei erledigt!\"\r\n else:\r\n ret= \"Nichts war hochgeladet! Ihr Firewall, Proxy oder Sicherheitseinstellungen einrichten!\"\r\n return ret","def download(self, cloud_path):\n zip_file = os.path.join(self.root, ZIPFILE)\n unzip_dir = os.path.join(self.root, UNZIP_NAME)\n\n if os.path.isfile(zip_file):\n logger.debug(f\"File {zip_file} exists. Skip download.\")\n else:\n client = GCSClient()\n object_key = os.path.join(NYU_GCS_PATH, ZIPFILE)\n\n logger.debug(\n f\"Downloading file {zip_file} from gs://{const.GCS_BUCKET}/\"\n f\"{object_key}\"\n )\n client.download(const.GCS_BUCKET, object_key, zip_file)\n\n if os.path.isdir(unzip_dir):\n logger.debug(f\"File {unzip_dir} exists. Skip unzip.\")\n else:\n # unzip the file\n with ZipFile(zip_file, \"r\") as zip_ref:\n zip_ref.extractall(self.root)\n logger.debug(f\"Unzip file from {zip_file}\")","def recompress_fucntion(destination_file, tmp_folder):\n def confirm_new_files(ziplocation):\n \"\"\"\n test if the file.zip/cbz has the same\n amount of files as tmp_folder\n :param ziplocation: string\n :return: bool\n \"\"\"\n try:\n zf = ZipFile(ziplocation)\n filecontents = list(zf.namelist())\n except BadZipFile:\n os.remove(ziplocation)\n print('OUTPUT FILE BROKEN')\n return False\n\n for walk in os.walk(tmp_folder):\n files = [walk[0] + '/' + x for x in walk[2]]\n if len(filecontents) < len(files):\n os.remove(ziplocation)\n shutil.rmtree(tmp_folder)\n print('FILES MISSING')\n return False\n break\n\n return True\n\n zipfile = destination_file[0:-(len('.cbz'))]\n\n if platform.system() != \"Windows\":\n os.sync()\n\n shutil.make_archive(zipfile, 'zip', tmp_folder)\n zipfile += '.zip'\n\n if platform.system() != \"Windows\":\n os.sync()\n\n if not confirm_new_files(zipfile):\n return False\n\n if not os.path.exists(zipfile) or os.path.getsize(zipfile) == 0:\n print('WRITE OUTPUT ERROR')\n if os.path.exists(zipfile):\n os.remove(zipfile)\n\n return False\n\n shutil.move(zipfile, destination_file)\n\n return True","def zip_data(self) -> None:\n zipf = zipfile.ZipFile('output.zip', 'w', zipfile.ZIP_DEFLATED)\n self._zipdir(self.path, zipf)\n zipf.close()","def tar_gz_compress(self, destination):\n\n if destination is not None and isinstance(destination, str):\n with tarfile_open(destination, \"w:gz\") as tar:\n tar.add(self.file)","def zip_open_bin(zip, filename):\n if isinstance(zip, FakeZip):\n return zip.open(filename, 'rb')\n else:\n return zip.open(filename, 'r')","def vcf_compress(fn):\n ret = cmd_exe(f\"vcf-sort {fn} | bgzip > {fn}.gz && tabix {fn}.gz\")","def zip_single_file_output(self, zip_single_file_output):\n\n self._zip_single_file_output = zip_single_file_output","def open_gzip(fn):\n magic = b'\\x1f\\x8b\\x08'\n l = len(magic)\n with open(fn, 'rb') as f:\n file_start = f.read(l)\n f.seek(0)\n # check if the file is compressed\n if file_start.startswith(magic):\n return gzip.open(fn, 'rt')\n # not compressed\n return open(fn, 'rt')","def _maybe_download_and_extract(self, filename):\n if not os.path.exists(self.work_dir):\n os.mkdir(self.work_dir)\n filepath = os.path.join(self.work_dir, filename)\n if not os.path.exists(filepath):\n filepath, _ = urllib.urlretrieve(self.url + filename, filepath)\n statinfo = os.stat(filepath)\n log.info('Successfully downloaded', filename, statinfo.st_size,\n 'bytes.')\n log.info('Extracting zip file ... ')\n f = zipfile.ZipFile(filepath)\n f.extractall(path=self.work_dir)\n log.info('Extraction finished ... ')","def read_zip_file():\n with open(os.path.join(DIST_DIR, \"build.zip\"), \"rb\") as zip_file:\n return zip_file.read()","def clean_gzip():\n this_dir = os.getcwd()\n os.chdir(\"/data/COHERENT2/data/CrystalChar/raw\")\n all_files = glob.glob(\"./**\", recursive=True)\n for f in all_files:\n if \".gz\" in f and \"tar\" not in f:\n print(f)\n sh(\"gunzip \" + f)\n os.chdir(this_dir)","def bgzip_tabix(bedbz2):\n bed = bedbz2.replace(\".bz2\", \"\")\n bedgz = bed + \".gz\"\n tbi = bedgz + \".tbi\"\n if os.path.exists(bedgz) and os.path.exists(tbi):\n print bedgz, tbi, \"has beed generated.\"\n return\n c1 = \"bzip2 -d %s\" % bedbz2\n c2 = \"bgzip %s\" % bed\n c3 = \"tabix -s 1 -b 2 -e 3 %s\" % bedgz\n call_sys([c1, c2, c3])","def close(self):\n self.myzip.close()","def prepare_zip(self, filename, *args, **kwargs):\n\n return '/vsizip/' + filename, args, kwargs","def test_deferred_close_by_archive(self):\n z = ZipFile(self.f, 'w')\n o = z.writestream(FILENAMES[0])\n z.close()\n self.assertIsNotNone(z._a)\n self.assertIsNotNone(z._stream)\n if PY3:\n o.write('testdata')\n else:\n o.write(unicode('testdata'))\n o.close()\n self.assertIsNone(z._a)\n self.assertIsNone(z._stream)\n z.close()","def zip(self):\n global pointer\n global error_flag\n global totalFiles\n while pointer < len(self.files) and ((self.t and not error_flag) or not self.t):\n # Se o modo e' t e a error_flag nao for false entao pode avancar\n # Se o modo nao for t pode avancar sem restricoes\n self.sem.acquire()\n iterator = pointer\n pointer += 1\n self.sem.release()\n if iterator < len(self.files): # Iterator e' o ficheiro que deve ser utilizado pela thread\n File = self.files[iterator]\n if os.path.isfile(File): # Ver se o ficheiro existe\n with ZipFile(File + '.zip', 'w') as zipfile:\n zipfile.write(File) # Zip\n self.totalFilesSem.acquire()\n totalFiles += 1\n self.totalFilesSem.release()\n else:\n print \"O ficheiro\", File, \"não existe.\" # Se nao existir, avisa o utilizador\n error_flag = True # Atualiza a sua propria flag","def do_pack():\n\n now = datetime.now()\n # format the name of the file with the timestamps\n now_year = now.year\n now_month = now.month\n now_day = now.day\n now_hour = now.hour\n now_minute = now.minute\n now_second = now.second\n # apply the format\n file_name = 'versions/web_static_{}{}{}{}{}{}.tgz'.format(\n now_year, now_month, now_day, now_hour, now_minute, now_second\n )\n # All archives must be stored in the folder versions\n local('mkdir -p versions')\n # execute locally the compression of the folder\n command = local(\"tar -cvzf \" + file_name + \" ./web_static/\")\n # return the archive path if the archive has been correctly generated\n if command.succeeded:\n return file_name\n else:\n return None","def hasBzip2():\n return _libsbml.SBMLWriter_hasBzip2()","def open_zip(path, *args, **kwargs):\r\n with contextlib.closing(zipfile.ZipFile(path, *args, **kwargs)) as zip:\r\n yield zip","def AddToZip(self, input_zip, output_zip, input_path=None):\n\n self.UnmountAll()\n\n common.ZipWriteStr(output_zip, \"META-INF/com/google/android/updater-script\",\n \"\\n\".join(self.script) + \"\\n\")\n\n if input_path is None:\n data = input_zip.read(\"OTA/bin/updater\")\n else:\n data = open(input_path, \"rb\").read()\n common.ZipWriteStr(output_zip, \"META-INF/com/google/android/update-binary\",\n data, perms=0o755)","def gunzip_file(gzip_file, base_dir):\n full_gzip_file = os.path.join(base_dir, gzip_file)\n if not gzip_file.endswith(\".gz\"):\n return gzip_file\n gunzip_file = full_gzip_file.replace(\".gz\", \"\")\n with gzip.open(full_gzip_file, 'rb') as f_in:\n with open(gunzip_file, 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)\n # Now that file is extracted. Remove file\n os.remove(full_gzip_file)\n\n return os.path.basename(gunzip_file)","def _extract_gz(src, dst):\n assert src.endswith(\".gz\"), \"{} is not a valid .gz file.\".format(src)\n assert os.path.exists(src), \"{} does not exist.\".format(src)\n\n with gzip.open(src, \"rb\") as f_src:\n # xxx.postfix.gz --> xxx.postfix\n file_name = os.path.basename(src)[:-3]\n with open(os.path.join(dst, file_name), \"wb\") as f_dst:\n shutil.copyfileobj(f_src, f_dst)","def gzip_files(topDir, afni_file,localizerfile):\n\n print 'GZIPPING FILES...'\n\n command1 = \"gzip %s*BRIK\" % (topDir)\n command2 = \"gzip %s*HEAD\" % (topDir)\n command3 = \"gzip %s%s/pb00*\" % (topDir,afni_file)\n command4 = \"gzip %s%s/errts*\" % (topDir,afni_file)\n command5 = \"gzip %s%s/fitts*\" % (topDir,afni_file)\n command6 = \"gzip %s%s/*al*\" % (topDir,afni_file)\n command7 = \"gzip %s%s/*ns*\" % (topDir,afni_file)\n command8 = \"gzip %s%s/all_runs*\" % (topDir,afni_file)\n command9 = \"gzip %s%s/*mask*\" % (topDir,afni_file)\n command10 = \"gzip %s*nii\" % (topDir)\n command11 = \"gzip %s%s/pb01*\" % (topDir,afni_file)\n command12 = \"gzip %s%s/pb03*\" % (topDir,afni_file)\n command13 = \"gzip %s%s/pb02*\" % (topDir,afni_file)\n\n os.system(command1)\n os.system(command2)\n os.system(command3)\n os.system(command4)\n os.system(command5)\n os.system(command6)\n os.system(command7)\n os.system(command8)\n #os.system(command9)\n os.system(command10)\n os.system(command11)\n try:\n os.system(command12)\n except:\n print 'Could not gzip pb03 files'\n\n if localizerfile == 'facescene_loc':\n os.system(command13)","def backup(self):\n if self.url is not None:\n\n # zip backup folder\n zipapp.create_archive(self.logs_directory, self.send_zip)\n\n # then send zipped folder to the URL\n try:\n requests.post(self.url, files={\n 'uploaded_file': (os.path.basename(self.send_zip), open(self.send_zip, 'rb')),\n })\n except requests.exceptions.ConnectionError as error:\n print(error)","def compress_files(self):\n archive_file_path = tkinter.filedialog.asksaveasfilename(parent=self,\n defaultextension=\".zip\",\n filetypes=[(\"Zip File\", \"*.zip\")])\n treeview_items = self.files_treeview.get_children()\n if archive_file_path and treeview_items:\n with ZipFile(archive_file_path, \"w\", ZIP_DEFLATED) as archive:\n for row in treeview_items:\n file_path = self.files_treeview.item(row, \"values\")[0]\n file_name = os.path.basename(file_path)\n archive.write(file_path, arcname=file_name)","def test_compress_file_response(self):\n with open(__file__, \"rb\") as file1:\n\n def get_response(req):\n file_resp = FileResponse(file1)\n file_resp[\"Content-Type\"] = \"text/html; charset=UTF-8\"\n return file_resp\n\n r = GZipMiddleware(get_response)(self.req)\n with open(__file__, \"rb\") as file2:\n self.assertEqual(self.decompress(b\"\".join(r)), file2.read())\n self.assertEqual(r.get(\"Content-Encoding\"), \"gzip\")\n self.assertIsNot(r.file_to_stream, file1)","def _gzip_file(filename):\n gzip_filename = filename + '.gz'\n with open(filename, 'rb') as f_in, gzip.open(gzip_filename, 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)","def store_source(zipfile_name, directory, storage_directory):\n if directory in ZIP_EXCLUDES:\n zip_command = ['zip', '-x ' + '-x'.join(ZIP_EXCLUDES[directory]), '-r', zipfile_name, directory]\n else:\n zip_command = ['zip', '-r', zipfile_name, directory]\n\n if exists(zipfile_name):\n os.remove(zipfile_name)\n\n try:\n logging.debug('Zipping Source: %s', zip_command)\n check_output(zip_command)\n except CalledProcessError as build_error:\n logging.error('Could not zip source, Return Code %s, Command %s', build_error.returncode, build_error.cmd)\n logging.error(build_error.output)\n os.remove(zipfile_name)\n return False\n\n qmk_storage.save_file(zipfile_name, os.path.join(storage_directory, zipfile_name), 'application/zip')\n os.remove(zipfile_name)\n\n return True","def create_zip_file():\n shutil.make_archive(os.path.join(DIST_DIR, \"build\"), \"zip\", BUILD_DIR)","def _zipfile_single_file_extract_worker(\n zip_file_path: Path,\n file_in_archive: zipfile.ZipInfo,\n destination_folder: Path,\n is_dir: bool,\n) -> Path:\n with _FastZipFileReader(zip_file_path) as zf:\n # assemble destination and ensure it exits\n destination_path = destination_folder / file_in_archive.filename\n\n if is_dir:\n destination_path.mkdir(parents=True, exist_ok=True)\n return destination_path\n desc = f\"decompressing {zip_file_path}:{file_in_archive.filename} -> {destination_path}\\n\"\n with zf.open(name=file_in_archive) as zip_fp, destination_path.open(\n \"wb\"\n ) as dest_fp, tqdm_logging_redirect(\n total=file_in_archive.file_size,\n desc=desc,\n **(\n _TQDM_FILE_OPTIONS\n | dict(miniters=_compute_tqdm_miniters(file_in_archive.file_size))\n ),\n ) as pbar:\n while chunk := zip_fp.read(_CHUNK_SIZE):\n dest_fp.write(chunk)\n pbar.update(len(chunk))\n return destination_path","def gunzip_file(gz_path, new_path):\n print(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def main():\n if len(sys.argv) != 2:\n print(\"Error: Incorrect number of arguments. Expected 1.\")\n print(\"Usage: python compress.py <path to file to compress>\")\n print(\"Example: python compress.py zones.json\")\n exit(1)\n\n with open(sys.argv[1], \"rb\") as r, \\\n open(\"{}.br\".format(sys.argv[1]), \"wb\") as w:\n w.write(brotli.compress(r.read()))","def checkBZ2(path):\n devnull = open('/dev/null', 'w+')\n proc = subprocess.Popen(['/usr/bin/bzip2', '-t', path], shell=False,\n stdin=devnull, stdout=devnull, stderr=devnull)\n proc.communicate()\n return proc.returncode == 0","def is_archive(afile):\n return file_ext(os.path.basename(afile)) in ARCHIVE_COMPRESS_FORMATS","def start():\n filePath = area.get()\n okMes.pack_forget()\n errMes.pack_forget()\n if is_zipfile(filePath):\n z = ZipFile(filePath, 'r')\n z.extractall()\n z.close()\n okMes.pack()\n else:\n \terrMes.pack()","def downloadZip(self, resource, fp):\n\n self._stayAlive()\n\n res = self.s.get(self.fullUrl(resource), stream = True)\n if res.ok:\n with fp.open('wb') as f:\n shutil.copyfileobj(res.raw, f)\n return res.status_code\n else:\n return None","def hasBzip2():\n return _libsbml.SBMLReader_hasBzip2()","def SBMLWriter_hasBzip2():\n return _libsbml.SBMLWriter_hasBzip2()","def on_post(self, req, resp):\n LOGGER = logging.getLogger()\n \n resp.set_header('Content-Type', 'text/json')\n raw_json = req.stream.read().decode('utf-8')\n content = json.loads(raw_json, encoding='utf-8')\n\n try:\n files = content.get(\"files\")\n zip_name = content.get(\"name\")\n zip_file = DownloadFilesResource.compress_files(files, zip_name)\n resp.body = json.dumps({'file': zip_file})\n LOGGER.info(\"Zip created and ready to download\")\n except Exception as e:\n LOGGER.error(\"Error creating zip file\" , exc_info=True)\n raise falcon.HTTPInternalServerError(title=\"Error downloading files: \" + str(type(e)),\n description=(str(e) +\n ','.join(traceback.format_tb(e.__traceback__))))","def dir_2_cbz(dir_pth):\r\n shutil.make_archive(dir_pth, 'zip', dir_pth)\r\n shutil.rmtree(dir_pth)\r\n os.rename(dir_pth+'.zip', dir_pth+'.cbz')\r\n pass","def gunzip_file(gz_path, new_path):\n logging.info(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def _compress_meds_file(self, ucfilename, fzfilename):\n from os.path import basename\n\n tup=(basename(ucfilename),basename(fzfilename))\n print('compressing file: %s -> %s' % tup)\n tpath=files.expandpath(fzfilename)\n if os.path.exists(tpath):\n os.remove(tpath)\n\n tmpdir = os.path.dirname(ucfilename)\n with StagedOutFile(fzfilename,tmpdir=tmpdir) as sf:\n cmd = self['fpack_command']\n cmd = cmd.format(fname=ucfilename)\n ret=os.system(cmd)\n\n if ret != 0:\n raise RuntimeError(\"failed to compress file\")\n\n print('output is in:',fzfilename)","def main(file_url, file_path):\n\n # extract file from the link\n\n if not os.path.exists(file_path):\n os.makedirs(file_path, exist_ok=True)\n \n r = requests.get(str(file_url))\n\n #unzip the zip file\n z = zipfile.ZipFile(io.BytesIO(r.content))\n z.extractall(path = file_path)","def testZipUrl(self):\n try:\n remoteLocator = self.__zipFileUrl\n # fn = self.__fileU.getFileName(remoteLocator)\n ok = self.__fileU.isLocal(remoteLocator)\n self.assertFalse(ok)\n #\n lPath = os.path.join(self.__workPath, self.__fileU.getFileName(self.__zipFileUrl))\n ok = self.__fileU.get(remoteLocator, lPath)\n self.assertTrue(ok)\n ok = self.__fileU.exists(lPath)\n self.assertTrue(ok)\n ok = self.__fileU.isLocal(lPath)\n self.assertTrue(ok)\n tPath = self.__fileU.getFilePath(lPath)\n self.assertEqual(lPath, tPath)\n fp = self.__fileU.uncompress(lPath, outputDir=self.__workPath)\n ok = fp.endswith(\"Food_Display_Table.xlsx\")\n self.assertTrue(ok)\n\n except Exception as e:\n logger.exception(\"Failing with %s\", str(e))\n self.fail()","def test_zip_files(self):\n base_zip_files = ['whypython.txt', 'states.dbf', 'cities.kmz']\n\n text_file = os.path.join(os.getcwd(), 'test-data', 'whypython.txt')\n dbf_file = os.path.join(os.getcwd(), 'test-data', 'states.dbf')\n kml_file = os.path.join(os.getcwd(), 'test-data', 'cities.kmz')\n #non_file = os.path.join(os.getcwd(), 'test-data', 'emptyfolder')\n self.request['params'][0]['response']['docs'][0]['path'] = text_file\n self.request['params'][0]['response']['docs'][1]['path'] = dbf_file\n self.request['params'][0]['response']['docs'][2]['path'] = kml_file\n #self.request['params'][0]['response']['docs'][3]['path'] = non_file\n __import__(self.request['task'])\n getattr(sys.modules[self.request['task']], \"execute\")(self.request)\n zip_files = zipfile.ZipFile(os.path.join(self.temp_folder, 'output.zip')).namelist()\n self.assertEqual(sorted(zip_files), sorted(base_zip_files))","def decompress_files(self):\n crx2rnx_path = os.path.join(ROOT_DIR, 'CRX2RNX')\n if not os.path.isfile(crx2rnx_path):\n raise OSError('Cannot find CRX2RNX binary in project directory!')\n\n if glob('{}/*'.format(self.__directory)):\n subprocess.run([\"gunzip\", \"-dr\", self.__directory])\n # convert Hatanaka compressed RINEX to standard RINEX\n for f in glob('{}/*.??d'.format(self.__directory)):\n subprocess.run([crx2rnx_path, f])\n else:\n raise RuntimeError(\n 'Could not decompress. No files were downloaded from FTP server.')","def isgzip(filename):\n magic_number = b'\\x1f\\x8b\\x08'\n with open(filename, 'rb') as f:\n file_start = f.read(len(magic_number))\n\n if magic_number == file_start:\n return True\n return False","def is_zipfile(filename):\n\n import zipfile\n\n return zipfile.is_zipfile(filename)","def _is_archive(local_path: str) -> bool:\n archive_mimetypes = [\n \"application/zip\",\n \"application/x-tar\",\n \"application/x-gzip\",\n \"application/x-bzip2\",\n \"application/x-7z-compressed\",\n \"application/x-rar-compressed\",\n \"application/x-xz\",\n \"application/x-lzip\",\n \"application/x-lzma\",\n \"application/x-lzop\",\n \"application/x-bzip\",\n \"application/x-bzip2\",\n \"application/x-compress\",\n \"application/x-compressed\",\n ]\n\n return mimetypes.guess_type(local_path)[0] in archive_mimetypes","def load_zip_folder(req_path, name, ext, zip_path):\n BASE_DIR = ROOT\n full_path = \"%s/%s.%s\" % (req_path, name, ext)\n full_real_path = get_real_path(BASE_DIR, full_path)\n try:\n zip_path = unquote(zip_path).encode('utf-8')\n except Exception as e:\n logger.info(\"Failed to encode: %s\", zip_path)\n\n if not os.path.exists(full_real_path):\n logger.error(\"No Path: %s\", full_real_path)\n return ('', 204)\n\n if ext not in archive_exts:\n return ('', 204)\n\n #get list of files in folder in zip file\n data = ComixData(Directories=[], Files=[])\n with zipfile.ZipFile(full_real_path) as zf:\n for name in zf.namelist():\n name = name.decode('euc-kr').encode('utf-8')\n pardir, basename = os.path.split(name)\n if basename and zip_path == pardir:\n logger.info(\"get_files_in_zip_path: %s, %s\", pardir, basename)\n data.Files.append(basename)\n if len(data.Files):\n response = flask.Response(json.dumps(data._asdict(), ensure_ascii=False), headers=None)\n return response\n\n return ('', 204)","def is_gz_file(f):\n with open(f, \"rb\") as fin:\n return binascii.hexlify(fin.read(2)) == b\"1f8b\"","def download_file(url, path):\n file_name = path + url.split(\"/\")[-1]\n req = requests.get(url)\n zipped_info = req.content\n print(file_name)\n if not os.path.isfile(file_name):\n print(\"file doesnt exist, writing\", file_name)\n with open(file_name, 'wb') as f:\n f.write(zipped_info)\n else:\n print(\"file exists\", file_name)","def upload_nextcloud_zipfile(import_type: migration.Migration, archive: UploadFile = File(...)):\n dir = app_dirs.MIGRATION_DIR.joinpath(import_type.value)\n dir.mkdir(parents=True, exist_ok=True)\n dest = dir.joinpath(archive.filename)\n\n with dest.open(\"wb\") as buffer:\n shutil.copyfileobj(archive.file, buffer)\n\n if not dest.is_file:\n raise HTTPException(status.HTTP_400_BAD_REQUEST)","def extract_gzip(fname: str, outfile: Optional[str] = None) -> Union[str, None]:\n if not outfile:\n outfile = fname[:-3]\n\n if fname.endswith(\".gz\"):\n with gzip.open(fname, \"rb\") as f_in:\n with open(outfile, \"wb\") as f_out:\n shutil.copyfileobj(f_in, f_out)\n os.unlink(fname)\n return outfile","def compress():\n run_manage_cmd('compress_assets')","def zip_file(backup_objects):\n\n # Get name from date_time\n name_of_zip_file = (get_date(\"%d%m%Y_%H.%S\") + '.zip')\n # put files in zip archiv\n z = zipfile.ZipFile(name_of_zip_file, 'a', zipfile.ZIP_DEFLATED) # create archive\n for i in backup_objects:\n if os.path.isdir(i):\n for root, dirs, files in os.walk(i): # get list of files in folder\n for file in files:\n z.write(os.path.join(root, file)) # Создание относительных путей и запись файлов в архив\n else:\n z.write(i)\n z.close()\n if zipfile.is_zipfile(name_of_zip_file):\n notest_file(\"arckhiving is conplite! Created file\" + name_of_zip_file)\n return name_of_zip_file","def zipsave(self):\n\n filename = filedialog.asksaveasfilename(initialdir=self.root.cache_dir,\n title='Save As',\n filetypes=[('Zip', '.zip')],\n defaultextension='')\n self.save_entry.clear()\n self.save_entry.insert(tk.END, filename)\n self.root.cache_dir = filename","def open(self, *args, **kwargs):\n return ZipFileArchiver(*args,**kwargs)","def _gz(filename):\n \n with open(filename, 'rb') as f:\n return binascii.hexlify(f.read(2)) == b'1f8b'","def gunzip_file(gz_path, new_path):\n print(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)","def __do_zip_binary_install(export_zip, item):\n\n # First copy the new file.\n if export_zip.install_item_to(item, DTF_BINARIES_DIR) != 0:\n log.e(TAG, \"Error copying binary '%s'\" % item.local_name)\n return -1\n\n # Update database\n if __update_binary(item) == 0:\n log.e(TAG, \"Failed to update binary '%s' details in database.\"\n % (item.name))\n return -2\n\n return 0"],"string":"[\n \"def compressIfNeeded(self):\\n\\n if self._mode == \\\"zip\\\":\\n zip_folder(self._rootExportPath, self.getZipArchiveFullPath())\",\n \"def zipFasta(self):\\n utils.log(\\\"zipping {} ...\\\".format(self.fastaFileName))\\n cmd = \\\"bgzip -f {}\\\".format(self.fastaFileName)\\n utils.runCommand(cmd)\",\n \"def _check_zip_file (filename, path_unzip, outfile) :\\n assert path_unzip is not None\\n file,ext = os.path.splitext (filename)\\n ext = ext.lower ()\\n if ext == \\\".gz\\\" :\\n \\n import gzip\\n \\n if outfile is None :\\n dest = filename.split (\\\"!\\\")\\n dest = dest [ len(dest)-1 ]\\n ext = os.path.splitext (dest) [1]\\n dest = dest.replace (ext, \\\".txt\\\")\\n path = os.path.split (filename)\\n path = \\\"/\\\".join (path [:len (path)-1])\\n dest = path + \\\"/\\\" + dest\\n else :\\n dest = outfile\\n \\n if not os.path.exists (dest) :\\n file = gzip.GzipFile (filename, \\\"r\\\")\\n if outfile is None :\\n dest = os.path.split (dest) [1]\\n dest = os.path.join (path_unzip, dest)\\n \\n if os.path.exists (dest) :\\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\\n if st2 > st1 : \\n fLOG (\\\"ungzipping file (already done)\\\", dest)\\n return dest\\n \\n fLOG (\\\"ungzipping file\\\", dest)\\n f = open (dest, \\\"w\\\")\\n data = file.read (2**27)\\n size = 0\\n while len (data) > 0 :\\n size += len (data)\\n fLOG (\\\"ungzipping \\\", size, \\\"bytes\\\")\\n if isinstance (data, bytes) : f.write (bytes.decode (data))\\n else : f.write (data)\\n data = file.read (2**27)\\n f.close ()\\n file.close ()\\n \\n return dest\\n \\n if ext == \\\".zip\\\" :\\n \\n import zipfile\\n try :\\n file = zipfile.ZipFile (filename, \\\"r\\\")\\n except Exception as e :\\n fLOG (\\\"problem with \\\", filename)\\n raise e\\n \\n if len (file.infolist()) != 1:\\n if outfile is not None :\\n raise PQHException (\\\"the archive contains %d files and not one as you expected by filling outfile\\\" % len (file.infolist()))\\n fLOG (\\\"unzip file (multiple) \\\", filename)\\n #message = \\\"\\\\n\\\".join ([ fi.filename for fi in file.infolist() ] )\\n #raise Exception.YstException(\\\"ColumnInfoSet.load_from_file: file %s contains no file or more than one file\\\\n\\\" + message)\\n folder = os.path.split (filename) [0]\\n todo = 0\\n _zip7_path = r\\\"c:\\\\Program Files\\\\7-Zip\\\"\\n zip7 = os.path.exists (_zip7_path)\\n wait = [ ]\\n for info in file.infolist () :\\n fileinside = info.filename\\n dest = os.path.join (folder, fileinside)\\n if not os.path.exists (dest) :\\n fol = os.path.split (dest) [0]\\n if not os.path.exists (fol) : os.makedirs (fol)\\n if os.path.exists (dest) :\\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\\n if st2 > st1 : \\n continue\\n \\n if not sys.platform.startswith(\\\"win\\\") or not zip7 :\\n data = file.read (fileinside)\\n dest = os.path.split (dest) [1]\\n dest = os.path.join (path_unzip, dest)\\n fLOG (\\\"unzipping file\\\", dest)\\n wait.append(dest)\\n f = open (dest, \\\"w\\\")\\n if isinstance (data, bytes) :\\n f.write (str (data))\\n else :\\n f.write (data)\\n f.close ()\\n else :\\n todo += 1\\n \\n if todo > 0 and zip7 :\\n dest = os.path.realpath (path_unzip)\\n cmd = '\\\"' + _zip7_path + '\\\\\\\\7z.exe\\\" e -y -o\\\"%s\\\" \\\"%s\\\"' % (dest, os.path.realpath (filename)) \\n out,err = run_cmd (cmd, wait = True)\\n if len (err) > 0 : raise PQHException (\\\"command {0} failed\\\\n{1}\\\".format(cmd,err))\\n if \\\"Error\\\" in out : raise PQHException (\\\"command {0} failed\\\\n{1}\\\".format(cmd,out))\\n else :\\n dest = path_unzip\\n \\n file.close ()\\n \\n ch = False\\n while not ch :\\n ch = True\\n for a in wait :\\n if not os.path.exists(a) : \\n ch = False\\n break\\n time.sleep(0.5)\\n \\n return dest\\n \\n else :\\n for info in file.infolist () :\\n fileinside = info.filename\\n \\n path = os.path.split (filename)\\n dest = outfile if outfile is not None else path [0] + \\\"/\\\" + fileinside\\n if not os.path.exists (dest) :\\n data = file.read (fileinside)\\n if outfile is None :\\n dest = os.path.split (dest) [1]\\n dest = os.path.join (path_unzip, dest)\\n \\n if os.path.exists (dest) :\\n st1 = datetime.datetime.utcfromtimestamp (os.stat (filename).st_mtime)\\n st2 = datetime.datetime.utcfromtimestamp (os.stat (dest).st_mtime)\\n if st2 > st1 : \\n fLOG(\\\"unzipping one file (already done)\\\", dest)\\n return dest\\n \\n fLOG(\\\"unzipping one file\\\", dest)\\n f = open (dest, \\\"w\\\")\\n if isinstance (data, bytes) :\\n f.write (bytes.decode (data))\\n else :\\n f.write (data)\\n f.close ()\\n file.close ()\\n return dest\\n \\n return filename\",\n \"def handle_file(self, path):\\n\\n if path:\\n if not matches_patterns(path, self.gzip_patterns):\\n return\\n\\n try:\\n original_file = self.open(path, mode=\\\"rb\\\")\\n except FileNotFoundError:\\n pass\\n else:\\n gzipped_path = \\\"{0}.gz\\\".format(path)\\n\\n if self.exists(gzipped_path):\\n self.delete(gzipped_path)\\n\\n gzipped_file = self._compress(original_file)\\n gzipped_path = self.save(gzipped_path, gzipped_file)\\n\\n return gzipped_path, gzipped_path, True\",\n \"def is_zip(filepath):\\n\\treturn os.path.splitext(filepath)[1] == '.gz'\",\n \"def _open_zip(self):\\n self.buffer = io.BytesIO()\\n self.zf = zipfile.ZipFile(self.buffer, \\\"w\\\", zipfile.ZIP_DEFLATED)\",\n \"def zip_compress(self, destination):\\n\\n if destination is not None and isinstance(destination, str):\\n with ZipFile(destination, \\\"w\\\") as thezip:\\n thezip.write(self.file)\",\n \"def finalize_zip(zip, filename):\\n zip.close()\\n with open(filename, 'wb') as file:\\n file.write(zipbytes.getvalue())\",\n \"def load_file_in_archive(req_path, archive, archive_ext, zip_path, name, ext):\\n BASE_DIR = ROOT\\n full_path = u\\\"%s/%s.%s\\\" % (req_path, archive, archive_ext)\\n zip_path = u\\\"%s/%s.%s\\\" % (zip_path, name, ext)\\n full_real_path = get_real_path(BASE_DIR, full_path)\\n logger.info(\\\"%s, %s\\\", full_real_path, [to_hex(c) for c in full_real_path])\\n try:\\n zip_path = unquote(zip_path).encode('utf-8')\\n except Exception as e:\\n logger.info(\\\"Failed to encode: %s\\\", zip_path)\\n\\n if ext == 'thm' or archive_ext not in archive_exts:\\n logger.info(\\\"Unsupported file\\\")\\n return ('', 204)\\n\\n if os.path.exists(full_real_path.encode('utf-8')):\\n logger.info(\\\"File doesn't exist: %s\\\", full_real_path)\\n return ('', 204)\\n\\n #Only zip files are supported <path>/file.zip/1/01.jpg\\n ## Render single file\\n with zipfile.ZipFile(full_real_path) as zf:\\n for name in zf.namelist():\\n encoded_name = name.decode('euc-kr').encode('utf-8')\\n logger.info(\\\"%s(%s), %s(%s), %s, %s\\\", encoded_name, type(encoded_name), zip_path, type(zip_path),\\n [to_hex(c) for c in name], [to_hex(c) for c in zip_path])\\n if encoded_name == zip_path:\\n with zf.open(name) as f:\\n bytesIO = BytesIO()\\n bytesIO.write(f.read())\\n bytesIO.seek(0)\\n return flask.send_file(bytesIO, attachment_filename=os.path.basename(zip_path), as_attachment=True)\\n logger.error(\\\"No file Name: %s\\\", zip_path)\\n return ('', 204)\",\n \"def write_zip(self, zip_file, callback=None):\\n\\n def _cb(*args):\\n if callback:\\n callback(*args)\\n\\n try:\\n _cb('zip-in-progress', True)\\n curr_path = os.path.dirname(os.path.abspath(__file__))\\n save_path = curr_path + \\\"/user_downloads\\\"\\n\\n if not os.path.exists(save_path):\\n os.makedirs(save_path)\\n\\n name_of_file = \\\"gmail_images.zip\\\"\\n full_file_name = os.path.join(save_path, name_of_file)\\n fp = open(full_file_name, \\\"w\\\")\\n fp.write(zip_file)\\n fp.close()\\n zip_file.close()\\n _cb('zip-complete, True')\\n _cb('write-zip', True, name_of_file)\\n\\n return True\\n\\n except:\\n\\n _cb('write-zip', False)\\n\\n return False\",\n \"def _iszip(self, filename):\\n fname, ext = os.path.splitext(filename)\\n return ext in _file_openers.keys()\",\n \"def _determine_compression_safe_file_opener(self):\\n f = gzip.open(self.input_fname, \\\"r\\\")\\n try:\\n f.read(1)\\n self._compression_safe_file_opener = gzip.open\\n except IOError:\\n self._compression_safe_file_opener = open\\n finally:\\n f.close()\",\n \"def extracted_file(fname: str):\\n new_fname = extract_gzip(fname)\\n gzipped = True\\n if new_fname is None:\\n new_fname = fname\\n gzipped = False\\n\\n try:\\n yield new_fname\\n finally:\\n if gzipped:\\n try:\\n bgzip_and_name(new_fname)\\n except Exception:\\n gzip_and_name(new_fname)\",\n \"def zipfile(filepath, cleanup=False):\\n\\tzfile = filepath+\\\".gz\\\"\\n\\twith open(filepath, 'rb') as f_in:\\n\\t\\twith gzip.open(zfile, 'wb') as f_out:\\n\\t\\t\\tf_out.writelines(f_in)\\t\\n\\t\\n\\tif cleanup and file_exists(zfile):\\n\\t\\tos.remove(filepath)\\n\\treturn zfile\",\n \"def make_zip(self, project):\\n return None\",\n \"def zipfiles (downloadable, name):\\n\\n print \\\"compressing files. almost done.\\\"\\n import zipfile\\n for book in downloadable:\\n if (os.path.exists(os.path.join(name, book[1]))):\\n files = os.listdir(os.path.join(name, book[1]))\\n cbz = zipfile.ZipFile(os.path.join(name, name + '-' + book[1] + '.cbz'), 'w')\\n for file in files:\\n cbz.write(os.path.join(name, book[1],file))\\n cbz.close()\",\n \"def extract_file(self):\\n# path_destination = os.path.join(\\n# self.root, self.resources.replace(\\\".zip\\\", \\\"\\\"))\\n# os.makedirs(path_destination, exist_ok=True)\\n shutil.unpack_archive(os.path.join(\\n self.root, self.resources), self.root)\\n os.remove(os.path.join(self.root, self.resources))\",\n \"def archive_file(filename, maxsize):#{{{\\n if not os.path.exists(filename):\\n print(filename, \\\"does not exist. ignore.\\\", file=sys.stderr)\\n return 1\\n\\n filesize = os.path.getsize(filename)\\n if filesize > maxsize:\\n cnt = 0\\n zipfile = \\\"\\\"\\n while 1:\\n cnt += 1\\n zipfile = \\\"%s.%d.gz\\\"%(filename, cnt)\\n if not os.path.exists(zipfile):\\n break\\n # write zip file\\n try:\\n f_in = open(filename, 'rb')\\n except IOError:\\n print(\\\"Failed to read %s\\\"%(filename), file=sys.stderr)\\n return 1\\n try:\\n f_out = gzip.open(zipfile, 'wb')\\n except IOError:\\n print(\\\"Failed to write to %s\\\"%(zipfile), file=sys.stderr)\\n return 1\\n\\n f_out.writelines(f_in)\\n f_out.close()\\n f_in.close()\\n print(\\\"%s is archived to %s\\\"%(filename, zipfile))\\n os.remove(filename)\\n return 0\",\n \"def make_zip_file(self, post_content):\\n file_path, file_url = self.save_file(post_content['shortcode'] + '.zip', self.make_empty_zip())\\n with ZipFile(file_path, 'w') as zipf:\\n if post_content['igtv'] is True:\\n zipf.writestr('igtv_link.txt', post_content['urls'][0][2])\\n else:\\n for url in post_content['urls']:\\n zipf.writestr(self.get_content_name(url[2]), requests.get(url[2]).content)\\n\\n if 'text' in post_content:\\n zipf.writestr('caption.txt', post_content['text'])\\n return file_url\",\n \"def process(self, event):\\n # the file will be processed there\\n print event.src_path, event.event_type\\n\\n if os.path.isfile(\\\"/Users/filename.zip\\\") == True:\\n os.remove(\\\"/Users/filename.zip\\\")\\n print (\\\"existing file is removed \\\")\\n shutil.make_archive(\\\"directory\\\", \\\"zip\\\", \\\"/Users/directory/\\\")\\n print (\\\"delete existing zip file and created a new zip file\\\")\\n else:\\n print (\\\"There is no zip file at the moment\\\")\\n shutil.make_archive(\\\"directory\\\",\\\"zip\\\", \\\"/Users/directory\\\")\\n print (\\\" A new zip file is created now \\\")\",\n \"def zip_file(file_path: str) -> str:\\n zip_file_path: str = file_path + \\\".gz\\\"\\n\\n print(f\\\"Compressing {file_path} into {zip_file_path}\\\")\\n timestamp=path.getmtime(file_path)\\n with open(file_path, \\\"rb\\\") as read_stream:\\n with gzip.open(zip_file_path, \\\"wb\\\") as write_stream:\\n shutil.copyfileobj(read_stream, write_stream)\\n os.utime(zip_file_path, (timestamp,timestamp) )\\n\\n return zip_file_path\",\n \"def zip_mail(self, comp_filename, zip_path, destination=''):\\r\\n\\r\\n pass\\r\\n # TODO Remodel this.\\r\",\n \"def _get_compressed_file(files, password=None):\\n multiple_files = len(files) > 1\\n # Replace the data and report type with just `.zip`.\\n zipfile = re.sub(r'(_(\\\\w+))?\\\\.(\\\\w+)$', '.zip', files[0].name)\\n compression = pyminizip.compress_multiple if multiple_files else pyminizip.compress\\n compression([f.name for f in files] if multiple_files else files[0].name, zipfile, password, COMPRESSION_LEVEL)\\n return zipfile\",\n \"def make_zip(self):\\n shutil.make_archive(self.name, 'zip', self.name)\",\n \"def gzip_worker(args):\\n\\tp = multiprocessing.current_process()\\n\\tprint('Start zipping %s: %s %s' %(args[1], p.name, p.pid))\\n\\tpath = args[0]\\n\\tfilename = args[1]\\n\\tassert os.path.splitext(filename)[1] == '.fastq', '%s is not a fastq file' %filename \\n\\t\\n\\tcall = 'gzip -c ' + os.path.join(path, filename) + ' > ' + os.path.join(path, filename) + '.gz'\\n\\tsubprocess.call(call, shell=True)\\n\\tprint('Completed zipping %s: %s %s' %(filename, p.name, p.pid))\",\n \"def download(request):\\n \\n\\n def make_archive(source, destination):\\n print(source, destination)\\n base = os.path.basename(destination)\\n name = base.split('.')[0]\\n format = base.split('.')[1]\\n archive_from = os.path.dirname(source)\\n archive_to = os.path.basename(source.strip(os.sep))\\n print(source, destination, archive_from, archive_to)\\n shutil.make_archive(name, format, archive_from, archive_to)\\n shutil.move('%s.%s' % (name, format), destination)\\n\\n user_id = request.session['user_id']\\n user_root = request.session['user_root']\\n search_id = request.session['search_id']\\n logger = Logger(user_root,user_id)\\n logger.write(\\\"start compressing images..\\\")\\n t_start_zip=time.time()\\n zip_target = os.path.join(user_root, search_id)\\n zip_path = os.path.join(user_root, search_id, \\\"Color_images.zip\\\")\\n make_archive(zip_target, zip_path)\\n print(\\\"finish zip.\\\")\\n zip_file = open(zip_path, '+rb')\\n response = HttpResponse(zip_file, content_type='application/zip')\\n response[\\n 'Content-Disposition'] = 'attachment; filename=%s' % \\\"dataset.zip\\\"\\n response['Content-Length'] = os.path.getsize(zip_path)\\n zip_file.close()\\n logger.write(\\\"compressing images finished (\\\"+convert_duration_time(time.time(),t_start_zip)+\\\"s)\\\")\\n\\n return response\",\n \"def isZipArchive(filepath):\\r\\n return zipfile.is_zipfile(filepath)\",\n \"def create_compressed_file(self):\\n\\t\\tself._compressed_file_name = 'c_' + self.file_name\\n\\t\\tself._compressed_save_path = self.full_path.replace(self.file_name, self._compressed_file_name)\\n\\t\\tself._is_png = 'png' in self.file_extension\\n\\t\\tself._is_jpg = 'jpg' in self.file_extension\\n\\n\\t\\timage = Image.open(self.full_path)\\n\\n\\t\\tif self._is_png:\\n\\t\\t\\timage.save(self._compressed_save_path, quality=85, optimize=False, compress_level=9)\\n\\t\\telif self._is_jpg:\\n\\t\\t\\timage.save(self._compressed_save_path, quality=85, progressive=False)\\n\\t\\telse:\\n\\t\\t\\tprint('Non-recognized asset format!!')\\n\\t\\t\\texit()\\n\\n\\t\\tself._compressed_file_size = ufo.get_file_size_in_bytes(self._compressed_save_path)\\n\\n\\n\\t\\ttransfer_path = self._compressed_save_path.replace('c_' + self.file_name, self.file_name).replace('/configuration_files/', '/quasar_site_django/')\\n\\t\\tufo.copy_file_to_path(self._compressed_save_path, transfer_path)\",\n \"def gzip_assets():\\n run('cd %(repo_path)s; python gzip_assets.py' % env)\",\n \"def prepare_gz(self, filename, *args, **kwargs):\\n\\n return '/vsigzip/' + filename, args, kwargs\",\n \"def check_request_and_create_zipfile() -> None:\\n\\n session = DBSession()\\n\\n for site_page in session.query(SitePage).filter(SitePage.status != STATUS_ARCHIVE_READY):\\n data = create_zipfile(url_page=site_page.url)\\n\\n site_page.zipfile = pickle.dumps(data)\\n site_page.status = STATUS_ARCHIVE_READY\\n session.add(site_page)\\n session.commit()\\n\\n session.close()\",\n \"def unzip_single_file(zip_file_name, output_file_name):\\n if not os.path.isfile(output_file_name):\\n with open(output_file_name, 'wb') as out_file:\\n with zipfile.ZipFile(zip_file_name) as zipped:\\n for info in zipped.infolist():\\n if output_file_name in info.filename:\\n with zipped.open(info) as requested_file:\\n out_file.write(requested_file.read())\\n return\",\n \"def _zip_files(self):\\n\\n zip_file = Path(self.build_directory.parent).joinpath(\\n self.package_name + '.zip'\\n )\\n logger.info('Creating zip file: %s', zip_file)\\n\\n shutil.make_archive(zip_file.with_suffix(''), 'zip', self.build_directory)\\n shutil.move(str(zip_file), self.build_directory)\",\n \"def prepare_zip_file(self):\\n # need the following:\\n # 1. readme\\n # 2. cleaned features file\\n # 3. gene map\\n # 4. clean response file\\n # 5. run.yml\\n # 6. combined viz scores files\\n # 7. all top_genes_per_phenotype* files\\n # 8. network metadata\\n zip_path = os.path.join(\\\\\\n self.job_dir_path, 'download.zip')\\n with ZipFile(zip_path, 'w', ZIP_DEFLATED) as zipout:\\n\\n zipout.write(\\\\\\n '/zip_readmes/README-GP.txt', 'README-GP.txt')\\n\\n cleaned_features_path = os.path.join(\\\\\\n self.userfiles_dir, self.features_file_relative_path)\\n zipout.write(\\\\\\n cleaned_features_path, 'clean_genomic_matrix.txt')\\n\\n gene_names_map_path = os.path.join(\\\\\\n self.userfiles_dir, self.gene_names_map_relative_path)\\n zipout.write(\\\\\\n gene_names_map_path, 'gene_map.txt')\\n\\n cleaned_response_path = os.path.join(\\\\\\n self.userfiles_dir, self.response_file_relative_path)\\n zipout.write(\\\\\\n cleaned_response_path, 'clean_phenotypic_matrix.txt')\\n\\n zipout.write(\\\\\\n self.yml_path, 'run_params.yml')\\n\\n # combine viz files\\n combined_viz_path = os.path.join(self.job_dir_path, \\\\\\n 'combined_viz.tsv')\\n with open(combined_viz_path, 'w') as combo:\\n for fidx, fname in enumerate(sorted(self.get_response_files())):\\n fpath = os.path.join(self.results_dir_path, fname)\\n with open(fpath, 'r') as vizfile:\\n for lidx, line in enumerate(vizfile):\\n if lidx == 0 and fidx > 0:\\n # only print the column labels once\\n pass\\n else:\\n combo.write(line)\\n zipout.write(combined_viz_path, 'genes_ranked_per_phenotype.txt')\\n\\n top_genes_files = [f for f in os.listdir(self.results_dir_path) \\\\\\n if f.startswith('top_genes_per_phenotype')]\\n if len(top_genes_files) == 1:\\n top_genes_file_path = os.path.join(\\\\\\n self.results_dir_path, top_genes_files[0])\\n zipout.write(\\\\\\n top_genes_file_path, 'top_genes_per_phenotype_matrix.txt')\\n\\n if self.gg_network_metadata_full_path is not None:\\n zipout.write(self.gg_network_metadata_full_path, \\\\\\n 'interaction_network.metadata')\",\n \"def run(self):\\n \\n try:\\n with zipfile.ZipFile(self.tmpArchiveFilePath, 'w', zipfile.ZIP_DEFLATED) as z:\\n z.write(self.resultFilePath, self.fileType+'.tif')\\n if os.path.isfile(self.resultPrjFilePath):\\n z.write(self.resultPrjFilePath, self.fileType+'.prj')\\n except:\\n msg = traceback.format_exc()\\n self.emit( SIGNAL('failed(QString)'), msg)\\n return\\n \\n with open(self.tmpArchiveFilePath, \\\"rb\\\") as binFile:\\n base64Data = base64.b64encode(binFile.read())\\n fileData = ('file_data', self.tmpArchiveFilePath, base64Data)\\n \\n self.emit( SIGNAL('prep_completed(int, QString, QString, QString, QString)'), self.eventId, self.fileType, fileData[0], fileData[1], fileData[2])\\n return\",\n \"def zip_campaign_files(): # pylint: disable=too-many-locals\\n try:\\n build_tag = env.get('BUILD_TAG')\\n assert Campaign.dump_db() == Campaign.EX_OK\\n assert Campaign.dump_artifacts() == Campaign.EX_OK\\n with zipfile.ZipFile(f'{build_tag}.zip',\\n 'w', zipfile.ZIP_DEFLATED) as zfile:\\n zfile.write(f\\\"{build_tag}.json\\\")\\n for root, _, files in os.walk(build_tag):\\n for filename in files:\\n zfile.write(os.path.join(root, filename))\\n b3resource = boto3.resource(\\n 's3', endpoint_url=os.environ[\\\"S3_ENDPOINT_URL\\\"])\\n dst_s3_url = os.environ[\\\"S3_DST_URL\\\"]\\n multipart_threshold = 5 * 1024 ** 5 if \\\"google\\\" in os.environ[\\n \\\"S3_ENDPOINT_URL\\\"] else 8 * 1024 * 1024\\n tconfig = TransferConfig(multipart_threshold=multipart_threshold)\\n bucket_name = urllib.parse.urlparse(dst_s3_url).netloc\\n mime_type = mimetypes.guess_type(f'{build_tag}.zip')\\n path = urllib.parse.urlparse(dst_s3_url).path.strip(\\\"/\\\")\\n # pylint: disable=no-member\\n b3resource.Bucket(bucket_name).upload_file(\\n f'{build_tag}.zip',\\n os.path.join(path, f'{build_tag}.zip'),\\n Config=tconfig,\\n ExtraArgs={'ContentType': mime_type[\\n 0] or 'application/octet-stream'})\\n dst_http_url = os.environ[\\\"HTTP_DST_URL\\\"]\\n link = os.path.join(dst_http_url, f'{build_tag}.zip')\\n Campaign.__logger.info(\\n \\\"All data were successfully published:\\\\n\\\\n%s\\\", link)\\n return Campaign.EX_OK\\n except KeyError as ex:\\n Campaign.__logger.error(\\\"Please check env var: %s\\\", str(ex))\\n return Campaign.EX_ZIP_CAMPAIGN_FILES_ERROR\\n except botocore.exceptions.NoCredentialsError:\\n Campaign.__logger.error(\\n \\\"Please fill ~/.aws/credentials, ~/.boto or set \\\"\\n \\\"AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY in env\\\")\\n return Campaign.EX_ZIP_CAMPAIGN_FILES_ERROR\\n except Exception: # pylint: disable=broad-except\\n Campaign.__logger.exception(\\\"Cannot publish the artifacts\\\")\\n return Campaign.EX_ZIP_CAMPAIGN_FILES_ERROR\",\n \"def download(self, download) -> None:\\n path_cifarh = path.join(self.root, self.filename_cifarh)\\n path_cifar = path.join(self.root, self.filename_cifar)\\n is_there = path.isfile(path_cifarh) and path.isfile(path_cifar)\\n if is_there:\\n print(\\\"Files already exist.\\\")\\n if download == \\\"force\\\" or not is_there:\\n download_and_extract_archive(\\n self.url_cifar, self.root, filename=self.filename_cifar\\n )\\n download_and_extract_archive(\\n self.url_cifarh, self.root, filename=self.filename_cifarh\\n )\",\n \"def test_deferred_close_by_archive(self):\\n z = ZipFile(self.f, 'r')\\n self.assertIsNotNone(z._a)\\n self.assertIsNone(z._stream)\\n z.close()\\n self.assertIsNone(z._a)\",\n \"def add(self):\\r\\n f_name=self.REQUEST.form.get('my_file').filename\\r\\n if len(f_name.split('\\\\\\\\'))>1:\\r\\n\\tf_name=f_name.split('\\\\\\\\')[-1]\\r\\n if f_name:\\r\\n format=str(f_name).split('.')[-1].upper()\\r\\n if (format == 'JPG' or format=='JPEG' or format =='GIF' or format=='PNG'):\\r\\n ret = add_image(self.this(),f_name,self.REQUEST.form.get('my_file'),search_id(self,self.this().objectValues('Image')))\\r\\n elif format=='ZIP':\\r\\n val=''\\r\\n zip_folder=tempfile.mktemp()\\r\\n os.mkdir(zip_folder)\\r\\n zip_datei=open(zip_folder+'/'+f_name,'w+')\\r\\n zip_datei.write(self.REQUEST.form.get('my_file').read())\\r\\n zip_datei.close()\\r\\n zip_datei=open(zip_folder+'/'+f_name,'r+')\\r\\n zf = ZipFile(zip_datei)\\r\\n for extracted_file in zf.namelist():\\r\\n format=str(extracted_file).split('.')[-1].upper()\\r\\n\\t if (format == 'JPG' or format=='JPEG' or format =='GIF' or format=='PNG'):\\r\\n\\t extracted=open(zip_folder+'/'+extracted_file,'w+')\\r\\n\\t extracted.write(zf.read(extracted_file))\\r\\n\\t extracted.close()\\r\\n\\t extracted=open(zip_folder+'/'+extracted_file,'r+')\\r\\n\\t val=val+add_image(self.this(),extracted_file,extracted,search_id(self,self.this().objectValues('Image')))\\r\\n\\t extracted.close()\\r\\n\\t os.remove(zip_folder+'/'+extracted_file)\\r\\n zip_datei.close()\\r\\n os.remove(zip_folder+'/'+f_name)\\r\\n os.rmdir(zip_folder)\\r\\n ret=\\\"<br>Datei Hochgeladet und entpacket!\\\"\\r\\n else:\\r\\n ret= \\\"Nur jpg, jpeg, gif, png, oder zip Datei erledigt!\\\"\\r\\n else:\\r\\n ret= \\\"Nichts war hochgeladet! Ihr Firewall, Proxy oder Sicherheitseinstellungen einrichten!\\\"\\r\\n return ret\",\n \"def download(self, cloud_path):\\n zip_file = os.path.join(self.root, ZIPFILE)\\n unzip_dir = os.path.join(self.root, UNZIP_NAME)\\n\\n if os.path.isfile(zip_file):\\n logger.debug(f\\\"File {zip_file} exists. Skip download.\\\")\\n else:\\n client = GCSClient()\\n object_key = os.path.join(NYU_GCS_PATH, ZIPFILE)\\n\\n logger.debug(\\n f\\\"Downloading file {zip_file} from gs://{const.GCS_BUCKET}/\\\"\\n f\\\"{object_key}\\\"\\n )\\n client.download(const.GCS_BUCKET, object_key, zip_file)\\n\\n if os.path.isdir(unzip_dir):\\n logger.debug(f\\\"File {unzip_dir} exists. Skip unzip.\\\")\\n else:\\n # unzip the file\\n with ZipFile(zip_file, \\\"r\\\") as zip_ref:\\n zip_ref.extractall(self.root)\\n logger.debug(f\\\"Unzip file from {zip_file}\\\")\",\n \"def recompress_fucntion(destination_file, tmp_folder):\\n def confirm_new_files(ziplocation):\\n \\\"\\\"\\\"\\n test if the file.zip/cbz has the same\\n amount of files as tmp_folder\\n :param ziplocation: string\\n :return: bool\\n \\\"\\\"\\\"\\n try:\\n zf = ZipFile(ziplocation)\\n filecontents = list(zf.namelist())\\n except BadZipFile:\\n os.remove(ziplocation)\\n print('OUTPUT FILE BROKEN')\\n return False\\n\\n for walk in os.walk(tmp_folder):\\n files = [walk[0] + '/' + x for x in walk[2]]\\n if len(filecontents) < len(files):\\n os.remove(ziplocation)\\n shutil.rmtree(tmp_folder)\\n print('FILES MISSING')\\n return False\\n break\\n\\n return True\\n\\n zipfile = destination_file[0:-(len('.cbz'))]\\n\\n if platform.system() != \\\"Windows\\\":\\n os.sync()\\n\\n shutil.make_archive(zipfile, 'zip', tmp_folder)\\n zipfile += '.zip'\\n\\n if platform.system() != \\\"Windows\\\":\\n os.sync()\\n\\n if not confirm_new_files(zipfile):\\n return False\\n\\n if not os.path.exists(zipfile) or os.path.getsize(zipfile) == 0:\\n print('WRITE OUTPUT ERROR')\\n if os.path.exists(zipfile):\\n os.remove(zipfile)\\n\\n return False\\n\\n shutil.move(zipfile, destination_file)\\n\\n return True\",\n \"def zip_data(self) -> None:\\n zipf = zipfile.ZipFile('output.zip', 'w', zipfile.ZIP_DEFLATED)\\n self._zipdir(self.path, zipf)\\n zipf.close()\",\n \"def tar_gz_compress(self, destination):\\n\\n if destination is not None and isinstance(destination, str):\\n with tarfile_open(destination, \\\"w:gz\\\") as tar:\\n tar.add(self.file)\",\n \"def zip_open_bin(zip, filename):\\n if isinstance(zip, FakeZip):\\n return zip.open(filename, 'rb')\\n else:\\n return zip.open(filename, 'r')\",\n \"def vcf_compress(fn):\\n ret = cmd_exe(f\\\"vcf-sort {fn} | bgzip > {fn}.gz && tabix {fn}.gz\\\")\",\n \"def zip_single_file_output(self, zip_single_file_output):\\n\\n self._zip_single_file_output = zip_single_file_output\",\n \"def open_gzip(fn):\\n magic = b'\\\\x1f\\\\x8b\\\\x08'\\n l = len(magic)\\n with open(fn, 'rb') as f:\\n file_start = f.read(l)\\n f.seek(0)\\n # check if the file is compressed\\n if file_start.startswith(magic):\\n return gzip.open(fn, 'rt')\\n # not compressed\\n return open(fn, 'rt')\",\n \"def _maybe_download_and_extract(self, filename):\\n if not os.path.exists(self.work_dir):\\n os.mkdir(self.work_dir)\\n filepath = os.path.join(self.work_dir, filename)\\n if not os.path.exists(filepath):\\n filepath, _ = urllib.urlretrieve(self.url + filename, filepath)\\n statinfo = os.stat(filepath)\\n log.info('Successfully downloaded', filename, statinfo.st_size,\\n 'bytes.')\\n log.info('Extracting zip file ... ')\\n f = zipfile.ZipFile(filepath)\\n f.extractall(path=self.work_dir)\\n log.info('Extraction finished ... ')\",\n \"def read_zip_file():\\n with open(os.path.join(DIST_DIR, \\\"build.zip\\\"), \\\"rb\\\") as zip_file:\\n return zip_file.read()\",\n \"def clean_gzip():\\n this_dir = os.getcwd()\\n os.chdir(\\\"/data/COHERENT2/data/CrystalChar/raw\\\")\\n all_files = glob.glob(\\\"./**\\\", recursive=True)\\n for f in all_files:\\n if \\\".gz\\\" in f and \\\"tar\\\" not in f:\\n print(f)\\n sh(\\\"gunzip \\\" + f)\\n os.chdir(this_dir)\",\n \"def bgzip_tabix(bedbz2):\\n bed = bedbz2.replace(\\\".bz2\\\", \\\"\\\")\\n bedgz = bed + \\\".gz\\\"\\n tbi = bedgz + \\\".tbi\\\"\\n if os.path.exists(bedgz) and os.path.exists(tbi):\\n print bedgz, tbi, \\\"has beed generated.\\\"\\n return\\n c1 = \\\"bzip2 -d %s\\\" % bedbz2\\n c2 = \\\"bgzip %s\\\" % bed\\n c3 = \\\"tabix -s 1 -b 2 -e 3 %s\\\" % bedgz\\n call_sys([c1, c2, c3])\",\n \"def close(self):\\n self.myzip.close()\",\n \"def prepare_zip(self, filename, *args, **kwargs):\\n\\n return '/vsizip/' + filename, args, kwargs\",\n \"def test_deferred_close_by_archive(self):\\n z = ZipFile(self.f, 'w')\\n o = z.writestream(FILENAMES[0])\\n z.close()\\n self.assertIsNotNone(z._a)\\n self.assertIsNotNone(z._stream)\\n if PY3:\\n o.write('testdata')\\n else:\\n o.write(unicode('testdata'))\\n o.close()\\n self.assertIsNone(z._a)\\n self.assertIsNone(z._stream)\\n z.close()\",\n \"def zip(self):\\n global pointer\\n global error_flag\\n global totalFiles\\n while pointer < len(self.files) and ((self.t and not error_flag) or not self.t):\\n # Se o modo e' t e a error_flag nao for false entao pode avancar\\n # Se o modo nao for t pode avancar sem restricoes\\n self.sem.acquire()\\n iterator = pointer\\n pointer += 1\\n self.sem.release()\\n if iterator < len(self.files): # Iterator e' o ficheiro que deve ser utilizado pela thread\\n File = self.files[iterator]\\n if os.path.isfile(File): # Ver se o ficheiro existe\\n with ZipFile(File + '.zip', 'w') as zipfile:\\n zipfile.write(File) # Zip\\n self.totalFilesSem.acquire()\\n totalFiles += 1\\n self.totalFilesSem.release()\\n else:\\n print \\\"O ficheiro\\\", File, \\\"não existe.\\\" # Se nao existir, avisa o utilizador\\n error_flag = True # Atualiza a sua propria flag\",\n \"def do_pack():\\n\\n now = datetime.now()\\n # format the name of the file with the timestamps\\n now_year = now.year\\n now_month = now.month\\n now_day = now.day\\n now_hour = now.hour\\n now_minute = now.minute\\n now_second = now.second\\n # apply the format\\n file_name = 'versions/web_static_{}{}{}{}{}{}.tgz'.format(\\n now_year, now_month, now_day, now_hour, now_minute, now_second\\n )\\n # All archives must be stored in the folder versions\\n local('mkdir -p versions')\\n # execute locally the compression of the folder\\n command = local(\\\"tar -cvzf \\\" + file_name + \\\" ./web_static/\\\")\\n # return the archive path if the archive has been correctly generated\\n if command.succeeded:\\n return file_name\\n else:\\n return None\",\n \"def hasBzip2():\\n return _libsbml.SBMLWriter_hasBzip2()\",\n \"def open_zip(path, *args, **kwargs):\\r\\n with contextlib.closing(zipfile.ZipFile(path, *args, **kwargs)) as zip:\\r\\n yield zip\",\n \"def AddToZip(self, input_zip, output_zip, input_path=None):\\n\\n self.UnmountAll()\\n\\n common.ZipWriteStr(output_zip, \\\"META-INF/com/google/android/updater-script\\\",\\n \\\"\\\\n\\\".join(self.script) + \\\"\\\\n\\\")\\n\\n if input_path is None:\\n data = input_zip.read(\\\"OTA/bin/updater\\\")\\n else:\\n data = open(input_path, \\\"rb\\\").read()\\n common.ZipWriteStr(output_zip, \\\"META-INF/com/google/android/update-binary\\\",\\n data, perms=0o755)\",\n \"def gunzip_file(gzip_file, base_dir):\\n full_gzip_file = os.path.join(base_dir, gzip_file)\\n if not gzip_file.endswith(\\\".gz\\\"):\\n return gzip_file\\n gunzip_file = full_gzip_file.replace(\\\".gz\\\", \\\"\\\")\\n with gzip.open(full_gzip_file, 'rb') as f_in:\\n with open(gunzip_file, 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n # Now that file is extracted. Remove file\\n os.remove(full_gzip_file)\\n\\n return os.path.basename(gunzip_file)\",\n \"def _extract_gz(src, dst):\\n assert src.endswith(\\\".gz\\\"), \\\"{} is not a valid .gz file.\\\".format(src)\\n assert os.path.exists(src), \\\"{} does not exist.\\\".format(src)\\n\\n with gzip.open(src, \\\"rb\\\") as f_src:\\n # xxx.postfix.gz --> xxx.postfix\\n file_name = os.path.basename(src)[:-3]\\n with open(os.path.join(dst, file_name), \\\"wb\\\") as f_dst:\\n shutil.copyfileobj(f_src, f_dst)\",\n \"def gzip_files(topDir, afni_file,localizerfile):\\n\\n print 'GZIPPING FILES...'\\n\\n command1 = \\\"gzip %s*BRIK\\\" % (topDir)\\n command2 = \\\"gzip %s*HEAD\\\" % (topDir)\\n command3 = \\\"gzip %s%s/pb00*\\\" % (topDir,afni_file)\\n command4 = \\\"gzip %s%s/errts*\\\" % (topDir,afni_file)\\n command5 = \\\"gzip %s%s/fitts*\\\" % (topDir,afni_file)\\n command6 = \\\"gzip %s%s/*al*\\\" % (topDir,afni_file)\\n command7 = \\\"gzip %s%s/*ns*\\\" % (topDir,afni_file)\\n command8 = \\\"gzip %s%s/all_runs*\\\" % (topDir,afni_file)\\n command9 = \\\"gzip %s%s/*mask*\\\" % (topDir,afni_file)\\n command10 = \\\"gzip %s*nii\\\" % (topDir)\\n command11 = \\\"gzip %s%s/pb01*\\\" % (topDir,afni_file)\\n command12 = \\\"gzip %s%s/pb03*\\\" % (topDir,afni_file)\\n command13 = \\\"gzip %s%s/pb02*\\\" % (topDir,afni_file)\\n\\n os.system(command1)\\n os.system(command2)\\n os.system(command3)\\n os.system(command4)\\n os.system(command5)\\n os.system(command6)\\n os.system(command7)\\n os.system(command8)\\n #os.system(command9)\\n os.system(command10)\\n os.system(command11)\\n try:\\n os.system(command12)\\n except:\\n print 'Could not gzip pb03 files'\\n\\n if localizerfile == 'facescene_loc':\\n os.system(command13)\",\n \"def backup(self):\\n if self.url is not None:\\n\\n # zip backup folder\\n zipapp.create_archive(self.logs_directory, self.send_zip)\\n\\n # then send zipped folder to the URL\\n try:\\n requests.post(self.url, files={\\n 'uploaded_file': (os.path.basename(self.send_zip), open(self.send_zip, 'rb')),\\n })\\n except requests.exceptions.ConnectionError as error:\\n print(error)\",\n \"def compress_files(self):\\n archive_file_path = tkinter.filedialog.asksaveasfilename(parent=self,\\n defaultextension=\\\".zip\\\",\\n filetypes=[(\\\"Zip File\\\", \\\"*.zip\\\")])\\n treeview_items = self.files_treeview.get_children()\\n if archive_file_path and treeview_items:\\n with ZipFile(archive_file_path, \\\"w\\\", ZIP_DEFLATED) as archive:\\n for row in treeview_items:\\n file_path = self.files_treeview.item(row, \\\"values\\\")[0]\\n file_name = os.path.basename(file_path)\\n archive.write(file_path, arcname=file_name)\",\n \"def test_compress_file_response(self):\\n with open(__file__, \\\"rb\\\") as file1:\\n\\n def get_response(req):\\n file_resp = FileResponse(file1)\\n file_resp[\\\"Content-Type\\\"] = \\\"text/html; charset=UTF-8\\\"\\n return file_resp\\n\\n r = GZipMiddleware(get_response)(self.req)\\n with open(__file__, \\\"rb\\\") as file2:\\n self.assertEqual(self.decompress(b\\\"\\\".join(r)), file2.read())\\n self.assertEqual(r.get(\\\"Content-Encoding\\\"), \\\"gzip\\\")\\n self.assertIsNot(r.file_to_stream, file1)\",\n \"def _gzip_file(filename):\\n gzip_filename = filename + '.gz'\\n with open(filename, 'rb') as f_in, gzip.open(gzip_filename, 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\",\n \"def store_source(zipfile_name, directory, storage_directory):\\n if directory in ZIP_EXCLUDES:\\n zip_command = ['zip', '-x ' + '-x'.join(ZIP_EXCLUDES[directory]), '-r', zipfile_name, directory]\\n else:\\n zip_command = ['zip', '-r', zipfile_name, directory]\\n\\n if exists(zipfile_name):\\n os.remove(zipfile_name)\\n\\n try:\\n logging.debug('Zipping Source: %s', zip_command)\\n check_output(zip_command)\\n except CalledProcessError as build_error:\\n logging.error('Could not zip source, Return Code %s, Command %s', build_error.returncode, build_error.cmd)\\n logging.error(build_error.output)\\n os.remove(zipfile_name)\\n return False\\n\\n qmk_storage.save_file(zipfile_name, os.path.join(storage_directory, zipfile_name), 'application/zip')\\n os.remove(zipfile_name)\\n\\n return True\",\n \"def create_zip_file():\\n shutil.make_archive(os.path.join(DIST_DIR, \\\"build\\\"), \\\"zip\\\", BUILD_DIR)\",\n \"def _zipfile_single_file_extract_worker(\\n zip_file_path: Path,\\n file_in_archive: zipfile.ZipInfo,\\n destination_folder: Path,\\n is_dir: bool,\\n) -> Path:\\n with _FastZipFileReader(zip_file_path) as zf:\\n # assemble destination and ensure it exits\\n destination_path = destination_folder / file_in_archive.filename\\n\\n if is_dir:\\n destination_path.mkdir(parents=True, exist_ok=True)\\n return destination_path\\n desc = f\\\"decompressing {zip_file_path}:{file_in_archive.filename} -> {destination_path}\\\\n\\\"\\n with zf.open(name=file_in_archive) as zip_fp, destination_path.open(\\n \\\"wb\\\"\\n ) as dest_fp, tqdm_logging_redirect(\\n total=file_in_archive.file_size,\\n desc=desc,\\n **(\\n _TQDM_FILE_OPTIONS\\n | dict(miniters=_compute_tqdm_miniters(file_in_archive.file_size))\\n ),\\n ) as pbar:\\n while chunk := zip_fp.read(_CHUNK_SIZE):\\n dest_fp.write(chunk)\\n pbar.update(len(chunk))\\n return destination_path\",\n \"def gunzip_file(gz_path, new_path):\\n print(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def main():\\n if len(sys.argv) != 2:\\n print(\\\"Error: Incorrect number of arguments. Expected 1.\\\")\\n print(\\\"Usage: python compress.py <path to file to compress>\\\")\\n print(\\\"Example: python compress.py zones.json\\\")\\n exit(1)\\n\\n with open(sys.argv[1], \\\"rb\\\") as r, \\\\\\n open(\\\"{}.br\\\".format(sys.argv[1]), \\\"wb\\\") as w:\\n w.write(brotli.compress(r.read()))\",\n \"def checkBZ2(path):\\n devnull = open('/dev/null', 'w+')\\n proc = subprocess.Popen(['/usr/bin/bzip2', '-t', path], shell=False,\\n stdin=devnull, stdout=devnull, stderr=devnull)\\n proc.communicate()\\n return proc.returncode == 0\",\n \"def is_archive(afile):\\n return file_ext(os.path.basename(afile)) in ARCHIVE_COMPRESS_FORMATS\",\n \"def start():\\n filePath = area.get()\\n okMes.pack_forget()\\n errMes.pack_forget()\\n if is_zipfile(filePath):\\n z = ZipFile(filePath, 'r')\\n z.extractall()\\n z.close()\\n okMes.pack()\\n else:\\n \\terrMes.pack()\",\n \"def downloadZip(self, resource, fp):\\n\\n self._stayAlive()\\n\\n res = self.s.get(self.fullUrl(resource), stream = True)\\n if res.ok:\\n with fp.open('wb') as f:\\n shutil.copyfileobj(res.raw, f)\\n return res.status_code\\n else:\\n return None\",\n \"def hasBzip2():\\n return _libsbml.SBMLReader_hasBzip2()\",\n \"def SBMLWriter_hasBzip2():\\n return _libsbml.SBMLWriter_hasBzip2()\",\n \"def on_post(self, req, resp):\\n LOGGER = logging.getLogger()\\n \\n resp.set_header('Content-Type', 'text/json')\\n raw_json = req.stream.read().decode('utf-8')\\n content = json.loads(raw_json, encoding='utf-8')\\n\\n try:\\n files = content.get(\\\"files\\\")\\n zip_name = content.get(\\\"name\\\")\\n zip_file = DownloadFilesResource.compress_files(files, zip_name)\\n resp.body = json.dumps({'file': zip_file})\\n LOGGER.info(\\\"Zip created and ready to download\\\")\\n except Exception as e:\\n LOGGER.error(\\\"Error creating zip file\\\" , exc_info=True)\\n raise falcon.HTTPInternalServerError(title=\\\"Error downloading files: \\\" + str(type(e)),\\n description=(str(e) +\\n ','.join(traceback.format_tb(e.__traceback__))))\",\n \"def dir_2_cbz(dir_pth):\\r\\n shutil.make_archive(dir_pth, 'zip', dir_pth)\\r\\n shutil.rmtree(dir_pth)\\r\\n os.rename(dir_pth+'.zip', dir_pth+'.cbz')\\r\\n pass\",\n \"def gunzip_file(gz_path, new_path):\\n logging.info(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def _compress_meds_file(self, ucfilename, fzfilename):\\n from os.path import basename\\n\\n tup=(basename(ucfilename),basename(fzfilename))\\n print('compressing file: %s -> %s' % tup)\\n tpath=files.expandpath(fzfilename)\\n if os.path.exists(tpath):\\n os.remove(tpath)\\n\\n tmpdir = os.path.dirname(ucfilename)\\n with StagedOutFile(fzfilename,tmpdir=tmpdir) as sf:\\n cmd = self['fpack_command']\\n cmd = cmd.format(fname=ucfilename)\\n ret=os.system(cmd)\\n\\n if ret != 0:\\n raise RuntimeError(\\\"failed to compress file\\\")\\n\\n print('output is in:',fzfilename)\",\n \"def main(file_url, file_path):\\n\\n # extract file from the link\\n\\n if not os.path.exists(file_path):\\n os.makedirs(file_path, exist_ok=True)\\n \\n r = requests.get(str(file_url))\\n\\n #unzip the zip file\\n z = zipfile.ZipFile(io.BytesIO(r.content))\\n z.extractall(path = file_path)\",\n \"def testZipUrl(self):\\n try:\\n remoteLocator = self.__zipFileUrl\\n # fn = self.__fileU.getFileName(remoteLocator)\\n ok = self.__fileU.isLocal(remoteLocator)\\n self.assertFalse(ok)\\n #\\n lPath = os.path.join(self.__workPath, self.__fileU.getFileName(self.__zipFileUrl))\\n ok = self.__fileU.get(remoteLocator, lPath)\\n self.assertTrue(ok)\\n ok = self.__fileU.exists(lPath)\\n self.assertTrue(ok)\\n ok = self.__fileU.isLocal(lPath)\\n self.assertTrue(ok)\\n tPath = self.__fileU.getFilePath(lPath)\\n self.assertEqual(lPath, tPath)\\n fp = self.__fileU.uncompress(lPath, outputDir=self.__workPath)\\n ok = fp.endswith(\\\"Food_Display_Table.xlsx\\\")\\n self.assertTrue(ok)\\n\\n except Exception as e:\\n logger.exception(\\\"Failing with %s\\\", str(e))\\n self.fail()\",\n \"def test_zip_files(self):\\n base_zip_files = ['whypython.txt', 'states.dbf', 'cities.kmz']\\n\\n text_file = os.path.join(os.getcwd(), 'test-data', 'whypython.txt')\\n dbf_file = os.path.join(os.getcwd(), 'test-data', 'states.dbf')\\n kml_file = os.path.join(os.getcwd(), 'test-data', 'cities.kmz')\\n #non_file = os.path.join(os.getcwd(), 'test-data', 'emptyfolder')\\n self.request['params'][0]['response']['docs'][0]['path'] = text_file\\n self.request['params'][0]['response']['docs'][1]['path'] = dbf_file\\n self.request['params'][0]['response']['docs'][2]['path'] = kml_file\\n #self.request['params'][0]['response']['docs'][3]['path'] = non_file\\n __import__(self.request['task'])\\n getattr(sys.modules[self.request['task']], \\\"execute\\\")(self.request)\\n zip_files = zipfile.ZipFile(os.path.join(self.temp_folder, 'output.zip')).namelist()\\n self.assertEqual(sorted(zip_files), sorted(base_zip_files))\",\n \"def decompress_files(self):\\n crx2rnx_path = os.path.join(ROOT_DIR, 'CRX2RNX')\\n if not os.path.isfile(crx2rnx_path):\\n raise OSError('Cannot find CRX2RNX binary in project directory!')\\n\\n if glob('{}/*'.format(self.__directory)):\\n subprocess.run([\\\"gunzip\\\", \\\"-dr\\\", self.__directory])\\n # convert Hatanaka compressed RINEX to standard RINEX\\n for f in glob('{}/*.??d'.format(self.__directory)):\\n subprocess.run([crx2rnx_path, f])\\n else:\\n raise RuntimeError(\\n 'Could not decompress. No files were downloaded from FTP server.')\",\n \"def isgzip(filename):\\n magic_number = b'\\\\x1f\\\\x8b\\\\x08'\\n with open(filename, 'rb') as f:\\n file_start = f.read(len(magic_number))\\n\\n if magic_number == file_start:\\n return True\\n return False\",\n \"def is_zipfile(filename):\\n\\n import zipfile\\n\\n return zipfile.is_zipfile(filename)\",\n \"def _is_archive(local_path: str) -> bool:\\n archive_mimetypes = [\\n \\\"application/zip\\\",\\n \\\"application/x-tar\\\",\\n \\\"application/x-gzip\\\",\\n \\\"application/x-bzip2\\\",\\n \\\"application/x-7z-compressed\\\",\\n \\\"application/x-rar-compressed\\\",\\n \\\"application/x-xz\\\",\\n \\\"application/x-lzip\\\",\\n \\\"application/x-lzma\\\",\\n \\\"application/x-lzop\\\",\\n \\\"application/x-bzip\\\",\\n \\\"application/x-bzip2\\\",\\n \\\"application/x-compress\\\",\\n \\\"application/x-compressed\\\",\\n ]\\n\\n return mimetypes.guess_type(local_path)[0] in archive_mimetypes\",\n \"def load_zip_folder(req_path, name, ext, zip_path):\\n BASE_DIR = ROOT\\n full_path = \\\"%s/%s.%s\\\" % (req_path, name, ext)\\n full_real_path = get_real_path(BASE_DIR, full_path)\\n try:\\n zip_path = unquote(zip_path).encode('utf-8')\\n except Exception as e:\\n logger.info(\\\"Failed to encode: %s\\\", zip_path)\\n\\n if not os.path.exists(full_real_path):\\n logger.error(\\\"No Path: %s\\\", full_real_path)\\n return ('', 204)\\n\\n if ext not in archive_exts:\\n return ('', 204)\\n\\n #get list of files in folder in zip file\\n data = ComixData(Directories=[], Files=[])\\n with zipfile.ZipFile(full_real_path) as zf:\\n for name in zf.namelist():\\n name = name.decode('euc-kr').encode('utf-8')\\n pardir, basename = os.path.split(name)\\n if basename and zip_path == pardir:\\n logger.info(\\\"get_files_in_zip_path: %s, %s\\\", pardir, basename)\\n data.Files.append(basename)\\n if len(data.Files):\\n response = flask.Response(json.dumps(data._asdict(), ensure_ascii=False), headers=None)\\n return response\\n\\n return ('', 204)\",\n \"def is_gz_file(f):\\n with open(f, \\\"rb\\\") as fin:\\n return binascii.hexlify(fin.read(2)) == b\\\"1f8b\\\"\",\n \"def download_file(url, path):\\n file_name = path + url.split(\\\"/\\\")[-1]\\n req = requests.get(url)\\n zipped_info = req.content\\n print(file_name)\\n if not os.path.isfile(file_name):\\n print(\\\"file doesnt exist, writing\\\", file_name)\\n with open(file_name, 'wb') as f:\\n f.write(zipped_info)\\n else:\\n print(\\\"file exists\\\", file_name)\",\n \"def upload_nextcloud_zipfile(import_type: migration.Migration, archive: UploadFile = File(...)):\\n dir = app_dirs.MIGRATION_DIR.joinpath(import_type.value)\\n dir.mkdir(parents=True, exist_ok=True)\\n dest = dir.joinpath(archive.filename)\\n\\n with dest.open(\\\"wb\\\") as buffer:\\n shutil.copyfileobj(archive.file, buffer)\\n\\n if not dest.is_file:\\n raise HTTPException(status.HTTP_400_BAD_REQUEST)\",\n \"def extract_gzip(fname: str, outfile: Optional[str] = None) -> Union[str, None]:\\n if not outfile:\\n outfile = fname[:-3]\\n\\n if fname.endswith(\\\".gz\\\"):\\n with gzip.open(fname, \\\"rb\\\") as f_in:\\n with open(outfile, \\\"wb\\\") as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n os.unlink(fname)\\n return outfile\",\n \"def compress():\\n run_manage_cmd('compress_assets')\",\n \"def zip_file(backup_objects):\\n\\n # Get name from date_time\\n name_of_zip_file = (get_date(\\\"%d%m%Y_%H.%S\\\") + '.zip')\\n # put files in zip archiv\\n z = zipfile.ZipFile(name_of_zip_file, 'a', zipfile.ZIP_DEFLATED) # create archive\\n for i in backup_objects:\\n if os.path.isdir(i):\\n for root, dirs, files in os.walk(i): # get list of files in folder\\n for file in files:\\n z.write(os.path.join(root, file)) # Создание относительных путей и запись файлов в архив\\n else:\\n z.write(i)\\n z.close()\\n if zipfile.is_zipfile(name_of_zip_file):\\n notest_file(\\\"arckhiving is conplite! Created file\\\" + name_of_zip_file)\\n return name_of_zip_file\",\n \"def zipsave(self):\\n\\n filename = filedialog.asksaveasfilename(initialdir=self.root.cache_dir,\\n title='Save As',\\n filetypes=[('Zip', '.zip')],\\n defaultextension='')\\n self.save_entry.clear()\\n self.save_entry.insert(tk.END, filename)\\n self.root.cache_dir = filename\",\n \"def open(self, *args, **kwargs):\\n return ZipFileArchiver(*args,**kwargs)\",\n \"def _gz(filename):\\n \\n with open(filename, 'rb') as f:\\n return binascii.hexlify(f.read(2)) == b'1f8b'\",\n \"def gunzip_file(gz_path, new_path):\\n print(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\",\n \"def __do_zip_binary_install(export_zip, item):\\n\\n # First copy the new file.\\n if export_zip.install_item_to(item, DTF_BINARIES_DIR) != 0:\\n log.e(TAG, \\\"Error copying binary '%s'\\\" % item.local_name)\\n return -1\\n\\n # Update database\\n if __update_binary(item) == 0:\\n log.e(TAG, \\\"Failed to update binary '%s' details in database.\\\"\\n % (item.name))\\n return -2\\n\\n return 0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64540195","0.61454713","0.61329705","0.6086035","0.5977188","0.5960336","0.58702797","0.5859002","0.58266616","0.57801116","0.5761597","0.575355","0.57480204","0.5744919","0.573051","0.5717974","0.56552184","0.5648838","0.5563235","0.5556836","0.555637","0.5555684","0.55519146","0.55344766","0.5529324","0.55125666","0.55077636","0.5475906","0.5468081","0.5467636","0.5463342","0.54490846","0.54486936","0.5445166","0.5441014","0.54347855","0.54262084","0.5422733","0.5418842","0.5416002","0.54130447","0.54022723","0.5393478","0.5370646","0.5360219","0.5337493","0.5332286","0.53228956","0.5310167","0.5301448","0.5297548","0.5291315","0.52687985","0.526745","0.5257611","0.5255723","0.52504873","0.52498025","0.52441126","0.52263486","0.5218115","0.52070475","0.51971793","0.5189288","0.51850826","0.51847595","0.5175852","0.5173357","0.51694214","0.51556575","0.51509076","0.51500505","0.5148911","0.5138483","0.51322526","0.5124297","0.51215005","0.51207066","0.5115937","0.5115244","0.5115131","0.51056904","0.5104865","0.50908315","0.5089173","0.5085233","0.5072375","0.5061881","0.5061307","0.50552887","0.5049312","0.5043822","0.50411415","0.5039332","0.50391996","0.50374335","0.5037122","0.5037052","0.5036069","0.5021526"],"string":"[\n \"0.64540195\",\n \"0.61454713\",\n \"0.61329705\",\n \"0.6086035\",\n \"0.5977188\",\n \"0.5960336\",\n \"0.58702797\",\n \"0.5859002\",\n \"0.58266616\",\n \"0.57801116\",\n \"0.5761597\",\n \"0.575355\",\n \"0.57480204\",\n \"0.5744919\",\n \"0.573051\",\n \"0.5717974\",\n \"0.56552184\",\n \"0.5648838\",\n \"0.5563235\",\n \"0.5556836\",\n \"0.555637\",\n \"0.5555684\",\n \"0.55519146\",\n \"0.55344766\",\n \"0.5529324\",\n \"0.55125666\",\n \"0.55077636\",\n \"0.5475906\",\n \"0.5468081\",\n \"0.5467636\",\n \"0.5463342\",\n \"0.54490846\",\n \"0.54486936\",\n \"0.5445166\",\n \"0.5441014\",\n \"0.54347855\",\n \"0.54262084\",\n \"0.5422733\",\n \"0.5418842\",\n \"0.5416002\",\n \"0.54130447\",\n \"0.54022723\",\n \"0.5393478\",\n \"0.5370646\",\n \"0.5360219\",\n \"0.5337493\",\n \"0.5332286\",\n \"0.53228956\",\n \"0.5310167\",\n \"0.5301448\",\n \"0.5297548\",\n \"0.5291315\",\n \"0.52687985\",\n \"0.526745\",\n \"0.5257611\",\n \"0.5255723\",\n \"0.52504873\",\n \"0.52498025\",\n \"0.52441126\",\n \"0.52263486\",\n \"0.5218115\",\n \"0.52070475\",\n \"0.51971793\",\n \"0.5189288\",\n \"0.51850826\",\n \"0.51847595\",\n \"0.5175852\",\n \"0.5173357\",\n \"0.51694214\",\n \"0.51556575\",\n \"0.51509076\",\n \"0.51500505\",\n \"0.5148911\",\n \"0.5138483\",\n \"0.51322526\",\n \"0.5124297\",\n \"0.51215005\",\n \"0.51207066\",\n \"0.5115937\",\n \"0.5115244\",\n \"0.5115131\",\n \"0.51056904\",\n \"0.5104865\",\n \"0.50908315\",\n \"0.5089173\",\n \"0.5085233\",\n \"0.5072375\",\n \"0.5061881\",\n \"0.5061307\",\n \"0.50552887\",\n \"0.5049312\",\n \"0.5043822\",\n \"0.50411415\",\n \"0.5039332\",\n \"0.50391996\",\n \"0.50374335\",\n \"0.5037122\",\n \"0.5037052\",\n \"0.5036069\",\n \"0.5021526\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6738823"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83189,"cells":{"query":{"kind":"string","value":"Return a function to open a (gzipped) file."},"document":{"kind":"string","value":"def _open(fname: str, mode: Optional[str] = \"r\"):\n if mode not in [\"r\", \"w\"]:\n raise ValueError(\"mode must be either 'r' or 'w'.\")\n\n if fname.endswith(\".gz\"):\n return gzip.open(fname, mode + \"t\")\n return open(fname, mode)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def open_gz(filename, mode):\n return gzip.open(filename, mode)","def open_gzip(fn):\n magic = b'\\x1f\\x8b\\x08'\n l = len(magic)\n with open(fn, 'rb') as f:\n file_start = f.read(l)\n f.seek(0)\n # check if the file is compressed\n if file_start.startswith(magic):\n return gzip.open(fn, 'rt')\n # not compressed\n return open(fn, 'rt')","def gzopen(f):\n return gzip.open(f, 'rb') if f.endswith('.gz') else open(f, 'r')","def open_(filename, mode=None, compresslevel=9):\n if filename[-3:] == '.gz':\n if mode is None: mode = 'rt'\n return closing(gzip.open(filename, mode, compresslevel))\n else:\n if mode is None: mode = 'r'\n return open(filename, mode)","def open_gzipped(infile, mode='rt'):\n import gzip\n import bz2\n if mode.startswith('r'):\n tmode = 'rt'\n bmode = 'r'\n elif mode.startswith('w'):\n tmode = 'wt'\n bmode = 'w'\n elif mode.startswith('a'):\n tmode = 'at'\n bmode = 'a'\n if hasattr(infile, 'write'):\n return infile\n if isinstance(infile, str):\n if infile.endswith('.gz'):\n return gzip.open(infile, tmode)\n if infile.endswith('.bz2'):\n if hasattr(bz2, 'open'):\n return bz2.open(infile, tmode)\n else:\n return bz2.BZ2File(infile, bmode)\n return open(infile, tmode)","def open_(filename, *args):\n\n if (filename[-3:] == '.gz'):\n return gzip.open(filename, *args)\n try:\n return open(filename, *args)\n except OSError:\n return gzip.open(filename + \".gz\", *args)","def genOpen(filename, mode):\n (name, ext) = os.path.splitext(filename)\n if ext == \".gz\":\n return gzip.open(filename, mode)\n else:\n return open(filename, mode)","def genOpen(filename, mode):\n (name, ext) = os.path.splitext(filename)\n if ext == \".gz\":\n return gzip.open(filename, mode)\n else:\n return open(filename, mode)","def smart_open(file, mode='rt', encoding='utf-8'):\n if file.endswith('.gz'):\n return gzip.open(file, mode=mode, encoding=encoding, newline=\"\\n\")\n return open(file, mode=mode, encoding=encoding, newline=\"\\n\")","def smart_open(filename: str, mode: str = \"rt\", ftype: str = \"auto\", errors: str = \"replace\"):\n if ftype == \"gzip\" or ftype == \"gz\" or (ftype == \"auto\" and filename.endswith(\".gz\")):\n return gzip.open(filename, mode=mode, encoding=\"utf-8\", errors=errors)\n else:\n return open(filename, mode=mode, encoding=\"utf-8\", errors=errors)","def openFile(file):\n file = file.lower()\n if file.endswith('.bz2'):\n return bz2.BZ2File(file)\n elif file.endswith('.gz'):\n return gzip.open(file)\n return open(file)","def crackOpen(path: Union[pathlib.Path, str], mode: str=\"r\", **args: Any) -> Generator[Union[gzip.GzipFile, TextIO, IO[Any]], None, None]:\n p = pathlib.Path(path)\n _, encoding = mimetypes.guess_type(p.name)\n if encoding == \"gzip\":\n if not mode.endswith(\"b\"):\n mode += \"t\" # Force text mode if binary not requested\n with gzip.open(path, mode, **args) as f:\n yield f\n else:\n with open(path, mode, **args) as g:\n yield g","def return_file_handle(input_file):\n if str(input_file).endswith(\".gz\"):\n gzipped_file_handle = gzip.open(input_file, \"rt\")\n return gzipped_file_handle\n else:\n normal_fh = open(input_file, \"r\")\n return normal_fh","def open_file(file_path, mode=None, buffer_size=FILE_BUFFER_SIZE, gzip_exts=('.gz','.gzip'), partial=False):\n import io\n \n if os.path.splitext(file_path)[1].lower() in gzip_exts:\n if mode and 'w' in mode:\n file_obj = BufferedWriter(gzip.open(file_path, mode), buffer_size)\n \n else:\n if partial:\n file_obj = BufferedReader(gzip.open(file_path, mode or 'rb'), buffer_size)\n \n else:\n try:\n file_obj = subprocess.Popen(['zcat', file_path], stdout=subprocess.PIPE).stdout\n except OSError:\n file_obj = BufferedReader(gzip.open(file_path, mode or 'rb'), buffer_size)\n \n if sys.version_info.major > 2:\n file_obj = io.TextIOWrapper(file_obj, encoding=\"utf-8\")\n \n else:\n if sys.version_info.major > 2:\n file_obj = open(file_path, mode or 'rU', buffer_size, encoding='utf-8')\n \n else:\n file_obj = open(file_path, mode or 'rU', buffer_size)\n \n return file_obj","def smart_open(filename, mode):\n if filename.endswith(\".bz2\"):\n opener = bz2.BZ2File\n elif filename.endswith(\".gz\"):\n opener = gzip.open\n else:\n opener = open\n return opener(filename, mode)","def qiime_open(fp, permission='U'):\r\n if is_gzip(fp):\r\n return gzip_open(fp)\r\n else:\r\n return open(fp, permission)","def _open_zipped(infile, mode='r', encoding='utf-8'):\n mode = mode[0] + 't'\n p2mode = mode\n if hasattr(infile, 'write'):\n return infile\n if isinstance(infile, str):\n if infile.endswith('.gz'):\n return _zopen(infile, mode)\n if infile.endswith('.bz2'):\n return _bopen(infile, mode)\n return open(infile, p2mode, encoding=encoding)","def get_infile(filename):\r\n if filename.endswith(\".gz\"):\r\n fin = GzipFile(filename, \"rb\")\r\n else:\r\n fin = open(filename, \"U\")\r\n return fin","def get_infile(filename):\r\n if filename.endswith(\".gz\"):\r\n fin = GzipFile(filename, \"rb\")\r\n else:\r\n fin = open(filename, \"U\")\r\n return fin","def zopen(filename: Union[str, Path], *args, **kwargs) -> IO:\n if Path is not None and isinstance(filename, Path):\n filename = str(filename)\n\n name, ext = os.path.splitext(filename)\n ext = ext.upper()\n if ext == \".BZ2\":\n return bz2.open(filename, *args, **kwargs)\n if ext in (\".GZ\", \".Z\"):\n return gzip.open(filename, *args, **kwargs)\n if ext in (\".XZ\", \".LZMA\"):\n return lzma.open(filename, *args, **kwargs)\n return open(filename, *args, **kwargs) # pylint: disable=R1732","def _get_correct_open(filepath, contentfile=None): #second param is content file name, only used in .zip case\n if filepath[-4:] == '.txt':\n openfun = open\n elif filepath[-3:] == '.gz':\n openfun = gzip.open\n elif filepath[-4:] == '.zip':\n # assume the zip only contains one file\n def openfun(filepath, mode): #more is 'r' or 'w'\n if mode =='r':\n zz = zipfile.ZipFile(filepath)\n #if mode =='w':\n # Do this later..\n return zz.open(contentfile, 'r')\n else:\n openfun = open\n return openfun","def open_zipped(infile, mode='r'):\n mode = mode[0] + 't'\n p2mode = mode\n if hasattr(infile, 'write'):\n return infile\n if isinstance(infile, str):\n if infile.endswith('.gz'):\n return gzip.open(infile, mode)\n if infile.endswith('.bz2'):\n if hasattr(bz2, 'open'):\n return bz2.open(infile, mode)\n else:\n return bz2.BZ2File(infile, p2mode)\n return open(infile, p2mode)","def open_compressed(filename, open_flag='r', compression_type='bz2'):\n # create temporary HDF5 file name\n hdf5_file_name = tempfile.mkstemp('.hdf5', 'bob_')[1]\n\n if open_flag == 'r':\n # extract the HDF5 file from the given file name into a temporary file name\n tar = tarfile.open(filename, mode=\"r:\" + compression_type)\n memory_file = tar.extractfile(tar.next())\n real_file = open(hdf5_file_name, 'wb')\n real_file.write(memory_file.read())\n del memory_file\n real_file.close()\n tar.close()\n\n return bob.io.base.HDF5File(hdf5_file_name, open_flag)","def _get_open_func(cls, filename: str, mode: str) -> Tuple[OpenFunc, str]:\n if filename.endswith('.gz'):\n return gzip.open, cls._map_disk_type('{}t', '{}').format(mode)\n else:\n return open, cls._map_disk_type('{}', '{}b').format(mode)","def file_test(vcf_file):\n if vcf_file.endswith(\".gz\"):\n return gzip.open, \"rt\"\n else:\n return open, \"rt\"","def auto_open(self, filename):\n if filename.endswith('.gz'):\n return gzip.open(filename)\n if not ( filename.endswith('.xml') or filename.endswith('.lmf') ):\n self.my_print(\"non-standard file extension\", msg_types.WARNING)\n return open(filename)","def _gzip_reader_fn():\n return tf.TFRecordReader(\n options=tf.python_io.TFRecordOptions(\n compression_type=tf.python_io.TFRecordCompressionType.GZIP))","def do_gzip(fileobj):\r\n sio = cStringIO.StringIO()\r\n gzf = gzip.GzipFile(fileobj = sio, mode = \"wb\")\r\n while True:\r\n data = fileobj.read(buf_size)\r\n if not data:\r\n break\r\n gzf.write(data)\r\n gzf.close()\r\n return sio","def _gzip_file(filename):\n gzip_filename = filename + '.gz'\n with open(filename, 'rb') as f_in, gzip.open(gzip_filename, 'wb') as f_out:\n shutil.copyfileobj(f_in, f_out)","def xopen(filename, mode='r'):\n\tassert isinstance(filename, basestring)\n\tif filename == '-':\n\t\treturn sys.stdin if 'r' in mode else sys.stdout\n\tif filename.endswith('.bz2'):\n\t\tif bz2 is None:\n\t\t\traise ImportError(\"Cannot open bz2 files: The bz2 module is not available\")\n\t\tif PY3:\n\t\t\treturn io.TextIOWrapper(bz2.BZ2File(filename, mode))\n\t\telse:\n\t\t\treturn bz2.BZ2File(filename, mode)\n\n\telif filename.endswith('.gz'):\n\t\tif PY3:\n\t\t\treturn io.TextIOWrapper(gzip.open(filename, mode))\n\t\telse:\n\t\t\tif 'r' in mode:\n\t\t\t\ttry:\n\t\t\t\t\treturn Popen(['gzip', '-cd', filename], stdout=PIPE).stdout\n\t\t\t\texcept IOError:\n\t\t\t\t\t# gzip not installed\n\t\t\t\t\treturn buffered_reader(gzip.open(filename, mode))\n\t\t\telse:\n\t\t\t\ttry:\n\t\t\t\t\treturn GzipWriter(filename)\n\t\t\t\texcept IOError:\n\t\t\t\t\treturn buffered_writer(gzip.open(filename, mode))\n\telse:\n\t\treturn open(filename, mode)","def file_open(*args, **kwargs):\n return open(*args, **kwargs)","def _determine_compression_safe_file_opener(self):\n f = gzip.open(self.input_fname, \"r\")\n try:\n f.read(1)\n self._compression_safe_file_opener = gzip.open\n except IOError:\n self._compression_safe_file_opener = open\n finally:\n f.close()","def _get_file_handle(\n filepath,\n mode,\n *,\n compression=None,\n encoding=None,\n errors=None,\n newline=None,\n):\n if compression:\n mode_ = mode.replace(\"b\", \"\").replace(\"t\", \"\")\n if compression == \"gzip\":\n f = gzip.GzipFile(filepath, mode=mode_)\n elif compression == \"bz2\":\n f = bz2.BZ2File(filepath, mode=mode_)\n elif compression == \"xz\":\n f = lzma.LZMAFile(filepath, mode=mode_)\n elif compression == \"zip\":\n zip_file = zipfile.ZipFile(filepath, mode=mode_)\n zip_names = zip_file.namelist()\n if len(zip_names) == 1:\n f = zip_file.open(zip_names[0])\n elif len(zip_names) == 0:\n raise ValueError(f\"no files found in zip file '{filepath}'\")\n else:\n raise ValueError(\n f\"{len(zip_names)} files found in zip file '{filepath}', \"\n \"but only one file is allowed\"\n )\n else:\n valid_values = [None, \"infer\"] + sorted(_ext_to_compression.values())\n raise ValueError(\n errors_.value_invalid_msg(\"compression\", compression, valid_values)\n )\n\n if \"t\" in mode:\n f = io.TextIOWrapper(f, encoding=encoding, errors=errors, newline=newline)\n\n # no compression, file is opened as usual\n else:\n f = filepath.open(mode=mode, encoding=encoding, errors=errors, newline=newline)\n\n return f","def open(self, filename: str, mode: str) -> IO[AnyStr]:\n # Make sure mode is either 'r' or 'w'\n if mode not in {'r', 'w', 'R', 'W'}:\n raise ValueError(f\"Mode must be 'r' or 'w', not '{mode}'\")\n mode = mode.lower()\n\n if filename.endswith(\".gz\"):\n mode = mode if self.binary_mode(filename) else f\"{mode}t\"\n return gzip.open(filename, mode)\n else:\n mode = f\"{mode}b\" if self.binary_mode(filename) else mode\n return open(filename, mode)","def open_any(filename):\n if filename == '-':\n fh = sys.stdin\n elif filename[-3:] == '.gz':\n fh = GzipFile(filename, 'r')\n elif filename[-4:] == '.bz2':\n fh = BZ2File(filename, 'r')\n else:\n fh = open(filename, 'r')\n\n return fh","def handle_file(self, path):\n\n if path:\n if not matches_patterns(path, self.gzip_patterns):\n return\n\n try:\n original_file = self.open(path, mode=\"rb\")\n except FileNotFoundError:\n pass\n else:\n gzipped_path = \"{0}.gz\".format(path)\n\n if self.exists(gzipped_path):\n self.delete(gzipped_path)\n\n gzipped_file = self._compress(original_file)\n gzipped_path = self.save(gzipped_path, gzipped_file)\n\n return gzipped_path, gzipped_path, True","def _open(path, mode, encoding=None):\n # type: (str, str, Optional[str]) -> typing.IO[Any]\n if mode not in {'r', 'rb', 'rt'}:\n raise ValueError('r')\n _, ext = os.path.splitext(path)\n ext = ext.lower()\n if ext == \".gz\":\n return gzip.open(path, mode, encoding=encoding)\n elif ext == \".bz2\":\n return bz2.open(path, mode, encoding=encoding)\n elif ext == \".xz\":\n return lzma.open(path, mode, encoding=encoding)\n elif ext == \".zip\":\n arh = zipfile.ZipFile(path, 'r')\n filelist = arh.infolist()\n if len(filelist) == 1:\n filename = filelist[0]\n zinfo = arh.getinfo(filename)\n f = arh.open(zinfo.filename, 'r')\n if 't' in mode:\n f = io.TextIOWrapper(f, encoding=encoding)\n return f\n else:\n raise ValueError(\"Expected a single file in the archive.\")\n else:\n return open(path, mode, encoding=encoding)","def bz2_file_reader(path):\n return bz2.open(path, 'rt')","def decompress_gzip(in_str):\n # gzip can only handle file object therefore using StringIO\n copmressed_stream = StringIO.StringIO(in_str)\n gzipper = gzip.GzipFile(fileobj=copmressed_stream)\n s = gzipper.read()\n gzipper.close()\n return s","def _import_zlib_fname(self, fn):\n b_zlib = readbytes(fn)\n\n return self._import_zlib_bytes(b_zlib)","def open_file_by_type(file_name, mode=\"r\"):\n file_name = op.expanduser(file_name) # expands '~' to the absolute home dir\n if file_name.endswith(\"bz2\"):\n return bz2.open(file_name, mode)\n elif file_name.endswith(\"gz\"):\n return gzip.open(file_name, mode, encoding=\"utf-8\")\n else:\n return open(file_name, mode, encoding=\"utf-8\")","def opener_from_zipfile(zipfile):\n\n def opener(filename):\n inner_file = zipfile.open(filename)\n if PY3:\n from io import TextIOWrapper\n return TextIOWrapper(inner_file)\n else:\n return inner_file\n\n return opener","def fileopen(file):\n return _posixfile_().fileopen(file)","def decompress_gzip(in_str):\n import gzip\n # gzip can only handle file object therefore using StringIO\n copmressed_stream = StringIO.StringIO(in_str)\n gzipper = gzip.GzipFile(fileobj=copmressed_stream)\n s = gzipper.read()\n gzipper.close()\n return s","def __init__(self, path: str):\n self._path = path\n self._fp = gzip.open(self._path, mode=\"r\")","def _gzip_reader_fn(filenames):\n return tf.data.TFRecordDataset(\n filenames,\n compression_type='GZIP')","def _gzip_reader_fn(filenames):\n return tf.data.TFRecordDataset(\n filenames,\n compression_type='GZIP')","def parse_fastq(filepath):\n if REGEX_GZIPPED.match(filepath):\n logging.debug('Opening \"%s\" as gzipped file', filepath)\n # using os.popen with zcat since it is much faster than gzip.open or gzip.open(io.BufferedReader)\n # http://aripollak.com/pythongzipbenchmarks/\n # assumes Linux os with zcat installed\n import os\n with os.popen('zcat < {}'.format(filepath)) as f:\n yield from _parse_fastq(f)\n else:\n with open(filepath, 'r') as f:\n yield from _parse_fastq(f)","def _gzip_reader_fn(filenames):\n return tf.data.TFRecordDataset(filenames, compression_type=\"GZIP\")","def _file_handle(file_ref, mode='r'):\n if not mode in 'rw':\n raise ValueError(\"mode must be 'r' or 'w'\")\n\n def _is_string_like(obj):\n try:\n obj + ''\n except (TypeError, ValueError):\n return False\n return True\n\n try:\n if _is_string_like(file_ref):\n if file_ref.endswith('.gz'):\n import gzip\n fh = gzip.open(file_ref, mode='%sb' % mode)\n else:\n if mode == 'r':\n fh = open(file_ref, 'U')\n else:\n fh = open(file_ref, 'w')\n else:\n fh = file_ref\n except TypeError:\n raise ValueError('input file must be a path or file handle')\n\n return fh","def _gzip_reader_fn(filenames):\n return tf.data.TFRecordDataset(filenames, compression_type='GZIP')","def _gzip_reader_fn(filenames):\n return tf.data.TFRecordDataset(\n filenames,\n compression_type='GZIP')","def prepare_gz(self, filename, *args, **kwargs):\n\n return '/vsigzip/' + filename, args, kwargs","def open_zip_file(self, filepath: str, mode=\"r\"):\n with ZipFile(self.zipped_code_path, \"r\") as z:\n return z.open(filepath, mode=mode)","def open_with_size(filename, *args):\n\n f = open_(filename, *args)\n if isinstance(f, gzip.GzipFile):\n fo = open(f.name, 'rb')\n fo.seek(-4, 2)\n r = fo.read()\n fo.close()\n return f, struct.unpack('<I', r)[0]\n else:\n f.seek(0, os.SEEK_END)\n buflen = f.tell()\n f.seek(4, os.SEEK_SET)\n return f, buflen","def _filehandle(self):\n if not self._fh or self._is_closed():\n filename = self._rotated_logfile or self.filename\n if filename.endswith('.gz'):\n self._fh = gzip.open(filename, 'r')\n else:\n self._fh = open(filename, \"r\", 1)\n self._fh.seek(self._offset)\n\n return self._fh","def extracted_file(fname: str):\n new_fname = extract_gzip(fname)\n gzipped = True\n if new_fname is None:\n new_fname = fname\n gzipped = False\n\n try:\n yield new_fname\n finally:\n if gzipped:\n try:\n bgzip_and_name(new_fname)\n except Exception:\n gzip_and_name(new_fname)","def parse(path):\n data = gzip.open(path, 'rb')\n for byte_line in data:\n yield eval(byte_line) # return generator instance to save memory","def gzip_compress(data):\n s = BytesIO()\n g = gzip.GzipFile(fileobj=s, mode='wb')\n g.write(data)\n g.close()\n return s.getvalue()","def extract_gzip(fname: str, outfile: Optional[str] = None) -> Union[str, None]:\n if not outfile:\n outfile = fname[:-3]\n\n if fname.endswith(\".gz\"):\n with gzip.open(fname, \"rb\") as f_in:\n with open(outfile, \"wb\") as f_out:\n shutil.copyfileobj(f_in, f_out)\n os.unlink(fname)\n return outfile","def DecompressionFile(src_fp, algorithm):\n if algorithm == \"lzma\":\n return lzma.open(src_fp, \"r\")\n\n if algorithm == \"snappy\":\n return SnappyFile(src_fp, \"rb\")\n\n if algorithm:\n raise InvalidConfigurationError(\"invalid compression algorithm: {!r}\".format(algorithm))\n\n return src_fp","def _gz(filename):\n \n with open(filename, 'rb') as f:\n return binascii.hexlify(f.read(2)) == b'1f8b'","def get_create_handler(self):\n return gzip.open(self.index_abspath, 'wt', compresslevel=self.compress_level)","def _compress_string(content):\n zbuf = StringIO()\n zfile = GzipFile(mode='wb', compresslevel=6, fileobj=zbuf)\n zfile.write(content)\n zfile.close()\n return zbuf.getvalue()","def CompressionFile(dst_fp, algorithm, level=0):\n if algorithm == \"lzma\":\n return lzma.open(dst_fp, \"w\", preset=level)\n\n if algorithm == \"snappy\":\n return SnappyFile(dst_fp, \"wb\")\n\n if algorithm:\n raise InvalidConfigurationError(\"invalid compression algorithm: {!r}\".format(algorithm))\n\n return dst_fp","def is_gz_file(f):\n with open(f, \"rb\") as fin:\n return binascii.hexlify(fin.read(2)) == b\"1f8b\"","def _CreateTaskStorageMergeReader(self, path):\n return gzip_file.GZIPStorageMergeReader(self, path)","def openFileRd(in_file):\n try:\n # First see if this file is gzipped\n try:\n # Opening the file works even if it is not a gzip file\n proto_in = gzip.open(in_file, \"rb\")\n\n # Force a check of the magic number by seeking in the\n # file. If we do not do it here the error will occur when\n # reading the first message.\n proto_in.seek(1)\n proto_in.seek(0)\n except IOError:\n proto_in = open(in_file, \"rb\")\n except IOError:\n print(\"Failed to open \", in_file, \" for reading\")\n exit(-1)\n return proto_in","def open_file(path, config):\n\n return fopen(normalize_path(path, config))","def open(self, filepath: str, mode=\"r\"):\n _, ext = os.path.splitext(filepath)\n\n if not self.is_local:\n f = self.open_zip_file(filepath, mode=mode)\n return self.parse_file(f, ext, decode_bytes=True)\n\n # opening the file locally is easy\n with open(filepath, mode=mode) as f:\n return self.parse_file(f, ext)","def bz2_file_bytes_reader(path):\n return bz2.open(path, 'rb')","def gunzip(data):\n return gzip.GzipFile(fileobj=StringIO(data)).read()","def file_open(path: str, mode: str):\n if _path_on_gcp(path):\n return tf.io.gfile.GFile(path, mode)\n return open(path, mode)","def gen_opener(filenames):\n for filename in filenames:\n if str(filename).endswith('.gz'):\n f = gzip.open(filename, 'rt')\n elif str(filename).endswith('.bz2'):\n f = bz2.open(filename, 'rt')\n else:\n f = open(filename, 'rt')\n yield f\n f.close()","def smart_open(filename, *args, **kwargs):\n return LOADERS.get(os.path.splitext(filename)[1], open)(filename, *args, **kwargs)","def read_filepath_or_buffer(f, open_flags=\"r\", compression=None):\n f, handles, close = open_filepath_or_buffer(\n f, open_flags=open_flags, compression=compression\n )\n try:\n data = f.read()\n finally:\n if close:\n try:\n f.close()\n except ValueError:\n pass\n return data","def open_file(filename):\n log.debug(\"filename: %s\\n\" % filename)\n if filename:\n return open(filename, \"w\")\n else:\n return tempfile.NamedTemporaryFile(mode=\"w+t\", delete=False)","def de_gzip(data):\n cmps = StringIO.StringIO(data)\n gzipper = gzip.GzipFile(fileobj=cmps)\n return gzipper.read()","def de_gzip(data):\n cmps = StringIO.StringIO(data)\n gzipper = gzip.GzipFile(fileobj=cmps)\n return gzipper.read()","def ungz(filepath, compression='rb', deletesource=False):\n\n import gzip\n\n with gzip.open(filepath, compression) as f:\n outF = open(filepath[:-3], 'wb')\n outF.write(f.read())\n f.close()\n outF.close()\n if deletesource:\n try:\n os.remove(filepath)\n except:\n raise Exception(\"Could not delete gz archive {0}.\".format(filepath))\n\n return filepath[:-3]","def open_file(path):\n return open(path, encoding='utf-8')","def _open(self, file_path=None):\n\t\tif file_path is None:\n\t\t\tfile_path = self.file_path\n\n\t\tif not os.path.exists(file_path):\n\t\t\traise ValueError('Could not find file: {}'.format(file_path))\n\n\t\ttry:\n\t\t\tf = open(file_path, encoding='utf-8', newline='')\n\t\texcept OSError as err:\n\t\t\tself.log.error(str(err))\n\t\t\traise ValueError('Could not open file: {}'.format(file_path))\n\n\t\treturn f","def compress_file(path):\n\n process = Popen([\"xz\", \"--compress\", \"--force\", \"--stdout\", path], stdout=PIPE)\n return process.communicate()[0]","def compress_file(path):\n\n process = Popen([\"xz\", \"--compress\", \"--force\", \"--stdout\", path], stdout=PIPE)\n return process.communicate()[0]","def is_gzip(fp):\r\n return open(fp, 'rb').read(2) == '\\x1f\\x8b'","def open_file(file_path, mode='rb', encoding='iso-8859-1'):\n try:\n return open(file_path, mode=mode, encoding=encoding)\n except IOError:\n raise","def test_compress_file_response(self):\n with open(__file__, \"rb\") as file1:\n\n def get_response(req):\n file_resp = FileResponse(file1)\n file_resp[\"Content-Type\"] = \"text/html; charset=UTF-8\"\n return file_resp\n\n r = GZipMiddleware(get_response)(self.req)\n with open(__file__, \"rb\") as file2:\n self.assertEqual(self.decompress(b\"\".join(r)), file2.read())\n self.assertEqual(r.get(\"Content-Encoding\"), \"gzip\")\n self.assertIsNot(r.file_to_stream, file1)","def _gzipencode(content):\n import gzip\n out = BytesIO()\n f = gzip.GzipFile(fileobj=out, mode='w', compresslevel=5)\n f.write(content)\n f.close()\n return out.getvalue()","def gzinflate(val):\n return zlib.decompress(val)","def open_file(file_name):\n pass","def open_zip(path, *args, **kwargs):\r\n with contextlib.closing(zipfile.ZipFile(path, *args, **kwargs)) as zip:\r\n yield zip","def openInputFile(infile, *args):\n if infile is None:\n logging.info(\"Reading input from STDIN\")\n return sys.stdin\n\n if isinstance(infile, str):\n if urlRE.match(infile):\n import urllib2\n return urllib2.urlopen(infile)\n if len(infile)>3 and infile[-3:]=='.gz':\n import gzip\n return gzip.GzipFile(infile,'rb')\n elif len(infile)>4 and infile[-4:]=='.bz2':\n import bz2\n return bz2.BZ2File(infile,'rb')\n else:\n return open(infile,'rt')\n else:\n return infile","def harmony_open_file(data):\n\n return Harmony(data)","def open_files(filenames):\n for filename in filenames:\n if filename.endswith('.gz') or filename.endswith('.zip'):\n yield gzip.open(filename, 'r')\n else:\n yield open(filename, 'rb')","def open_file(filename):\n print(\"filename: %s\\n\" % filename)\n if filename:\n return open(filename, \"w\")\n else:\n return tempfile.NamedTemporaryFile(delete=False)","def isgzip(filename):\n magic_number = b'\\x1f\\x8b\\x08'\n with open(filename, 'rb') as f:\n file_start = f.read(len(magic_number))\n\n if magic_number == file_start:\n return True\n return False","def maybe_compress(filename, compress_minsize=config.COMPRESS_MINSIZE):\n size = os.path.getsize(filename)\n if size < compress_minsize:\n return open(filename, 'rb'), False\n\n compressed_size, compressed_fobj = compress_file(filename)\n if compressed_size >= size:\n # Compressed file was larger\n log.info(\"%s was larger when compressed; using uncompressed version\", filename)\n return open(filename, 'rb'), False\n\n return compressed_fobj, True","def open_archive(filename: str, mode: str = 'rb', use_extension: bool = True):\n # extension_map maps magic_number to extension.\n # Unfortunately, legacy LZMA container has no magic number\n extension_map = {\n b'BZh': 'bz2',\n b'\\x1F\\x8B\\x08': 'gz',\n b\"7z\\xBC\\xAF'\\x1C\": '7z',\n b'\\xFD7zXZ\\x00': 'xz',\n }\n\n if mode in ('r', 'a', 'w'):\n mode += 'b'\n elif mode not in ('rb', 'ab', 'wb'):\n raise ValueError('Invalid mode: \"{}\"'.format(mode))\n\n if use_extension:\n # if '.' not in filename, it'll be 1 character long but otherwise\n # contain the period\n extension = filename[filename.rfind('.'):][1:]\n else:\n if mode != 'rb':\n raise ValueError('Magic number detection only when reading')\n with open(filename, 'rb') as f:\n magic_number = f.read(8)\n\n for pattern in extension_map:\n if magic_number.startswith(pattern):\n extension = extension_map[pattern]\n break\n else:\n extension = ''\n\n if extension == 'bz2':\n if isinstance(bz2, ImportError):\n raise bz2\n return bz2.BZ2File(filename, mode)\n\n if extension == 'gz':\n return gzip.open(filename, mode)\n\n if extension == '7z':\n if mode != 'rb':\n raise NotImplementedError('It is not possible to write a 7z file.')\n\n try:\n process = subprocess.Popen(['7za', 'e', '-bd', '-so', filename],\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n bufsize=65535)\n except OSError:\n raise ValueError('7za is not installed or cannot '\n 'uncompress \"{}\"'.format(filename))\n else:\n stderr = process.stderr.read()\n process.stderr.close()\n if stderr != b'':\n process.stdout.close()\n raise OSError(\n 'Unexpected STDERR output from 7za {}'.format(stderr))\n return process.stdout\n\n if extension in ('lzma', 'xz'):\n if isinstance(lzma, ImportError):\n raise lzma\n lzma_fmts = {'lzma': lzma.FORMAT_ALONE, 'xz': lzma.FORMAT_XZ}\n return lzma.open(filename, mode, format=lzma_fmts[extension])\n\n # assume it's an uncompressed file\n return open(filename, 'rb')","def gzip_and_name(fname, gzip_file=True) -> str:\n if gzip_file:\n with open(fname, \"rb\") as f_in:\n with gzip.open(fname + \".gz\", \"wb\") as f_out:\n shutil.copyfileobj(f_in, f_out)\n os.unlink(fname)\n fname += \".gz\"\n return fname","def gzipFile(aFile):\n f_in = open(aFile, \"rb\")\n f_out = gzip.open(aFile + \".gz\", \"wb\")\n f_out.writelines(f_in)\n f_out.close()\n f_in.close()\n os.remove(aFile)"],"string":"[\n \"def open_gz(filename, mode):\\n return gzip.open(filename, mode)\",\n \"def open_gzip(fn):\\n magic = b'\\\\x1f\\\\x8b\\\\x08'\\n l = len(magic)\\n with open(fn, 'rb') as f:\\n file_start = f.read(l)\\n f.seek(0)\\n # check if the file is compressed\\n if file_start.startswith(magic):\\n return gzip.open(fn, 'rt')\\n # not compressed\\n return open(fn, 'rt')\",\n \"def gzopen(f):\\n return gzip.open(f, 'rb') if f.endswith('.gz') else open(f, 'r')\",\n \"def open_(filename, mode=None, compresslevel=9):\\n if filename[-3:] == '.gz':\\n if mode is None: mode = 'rt'\\n return closing(gzip.open(filename, mode, compresslevel))\\n else:\\n if mode is None: mode = 'r'\\n return open(filename, mode)\",\n \"def open_gzipped(infile, mode='rt'):\\n import gzip\\n import bz2\\n if mode.startswith('r'):\\n tmode = 'rt'\\n bmode = 'r'\\n elif mode.startswith('w'):\\n tmode = 'wt'\\n bmode = 'w'\\n elif mode.startswith('a'):\\n tmode = 'at'\\n bmode = 'a'\\n if hasattr(infile, 'write'):\\n return infile\\n if isinstance(infile, str):\\n if infile.endswith('.gz'):\\n return gzip.open(infile, tmode)\\n if infile.endswith('.bz2'):\\n if hasattr(bz2, 'open'):\\n return bz2.open(infile, tmode)\\n else:\\n return bz2.BZ2File(infile, bmode)\\n return open(infile, tmode)\",\n \"def open_(filename, *args):\\n\\n if (filename[-3:] == '.gz'):\\n return gzip.open(filename, *args)\\n try:\\n return open(filename, *args)\\n except OSError:\\n return gzip.open(filename + \\\".gz\\\", *args)\",\n \"def genOpen(filename, mode):\\n (name, ext) = os.path.splitext(filename)\\n if ext == \\\".gz\\\":\\n return gzip.open(filename, mode)\\n else:\\n return open(filename, mode)\",\n \"def genOpen(filename, mode):\\n (name, ext) = os.path.splitext(filename)\\n if ext == \\\".gz\\\":\\n return gzip.open(filename, mode)\\n else:\\n return open(filename, mode)\",\n \"def smart_open(file, mode='rt', encoding='utf-8'):\\n if file.endswith('.gz'):\\n return gzip.open(file, mode=mode, encoding=encoding, newline=\\\"\\\\n\\\")\\n return open(file, mode=mode, encoding=encoding, newline=\\\"\\\\n\\\")\",\n \"def smart_open(filename: str, mode: str = \\\"rt\\\", ftype: str = \\\"auto\\\", errors: str = \\\"replace\\\"):\\n if ftype == \\\"gzip\\\" or ftype == \\\"gz\\\" or (ftype == \\\"auto\\\" and filename.endswith(\\\".gz\\\")):\\n return gzip.open(filename, mode=mode, encoding=\\\"utf-8\\\", errors=errors)\\n else:\\n return open(filename, mode=mode, encoding=\\\"utf-8\\\", errors=errors)\",\n \"def openFile(file):\\n file = file.lower()\\n if file.endswith('.bz2'):\\n return bz2.BZ2File(file)\\n elif file.endswith('.gz'):\\n return gzip.open(file)\\n return open(file)\",\n \"def crackOpen(path: Union[pathlib.Path, str], mode: str=\\\"r\\\", **args: Any) -> Generator[Union[gzip.GzipFile, TextIO, IO[Any]], None, None]:\\n p = pathlib.Path(path)\\n _, encoding = mimetypes.guess_type(p.name)\\n if encoding == \\\"gzip\\\":\\n if not mode.endswith(\\\"b\\\"):\\n mode += \\\"t\\\" # Force text mode if binary not requested\\n with gzip.open(path, mode, **args) as f:\\n yield f\\n else:\\n with open(path, mode, **args) as g:\\n yield g\",\n \"def return_file_handle(input_file):\\n if str(input_file).endswith(\\\".gz\\\"):\\n gzipped_file_handle = gzip.open(input_file, \\\"rt\\\")\\n return gzipped_file_handle\\n else:\\n normal_fh = open(input_file, \\\"r\\\")\\n return normal_fh\",\n \"def open_file(file_path, mode=None, buffer_size=FILE_BUFFER_SIZE, gzip_exts=('.gz','.gzip'), partial=False):\\n import io\\n \\n if os.path.splitext(file_path)[1].lower() in gzip_exts:\\n if mode and 'w' in mode:\\n file_obj = BufferedWriter(gzip.open(file_path, mode), buffer_size)\\n \\n else:\\n if partial:\\n file_obj = BufferedReader(gzip.open(file_path, mode or 'rb'), buffer_size)\\n \\n else:\\n try:\\n file_obj = subprocess.Popen(['zcat', file_path], stdout=subprocess.PIPE).stdout\\n except OSError:\\n file_obj = BufferedReader(gzip.open(file_path, mode or 'rb'), buffer_size)\\n \\n if sys.version_info.major > 2:\\n file_obj = io.TextIOWrapper(file_obj, encoding=\\\"utf-8\\\")\\n \\n else:\\n if sys.version_info.major > 2:\\n file_obj = open(file_path, mode or 'rU', buffer_size, encoding='utf-8')\\n \\n else:\\n file_obj = open(file_path, mode or 'rU', buffer_size)\\n \\n return file_obj\",\n \"def smart_open(filename, mode):\\n if filename.endswith(\\\".bz2\\\"):\\n opener = bz2.BZ2File\\n elif filename.endswith(\\\".gz\\\"):\\n opener = gzip.open\\n else:\\n opener = open\\n return opener(filename, mode)\",\n \"def qiime_open(fp, permission='U'):\\r\\n if is_gzip(fp):\\r\\n return gzip_open(fp)\\r\\n else:\\r\\n return open(fp, permission)\",\n \"def _open_zipped(infile, mode='r', encoding='utf-8'):\\n mode = mode[0] + 't'\\n p2mode = mode\\n if hasattr(infile, 'write'):\\n return infile\\n if isinstance(infile, str):\\n if infile.endswith('.gz'):\\n return _zopen(infile, mode)\\n if infile.endswith('.bz2'):\\n return _bopen(infile, mode)\\n return open(infile, p2mode, encoding=encoding)\",\n \"def get_infile(filename):\\r\\n if filename.endswith(\\\".gz\\\"):\\r\\n fin = GzipFile(filename, \\\"rb\\\")\\r\\n else:\\r\\n fin = open(filename, \\\"U\\\")\\r\\n return fin\",\n \"def get_infile(filename):\\r\\n if filename.endswith(\\\".gz\\\"):\\r\\n fin = GzipFile(filename, \\\"rb\\\")\\r\\n else:\\r\\n fin = open(filename, \\\"U\\\")\\r\\n return fin\",\n \"def zopen(filename: Union[str, Path], *args, **kwargs) -> IO:\\n if Path is not None and isinstance(filename, Path):\\n filename = str(filename)\\n\\n name, ext = os.path.splitext(filename)\\n ext = ext.upper()\\n if ext == \\\".BZ2\\\":\\n return bz2.open(filename, *args, **kwargs)\\n if ext in (\\\".GZ\\\", \\\".Z\\\"):\\n return gzip.open(filename, *args, **kwargs)\\n if ext in (\\\".XZ\\\", \\\".LZMA\\\"):\\n return lzma.open(filename, *args, **kwargs)\\n return open(filename, *args, **kwargs) # pylint: disable=R1732\",\n \"def _get_correct_open(filepath, contentfile=None): #second param is content file name, only used in .zip case\\n if filepath[-4:] == '.txt':\\n openfun = open\\n elif filepath[-3:] == '.gz':\\n openfun = gzip.open\\n elif filepath[-4:] == '.zip':\\n # assume the zip only contains one file\\n def openfun(filepath, mode): #more is 'r' or 'w'\\n if mode =='r':\\n zz = zipfile.ZipFile(filepath)\\n #if mode =='w':\\n # Do this later..\\n return zz.open(contentfile, 'r')\\n else:\\n openfun = open\\n return openfun\",\n \"def open_zipped(infile, mode='r'):\\n mode = mode[0] + 't'\\n p2mode = mode\\n if hasattr(infile, 'write'):\\n return infile\\n if isinstance(infile, str):\\n if infile.endswith('.gz'):\\n return gzip.open(infile, mode)\\n if infile.endswith('.bz2'):\\n if hasattr(bz2, 'open'):\\n return bz2.open(infile, mode)\\n else:\\n return bz2.BZ2File(infile, p2mode)\\n return open(infile, p2mode)\",\n \"def open_compressed(filename, open_flag='r', compression_type='bz2'):\\n # create temporary HDF5 file name\\n hdf5_file_name = tempfile.mkstemp('.hdf5', 'bob_')[1]\\n\\n if open_flag == 'r':\\n # extract the HDF5 file from the given file name into a temporary file name\\n tar = tarfile.open(filename, mode=\\\"r:\\\" + compression_type)\\n memory_file = tar.extractfile(tar.next())\\n real_file = open(hdf5_file_name, 'wb')\\n real_file.write(memory_file.read())\\n del memory_file\\n real_file.close()\\n tar.close()\\n\\n return bob.io.base.HDF5File(hdf5_file_name, open_flag)\",\n \"def _get_open_func(cls, filename: str, mode: str) -> Tuple[OpenFunc, str]:\\n if filename.endswith('.gz'):\\n return gzip.open, cls._map_disk_type('{}t', '{}').format(mode)\\n else:\\n return open, cls._map_disk_type('{}', '{}b').format(mode)\",\n \"def file_test(vcf_file):\\n if vcf_file.endswith(\\\".gz\\\"):\\n return gzip.open, \\\"rt\\\"\\n else:\\n return open, \\\"rt\\\"\",\n \"def auto_open(self, filename):\\n if filename.endswith('.gz'):\\n return gzip.open(filename)\\n if not ( filename.endswith('.xml') or filename.endswith('.lmf') ):\\n self.my_print(\\\"non-standard file extension\\\", msg_types.WARNING)\\n return open(filename)\",\n \"def _gzip_reader_fn():\\n return tf.TFRecordReader(\\n options=tf.python_io.TFRecordOptions(\\n compression_type=tf.python_io.TFRecordCompressionType.GZIP))\",\n \"def do_gzip(fileobj):\\r\\n sio = cStringIO.StringIO()\\r\\n gzf = gzip.GzipFile(fileobj = sio, mode = \\\"wb\\\")\\r\\n while True:\\r\\n data = fileobj.read(buf_size)\\r\\n if not data:\\r\\n break\\r\\n gzf.write(data)\\r\\n gzf.close()\\r\\n return sio\",\n \"def _gzip_file(filename):\\n gzip_filename = filename + '.gz'\\n with open(filename, 'rb') as f_in, gzip.open(gzip_filename, 'wb') as f_out:\\n shutil.copyfileobj(f_in, f_out)\",\n \"def xopen(filename, mode='r'):\\n\\tassert isinstance(filename, basestring)\\n\\tif filename == '-':\\n\\t\\treturn sys.stdin if 'r' in mode else sys.stdout\\n\\tif filename.endswith('.bz2'):\\n\\t\\tif bz2 is None:\\n\\t\\t\\traise ImportError(\\\"Cannot open bz2 files: The bz2 module is not available\\\")\\n\\t\\tif PY3:\\n\\t\\t\\treturn io.TextIOWrapper(bz2.BZ2File(filename, mode))\\n\\t\\telse:\\n\\t\\t\\treturn bz2.BZ2File(filename, mode)\\n\\n\\telif filename.endswith('.gz'):\\n\\t\\tif PY3:\\n\\t\\t\\treturn io.TextIOWrapper(gzip.open(filename, mode))\\n\\t\\telse:\\n\\t\\t\\tif 'r' in mode:\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\treturn Popen(['gzip', '-cd', filename], stdout=PIPE).stdout\\n\\t\\t\\t\\texcept IOError:\\n\\t\\t\\t\\t\\t# gzip not installed\\n\\t\\t\\t\\t\\treturn buffered_reader(gzip.open(filename, mode))\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\treturn GzipWriter(filename)\\n\\t\\t\\t\\texcept IOError:\\n\\t\\t\\t\\t\\treturn buffered_writer(gzip.open(filename, mode))\\n\\telse:\\n\\t\\treturn open(filename, mode)\",\n \"def file_open(*args, **kwargs):\\n return open(*args, **kwargs)\",\n \"def _determine_compression_safe_file_opener(self):\\n f = gzip.open(self.input_fname, \\\"r\\\")\\n try:\\n f.read(1)\\n self._compression_safe_file_opener = gzip.open\\n except IOError:\\n self._compression_safe_file_opener = open\\n finally:\\n f.close()\",\n \"def _get_file_handle(\\n filepath,\\n mode,\\n *,\\n compression=None,\\n encoding=None,\\n errors=None,\\n newline=None,\\n):\\n if compression:\\n mode_ = mode.replace(\\\"b\\\", \\\"\\\").replace(\\\"t\\\", \\\"\\\")\\n if compression == \\\"gzip\\\":\\n f = gzip.GzipFile(filepath, mode=mode_)\\n elif compression == \\\"bz2\\\":\\n f = bz2.BZ2File(filepath, mode=mode_)\\n elif compression == \\\"xz\\\":\\n f = lzma.LZMAFile(filepath, mode=mode_)\\n elif compression == \\\"zip\\\":\\n zip_file = zipfile.ZipFile(filepath, mode=mode_)\\n zip_names = zip_file.namelist()\\n if len(zip_names) == 1:\\n f = zip_file.open(zip_names[0])\\n elif len(zip_names) == 0:\\n raise ValueError(f\\\"no files found in zip file '{filepath}'\\\")\\n else:\\n raise ValueError(\\n f\\\"{len(zip_names)} files found in zip file '{filepath}', \\\"\\n \\\"but only one file is allowed\\\"\\n )\\n else:\\n valid_values = [None, \\\"infer\\\"] + sorted(_ext_to_compression.values())\\n raise ValueError(\\n errors_.value_invalid_msg(\\\"compression\\\", compression, valid_values)\\n )\\n\\n if \\\"t\\\" in mode:\\n f = io.TextIOWrapper(f, encoding=encoding, errors=errors, newline=newline)\\n\\n # no compression, file is opened as usual\\n else:\\n f = filepath.open(mode=mode, encoding=encoding, errors=errors, newline=newline)\\n\\n return f\",\n \"def open(self, filename: str, mode: str) -> IO[AnyStr]:\\n # Make sure mode is either 'r' or 'w'\\n if mode not in {'r', 'w', 'R', 'W'}:\\n raise ValueError(f\\\"Mode must be 'r' or 'w', not '{mode}'\\\")\\n mode = mode.lower()\\n\\n if filename.endswith(\\\".gz\\\"):\\n mode = mode if self.binary_mode(filename) else f\\\"{mode}t\\\"\\n return gzip.open(filename, mode)\\n else:\\n mode = f\\\"{mode}b\\\" if self.binary_mode(filename) else mode\\n return open(filename, mode)\",\n \"def open_any(filename):\\n if filename == '-':\\n fh = sys.stdin\\n elif filename[-3:] == '.gz':\\n fh = GzipFile(filename, 'r')\\n elif filename[-4:] == '.bz2':\\n fh = BZ2File(filename, 'r')\\n else:\\n fh = open(filename, 'r')\\n\\n return fh\",\n \"def handle_file(self, path):\\n\\n if path:\\n if not matches_patterns(path, self.gzip_patterns):\\n return\\n\\n try:\\n original_file = self.open(path, mode=\\\"rb\\\")\\n except FileNotFoundError:\\n pass\\n else:\\n gzipped_path = \\\"{0}.gz\\\".format(path)\\n\\n if self.exists(gzipped_path):\\n self.delete(gzipped_path)\\n\\n gzipped_file = self._compress(original_file)\\n gzipped_path = self.save(gzipped_path, gzipped_file)\\n\\n return gzipped_path, gzipped_path, True\",\n \"def _open(path, mode, encoding=None):\\n # type: (str, str, Optional[str]) -> typing.IO[Any]\\n if mode not in {'r', 'rb', 'rt'}:\\n raise ValueError('r')\\n _, ext = os.path.splitext(path)\\n ext = ext.lower()\\n if ext == \\\".gz\\\":\\n return gzip.open(path, mode, encoding=encoding)\\n elif ext == \\\".bz2\\\":\\n return bz2.open(path, mode, encoding=encoding)\\n elif ext == \\\".xz\\\":\\n return lzma.open(path, mode, encoding=encoding)\\n elif ext == \\\".zip\\\":\\n arh = zipfile.ZipFile(path, 'r')\\n filelist = arh.infolist()\\n if len(filelist) == 1:\\n filename = filelist[0]\\n zinfo = arh.getinfo(filename)\\n f = arh.open(zinfo.filename, 'r')\\n if 't' in mode:\\n f = io.TextIOWrapper(f, encoding=encoding)\\n return f\\n else:\\n raise ValueError(\\\"Expected a single file in the archive.\\\")\\n else:\\n return open(path, mode, encoding=encoding)\",\n \"def bz2_file_reader(path):\\n return bz2.open(path, 'rt')\",\n \"def decompress_gzip(in_str):\\n # gzip can only handle file object therefore using StringIO\\n copmressed_stream = StringIO.StringIO(in_str)\\n gzipper = gzip.GzipFile(fileobj=copmressed_stream)\\n s = gzipper.read()\\n gzipper.close()\\n return s\",\n \"def _import_zlib_fname(self, fn):\\n b_zlib = readbytes(fn)\\n\\n return self._import_zlib_bytes(b_zlib)\",\n \"def open_file_by_type(file_name, mode=\\\"r\\\"):\\n file_name = op.expanduser(file_name) # expands '~' to the absolute home dir\\n if file_name.endswith(\\\"bz2\\\"):\\n return bz2.open(file_name, mode)\\n elif file_name.endswith(\\\"gz\\\"):\\n return gzip.open(file_name, mode, encoding=\\\"utf-8\\\")\\n else:\\n return open(file_name, mode, encoding=\\\"utf-8\\\")\",\n \"def opener_from_zipfile(zipfile):\\n\\n def opener(filename):\\n inner_file = zipfile.open(filename)\\n if PY3:\\n from io import TextIOWrapper\\n return TextIOWrapper(inner_file)\\n else:\\n return inner_file\\n\\n return opener\",\n \"def fileopen(file):\\n return _posixfile_().fileopen(file)\",\n \"def decompress_gzip(in_str):\\n import gzip\\n # gzip can only handle file object therefore using StringIO\\n copmressed_stream = StringIO.StringIO(in_str)\\n gzipper = gzip.GzipFile(fileobj=copmressed_stream)\\n s = gzipper.read()\\n gzipper.close()\\n return s\",\n \"def __init__(self, path: str):\\n self._path = path\\n self._fp = gzip.open(self._path, mode=\\\"r\\\")\",\n \"def _gzip_reader_fn(filenames):\\n return tf.data.TFRecordDataset(\\n filenames,\\n compression_type='GZIP')\",\n \"def _gzip_reader_fn(filenames):\\n return tf.data.TFRecordDataset(\\n filenames,\\n compression_type='GZIP')\",\n \"def parse_fastq(filepath):\\n if REGEX_GZIPPED.match(filepath):\\n logging.debug('Opening \\\"%s\\\" as gzipped file', filepath)\\n # using os.popen with zcat since it is much faster than gzip.open or gzip.open(io.BufferedReader)\\n # http://aripollak.com/pythongzipbenchmarks/\\n # assumes Linux os with zcat installed\\n import os\\n with os.popen('zcat < {}'.format(filepath)) as f:\\n yield from _parse_fastq(f)\\n else:\\n with open(filepath, 'r') as f:\\n yield from _parse_fastq(f)\",\n \"def _gzip_reader_fn(filenames):\\n return tf.data.TFRecordDataset(filenames, compression_type=\\\"GZIP\\\")\",\n \"def _file_handle(file_ref, mode='r'):\\n if not mode in 'rw':\\n raise ValueError(\\\"mode must be 'r' or 'w'\\\")\\n\\n def _is_string_like(obj):\\n try:\\n obj + ''\\n except (TypeError, ValueError):\\n return False\\n return True\\n\\n try:\\n if _is_string_like(file_ref):\\n if file_ref.endswith('.gz'):\\n import gzip\\n fh = gzip.open(file_ref, mode='%sb' % mode)\\n else:\\n if mode == 'r':\\n fh = open(file_ref, 'U')\\n else:\\n fh = open(file_ref, 'w')\\n else:\\n fh = file_ref\\n except TypeError:\\n raise ValueError('input file must be a path or file handle')\\n\\n return fh\",\n \"def _gzip_reader_fn(filenames):\\n return tf.data.TFRecordDataset(filenames, compression_type='GZIP')\",\n \"def _gzip_reader_fn(filenames):\\n return tf.data.TFRecordDataset(\\n filenames,\\n compression_type='GZIP')\",\n \"def prepare_gz(self, filename, *args, **kwargs):\\n\\n return '/vsigzip/' + filename, args, kwargs\",\n \"def open_zip_file(self, filepath: str, mode=\\\"r\\\"):\\n with ZipFile(self.zipped_code_path, \\\"r\\\") as z:\\n return z.open(filepath, mode=mode)\",\n \"def open_with_size(filename, *args):\\n\\n f = open_(filename, *args)\\n if isinstance(f, gzip.GzipFile):\\n fo = open(f.name, 'rb')\\n fo.seek(-4, 2)\\n r = fo.read()\\n fo.close()\\n return f, struct.unpack('<I', r)[0]\\n else:\\n f.seek(0, os.SEEK_END)\\n buflen = f.tell()\\n f.seek(4, os.SEEK_SET)\\n return f, buflen\",\n \"def _filehandle(self):\\n if not self._fh or self._is_closed():\\n filename = self._rotated_logfile or self.filename\\n if filename.endswith('.gz'):\\n self._fh = gzip.open(filename, 'r')\\n else:\\n self._fh = open(filename, \\\"r\\\", 1)\\n self._fh.seek(self._offset)\\n\\n return self._fh\",\n \"def extracted_file(fname: str):\\n new_fname = extract_gzip(fname)\\n gzipped = True\\n if new_fname is None:\\n new_fname = fname\\n gzipped = False\\n\\n try:\\n yield new_fname\\n finally:\\n if gzipped:\\n try:\\n bgzip_and_name(new_fname)\\n except Exception:\\n gzip_and_name(new_fname)\",\n \"def parse(path):\\n data = gzip.open(path, 'rb')\\n for byte_line in data:\\n yield eval(byte_line) # return generator instance to save memory\",\n \"def gzip_compress(data):\\n s = BytesIO()\\n g = gzip.GzipFile(fileobj=s, mode='wb')\\n g.write(data)\\n g.close()\\n return s.getvalue()\",\n \"def extract_gzip(fname: str, outfile: Optional[str] = None) -> Union[str, None]:\\n if not outfile:\\n outfile = fname[:-3]\\n\\n if fname.endswith(\\\".gz\\\"):\\n with gzip.open(fname, \\\"rb\\\") as f_in:\\n with open(outfile, \\\"wb\\\") as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n os.unlink(fname)\\n return outfile\",\n \"def DecompressionFile(src_fp, algorithm):\\n if algorithm == \\\"lzma\\\":\\n return lzma.open(src_fp, \\\"r\\\")\\n\\n if algorithm == \\\"snappy\\\":\\n return SnappyFile(src_fp, \\\"rb\\\")\\n\\n if algorithm:\\n raise InvalidConfigurationError(\\\"invalid compression algorithm: {!r}\\\".format(algorithm))\\n\\n return src_fp\",\n \"def _gz(filename):\\n \\n with open(filename, 'rb') as f:\\n return binascii.hexlify(f.read(2)) == b'1f8b'\",\n \"def get_create_handler(self):\\n return gzip.open(self.index_abspath, 'wt', compresslevel=self.compress_level)\",\n \"def _compress_string(content):\\n zbuf = StringIO()\\n zfile = GzipFile(mode='wb', compresslevel=6, fileobj=zbuf)\\n zfile.write(content)\\n zfile.close()\\n return zbuf.getvalue()\",\n \"def CompressionFile(dst_fp, algorithm, level=0):\\n if algorithm == \\\"lzma\\\":\\n return lzma.open(dst_fp, \\\"w\\\", preset=level)\\n\\n if algorithm == \\\"snappy\\\":\\n return SnappyFile(dst_fp, \\\"wb\\\")\\n\\n if algorithm:\\n raise InvalidConfigurationError(\\\"invalid compression algorithm: {!r}\\\".format(algorithm))\\n\\n return dst_fp\",\n \"def is_gz_file(f):\\n with open(f, \\\"rb\\\") as fin:\\n return binascii.hexlify(fin.read(2)) == b\\\"1f8b\\\"\",\n \"def _CreateTaskStorageMergeReader(self, path):\\n return gzip_file.GZIPStorageMergeReader(self, path)\",\n \"def openFileRd(in_file):\\n try:\\n # First see if this file is gzipped\\n try:\\n # Opening the file works even if it is not a gzip file\\n proto_in = gzip.open(in_file, \\\"rb\\\")\\n\\n # Force a check of the magic number by seeking in the\\n # file. If we do not do it here the error will occur when\\n # reading the first message.\\n proto_in.seek(1)\\n proto_in.seek(0)\\n except IOError:\\n proto_in = open(in_file, \\\"rb\\\")\\n except IOError:\\n print(\\\"Failed to open \\\", in_file, \\\" for reading\\\")\\n exit(-1)\\n return proto_in\",\n \"def open_file(path, config):\\n\\n return fopen(normalize_path(path, config))\",\n \"def open(self, filepath: str, mode=\\\"r\\\"):\\n _, ext = os.path.splitext(filepath)\\n\\n if not self.is_local:\\n f = self.open_zip_file(filepath, mode=mode)\\n return self.parse_file(f, ext, decode_bytes=True)\\n\\n # opening the file locally is easy\\n with open(filepath, mode=mode) as f:\\n return self.parse_file(f, ext)\",\n \"def bz2_file_bytes_reader(path):\\n return bz2.open(path, 'rb')\",\n \"def gunzip(data):\\n return gzip.GzipFile(fileobj=StringIO(data)).read()\",\n \"def file_open(path: str, mode: str):\\n if _path_on_gcp(path):\\n return tf.io.gfile.GFile(path, mode)\\n return open(path, mode)\",\n \"def gen_opener(filenames):\\n for filename in filenames:\\n if str(filename).endswith('.gz'):\\n f = gzip.open(filename, 'rt')\\n elif str(filename).endswith('.bz2'):\\n f = bz2.open(filename, 'rt')\\n else:\\n f = open(filename, 'rt')\\n yield f\\n f.close()\",\n \"def smart_open(filename, *args, **kwargs):\\n return LOADERS.get(os.path.splitext(filename)[1], open)(filename, *args, **kwargs)\",\n \"def read_filepath_or_buffer(f, open_flags=\\\"r\\\", compression=None):\\n f, handles, close = open_filepath_or_buffer(\\n f, open_flags=open_flags, compression=compression\\n )\\n try:\\n data = f.read()\\n finally:\\n if close:\\n try:\\n f.close()\\n except ValueError:\\n pass\\n return data\",\n \"def open_file(filename):\\n log.debug(\\\"filename: %s\\\\n\\\" % filename)\\n if filename:\\n return open(filename, \\\"w\\\")\\n else:\\n return tempfile.NamedTemporaryFile(mode=\\\"w+t\\\", delete=False)\",\n \"def de_gzip(data):\\n cmps = StringIO.StringIO(data)\\n gzipper = gzip.GzipFile(fileobj=cmps)\\n return gzipper.read()\",\n \"def de_gzip(data):\\n cmps = StringIO.StringIO(data)\\n gzipper = gzip.GzipFile(fileobj=cmps)\\n return gzipper.read()\",\n \"def ungz(filepath, compression='rb', deletesource=False):\\n\\n import gzip\\n\\n with gzip.open(filepath, compression) as f:\\n outF = open(filepath[:-3], 'wb')\\n outF.write(f.read())\\n f.close()\\n outF.close()\\n if deletesource:\\n try:\\n os.remove(filepath)\\n except:\\n raise Exception(\\\"Could not delete gz archive {0}.\\\".format(filepath))\\n\\n return filepath[:-3]\",\n \"def open_file(path):\\n return open(path, encoding='utf-8')\",\n \"def _open(self, file_path=None):\\n\\t\\tif file_path is None:\\n\\t\\t\\tfile_path = self.file_path\\n\\n\\t\\tif not os.path.exists(file_path):\\n\\t\\t\\traise ValueError('Could not find file: {}'.format(file_path))\\n\\n\\t\\ttry:\\n\\t\\t\\tf = open(file_path, encoding='utf-8', newline='')\\n\\t\\texcept OSError as err:\\n\\t\\t\\tself.log.error(str(err))\\n\\t\\t\\traise ValueError('Could not open file: {}'.format(file_path))\\n\\n\\t\\treturn f\",\n \"def compress_file(path):\\n\\n process = Popen([\\\"xz\\\", \\\"--compress\\\", \\\"--force\\\", \\\"--stdout\\\", path], stdout=PIPE)\\n return process.communicate()[0]\",\n \"def compress_file(path):\\n\\n process = Popen([\\\"xz\\\", \\\"--compress\\\", \\\"--force\\\", \\\"--stdout\\\", path], stdout=PIPE)\\n return process.communicate()[0]\",\n \"def is_gzip(fp):\\r\\n return open(fp, 'rb').read(2) == '\\\\x1f\\\\x8b'\",\n \"def open_file(file_path, mode='rb', encoding='iso-8859-1'):\\n try:\\n return open(file_path, mode=mode, encoding=encoding)\\n except IOError:\\n raise\",\n \"def test_compress_file_response(self):\\n with open(__file__, \\\"rb\\\") as file1:\\n\\n def get_response(req):\\n file_resp = FileResponse(file1)\\n file_resp[\\\"Content-Type\\\"] = \\\"text/html; charset=UTF-8\\\"\\n return file_resp\\n\\n r = GZipMiddleware(get_response)(self.req)\\n with open(__file__, \\\"rb\\\") as file2:\\n self.assertEqual(self.decompress(b\\\"\\\".join(r)), file2.read())\\n self.assertEqual(r.get(\\\"Content-Encoding\\\"), \\\"gzip\\\")\\n self.assertIsNot(r.file_to_stream, file1)\",\n \"def _gzipencode(content):\\n import gzip\\n out = BytesIO()\\n f = gzip.GzipFile(fileobj=out, mode='w', compresslevel=5)\\n f.write(content)\\n f.close()\\n return out.getvalue()\",\n \"def gzinflate(val):\\n return zlib.decompress(val)\",\n \"def open_file(file_name):\\n pass\",\n \"def open_zip(path, *args, **kwargs):\\r\\n with contextlib.closing(zipfile.ZipFile(path, *args, **kwargs)) as zip:\\r\\n yield zip\",\n \"def openInputFile(infile, *args):\\n if infile is None:\\n logging.info(\\\"Reading input from STDIN\\\")\\n return sys.stdin\\n\\n if isinstance(infile, str):\\n if urlRE.match(infile):\\n import urllib2\\n return urllib2.urlopen(infile)\\n if len(infile)>3 and infile[-3:]=='.gz':\\n import gzip\\n return gzip.GzipFile(infile,'rb')\\n elif len(infile)>4 and infile[-4:]=='.bz2':\\n import bz2\\n return bz2.BZ2File(infile,'rb')\\n else:\\n return open(infile,'rt')\\n else:\\n return infile\",\n \"def harmony_open_file(data):\\n\\n return Harmony(data)\",\n \"def open_files(filenames):\\n for filename in filenames:\\n if filename.endswith('.gz') or filename.endswith('.zip'):\\n yield gzip.open(filename, 'r')\\n else:\\n yield open(filename, 'rb')\",\n \"def open_file(filename):\\n print(\\\"filename: %s\\\\n\\\" % filename)\\n if filename:\\n return open(filename, \\\"w\\\")\\n else:\\n return tempfile.NamedTemporaryFile(delete=False)\",\n \"def isgzip(filename):\\n magic_number = b'\\\\x1f\\\\x8b\\\\x08'\\n with open(filename, 'rb') as f:\\n file_start = f.read(len(magic_number))\\n\\n if magic_number == file_start:\\n return True\\n return False\",\n \"def maybe_compress(filename, compress_minsize=config.COMPRESS_MINSIZE):\\n size = os.path.getsize(filename)\\n if size < compress_minsize:\\n return open(filename, 'rb'), False\\n\\n compressed_size, compressed_fobj = compress_file(filename)\\n if compressed_size >= size:\\n # Compressed file was larger\\n log.info(\\\"%s was larger when compressed; using uncompressed version\\\", filename)\\n return open(filename, 'rb'), False\\n\\n return compressed_fobj, True\",\n \"def open_archive(filename: str, mode: str = 'rb', use_extension: bool = True):\\n # extension_map maps magic_number to extension.\\n # Unfortunately, legacy LZMA container has no magic number\\n extension_map = {\\n b'BZh': 'bz2',\\n b'\\\\x1F\\\\x8B\\\\x08': 'gz',\\n b\\\"7z\\\\xBC\\\\xAF'\\\\x1C\\\": '7z',\\n b'\\\\xFD7zXZ\\\\x00': 'xz',\\n }\\n\\n if mode in ('r', 'a', 'w'):\\n mode += 'b'\\n elif mode not in ('rb', 'ab', 'wb'):\\n raise ValueError('Invalid mode: \\\"{}\\\"'.format(mode))\\n\\n if use_extension:\\n # if '.' not in filename, it'll be 1 character long but otherwise\\n # contain the period\\n extension = filename[filename.rfind('.'):][1:]\\n else:\\n if mode != 'rb':\\n raise ValueError('Magic number detection only when reading')\\n with open(filename, 'rb') as f:\\n magic_number = f.read(8)\\n\\n for pattern in extension_map:\\n if magic_number.startswith(pattern):\\n extension = extension_map[pattern]\\n break\\n else:\\n extension = ''\\n\\n if extension == 'bz2':\\n if isinstance(bz2, ImportError):\\n raise bz2\\n return bz2.BZ2File(filename, mode)\\n\\n if extension == 'gz':\\n return gzip.open(filename, mode)\\n\\n if extension == '7z':\\n if mode != 'rb':\\n raise NotImplementedError('It is not possible to write a 7z file.')\\n\\n try:\\n process = subprocess.Popen(['7za', 'e', '-bd', '-so', filename],\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE,\\n bufsize=65535)\\n except OSError:\\n raise ValueError('7za is not installed or cannot '\\n 'uncompress \\\"{}\\\"'.format(filename))\\n else:\\n stderr = process.stderr.read()\\n process.stderr.close()\\n if stderr != b'':\\n process.stdout.close()\\n raise OSError(\\n 'Unexpected STDERR output from 7za {}'.format(stderr))\\n return process.stdout\\n\\n if extension in ('lzma', 'xz'):\\n if isinstance(lzma, ImportError):\\n raise lzma\\n lzma_fmts = {'lzma': lzma.FORMAT_ALONE, 'xz': lzma.FORMAT_XZ}\\n return lzma.open(filename, mode, format=lzma_fmts[extension])\\n\\n # assume it's an uncompressed file\\n return open(filename, 'rb')\",\n \"def gzip_and_name(fname, gzip_file=True) -> str:\\n if gzip_file:\\n with open(fname, \\\"rb\\\") as f_in:\\n with gzip.open(fname + \\\".gz\\\", \\\"wb\\\") as f_out:\\n shutil.copyfileobj(f_in, f_out)\\n os.unlink(fname)\\n fname += \\\".gz\\\"\\n return fname\",\n \"def gzipFile(aFile):\\n f_in = open(aFile, \\\"rb\\\")\\n f_out = gzip.open(aFile + \\\".gz\\\", \\\"wb\\\")\\n f_out.writelines(f_in)\\n f_out.close()\\n f_in.close()\\n os.remove(aFile)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.82734615","0.8186003","0.8017077","0.78277725","0.7727428","0.7643111","0.73564893","0.73564893","0.732356","0.7103141","0.70543605","0.70016134","0.6944863","0.6920207","0.6873506","0.66928023","0.66770685","0.6631664","0.6631664","0.6600424","0.6580027","0.64895326","0.64764065","0.6457817","0.6422867","0.63363135","0.6301959","0.62391365","0.6215724","0.6170747","0.6168294","0.61651325","0.6122772","0.61218834","0.6105112","0.6081553","0.60781324","0.6050712","0.59981036","0.59923196","0.59869045","0.59801435","0.5970399","0.59482324","0.5924531","0.5889526","0.5889526","0.58843803","0.5865204","0.58557063","0.5854513","0.583779","0.5835696","0.57922953","0.57505673","0.5744459","0.5708418","0.56911665","0.56709003","0.5649803","0.5625126","0.5621904","0.5614155","0.5610826","0.56001073","0.55880475","0.55848694","0.5581659","0.5559243","0.5538499","0.5524832","0.5511394","0.54996043","0.54659486","0.54644036","0.54586357","0.5456168","0.5451879","0.5451879","0.5438422","0.54342157","0.5428476","0.54270613","0.54270613","0.5421817","0.54148805","0.54062164","0.5396873","0.53884345","0.5384678","0.53840923","0.5374806","0.53656834","0.5363291","0.53499335","0.5345347","0.5335043","0.5333797","0.533163","0.53296804"],"string":"[\n \"0.82734615\",\n \"0.8186003\",\n \"0.8017077\",\n \"0.78277725\",\n \"0.7727428\",\n \"0.7643111\",\n \"0.73564893\",\n \"0.73564893\",\n \"0.732356\",\n \"0.7103141\",\n \"0.70543605\",\n \"0.70016134\",\n \"0.6944863\",\n \"0.6920207\",\n \"0.6873506\",\n \"0.66928023\",\n \"0.66770685\",\n \"0.6631664\",\n \"0.6631664\",\n \"0.6600424\",\n \"0.6580027\",\n \"0.64895326\",\n \"0.64764065\",\n \"0.6457817\",\n \"0.6422867\",\n \"0.63363135\",\n \"0.6301959\",\n \"0.62391365\",\n \"0.6215724\",\n \"0.6170747\",\n \"0.6168294\",\n \"0.61651325\",\n \"0.6122772\",\n \"0.61218834\",\n \"0.6105112\",\n \"0.6081553\",\n \"0.60781324\",\n \"0.6050712\",\n \"0.59981036\",\n \"0.59923196\",\n \"0.59869045\",\n \"0.59801435\",\n \"0.5970399\",\n \"0.59482324\",\n \"0.5924531\",\n \"0.5889526\",\n \"0.5889526\",\n \"0.58843803\",\n \"0.5865204\",\n \"0.58557063\",\n \"0.5854513\",\n \"0.583779\",\n \"0.5835696\",\n \"0.57922953\",\n \"0.57505673\",\n \"0.5744459\",\n \"0.5708418\",\n \"0.56911665\",\n \"0.56709003\",\n \"0.5649803\",\n \"0.5625126\",\n \"0.5621904\",\n \"0.5614155\",\n \"0.5610826\",\n \"0.56001073\",\n \"0.55880475\",\n \"0.55848694\",\n \"0.5581659\",\n \"0.5559243\",\n \"0.5538499\",\n \"0.5524832\",\n \"0.5511394\",\n \"0.54996043\",\n \"0.54659486\",\n \"0.54644036\",\n \"0.54586357\",\n \"0.5456168\",\n \"0.5451879\",\n \"0.5451879\",\n \"0.5438422\",\n \"0.54342157\",\n \"0.5428476\",\n \"0.54270613\",\n \"0.54270613\",\n \"0.5421817\",\n \"0.54148805\",\n \"0.54062164\",\n \"0.5396873\",\n \"0.53884345\",\n \"0.5384678\",\n \"0.53840923\",\n \"0.5374806\",\n \"0.53656834\",\n \"0.5363291\",\n \"0.53499335\",\n \"0.5345347\",\n \"0.5335043\",\n \"0.5333797\",\n \"0.533163\",\n \"0.53296804\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.677487"},"document_rank":{"kind":"string","value":"15"}}},{"rowIdx":83190,"cells":{"query":{"kind":"string","value":"Returns the lower case file type of a file, and if it is (g)zipped"},"document":{"kind":"string","value":"def get_file_info(fname) -> Tuple[str, bool]:\n fname = fname.lower()\n is_compressed = False\n if fname.endswith((\".tgz\", \".tar.gz\")):\n is_compressed = True\n fname = re.sub(r\"\\.(tgz|tar\\.gz)$\", \"\", fname)\n elif fname.endswith(\".gz\"):\n is_compressed = True\n fname = fname[:-3]\n elif fname.endswith(\".zip\"):\n is_compressed = True\n fname = fname[:-4]\n split = os.path.splitext(fname)\n return split[1], is_compressed"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_file_type(cls, filename):\n with open(filename) as f:\n file_header = f.read(cls.MAX_FILE_HEADER_LEN)\n for magic, filetype in cls.MAGIC_DICT.items():\n if file_header.startswith(magic):\n return filetype\n return \"uncompressed\"","def is_zip(filepath):\n\treturn os.path.splitext(filepath)[1] == '.gz'","def file_type(filename, stream=False):\n magic_dict = {\"\\x1f\\x8b\\x08\": \"gz\",\n \"\\x42\\x5a\\x68\": \"bz2\",\n \"\\x50\\x4b\\x03\\x04\": \"zip\",\n b\"\\x50\\x4b\\x03\\x04\": \"zip\",\n \"PK\\x03\\x04\": \"zip\",\n b\"PK\\x03\\x04\": \"zip\",\n }\n\n max_len = max(len(x) for x in magic_dict)\n if not stream:\n with open(filename) as f:\n file_start = f.read(max_len)\n for magic, filetype in magic_dict.items():\n if file_start.startswith(magic):\n return filetype\n else:\n for magic, filetype in magic_dict.items():\n if filename[:len(magic)] == magic:\n return filetype\n\n return None","def get_file_type(filename):\n return filename[filename.rfind('.')+1:].lower()","def _iszip(self, filename):\n fname, ext = os.path.splitext(filename)\n return ext in _file_openers.keys()","def identify_compression(file_path: str) -> Optional[str]:\r\n sign_dict = {\r\n b\"\\x1f\\x8b\\x08\": \"gz\",\r\n b\"\\x42\\x5a\\x68\": \"bz2\",\r\n b\"\\x50\\x4b\\x03\\x04\": \"zip\",\r\n b\"\\x37\\x7a\\xbc\\xaf\\x27\\x1c\": \"7z\",\r\n b\"\\x75\\x73\\x74\\x61\\x72\": \"tar\",\r\n b\"\\x52\\x61\\x72\\x21\\x1a\\x07\\x00\": \"rar\",\r\n }\r\n\r\n max_len = max(len(x) for x in sign_dict)\r\n with open(file_path, \"rb\") as f:\r\n file_start = f.read(max_len)\r\n for magic, filetype in sign_dict.items():\r\n if file_start.startswith(magic):\r\n return filetype\r\n return None","def filename_type(filename):\n import re\n\n nii_re = re.compile(\".+(nii.gz)$|.+(nii)$\")\n npy_re = re.compile(\".+(npy)$|.+(npz)$\")\n\n\n if len(nii_re.findall(filename)):\n return 'nii'\n elif len(npy_re.findall(filename)):\n return 'npy'\n return None","def get_file_type(filename):\n try:\n with open(filename, 'rb') as file:\n magic = file.read(4)\n #print (magic)\n file.close()\n if magic == b'\\x7fELF':\n return \"elf\"\n elif int.from_bytes(magic[0:2], \"little\") == 0xc2:\n return \"coff\"\n else:\n return \"Unexpected file type\"\n \n except FileNotFoundError:\n return \"File <\"+filename+\"> not found.\"","def determine_file_type(input_file):\r\n file_info, error = subprocess.Popen([settings.FILE, input_file], stdout=subprocess.PIPE).communicate()\r\n\r\n file_type = file_info.decode(\"utf-8\").split()[1]\r\n\r\n if file_type == \"tcpdump\":\r\n return \"pcap\"\r\n elif file_type == \"pcap-ng\":\r\n return \"pcapng\"\r\n elif file_type == \"data\" and (b\"nfdump\" in file_info or b\"nfcapd\" in file_info):\r\n return \"nfdump\"\r\n else:\r\n raise UnsupportedFileTypeError(\"The file type \" + file_type + \" is not supported.\")","def _file_can_be_compressed(filename):\n content_type = ''\n with open(filename, 'rb') as f:\n content_type = _get_content_type(f)\n return content_type in TEXT_TYPES","def valid_package(filename=None, file_type=None):\n f = File(file_path=filename)\n if filename and not file_type:\n file_type = f.get_type()\n\n if not file_type:\n return None\n\n if f.get_size() > FILESIZE_LIMIT:\n return None\n\n if \"DLL\" in file_type and filename.endswith(\".cpl\"):\n return \"cpl\"\n elif \"DLL\" in file_type:\n return \"dll\"\n elif \"PE32\" in file_type or \"MS-DOS\" in file_type:\n return \"exe\"\n elif \"PDF\" in file_type:\n return \"pdf\"\n elif \"Rich Text Format\" in file_type or \"Microsoft Office Word\" in file_type or filename.endswith(\".docx\"):\n return \"doc\"\n elif \"Microsoft Office Excel\" in file_type or \"Microsoft Excel\" in file_type or filename.endswith(\".xlsx\"):\n return \"xls\"\n elif \"Zip archive\" in file_type:\n return \"zip\"\n elif \"HTML\" in file_type:\n return \"html\"\n else:\n return None","def is_zipfile(filename):\n\n import zipfile\n\n return zipfile.is_zipfile(filename)","def determine_file_type(self, name):\n for type_key, type_name, type_test in self.filetypes:\n if type_test(name):\n return type_key\n return self.filetypes[-1][0]","def detect_file_format(path):\n with open(path, \"rb\") as f:\n first_bytes = f.read(16)\n if first_bytes.startswith(b\"CRAM\"):\n return \"CRAM\"\n if first_bytes.startswith(b\"##fileformat=VCF\"):\n return \"VCF\"\n\n gzip_header = b\"\\037\\213\"\n if first_bytes.startswith(gzip_header):\n with gzip.GzipFile(path, \"rb\") as f:\n first_bytes = f.read(16)\n if first_bytes.startswith(b\"BAM\\1\"):\n return \"BAM\"\n elif first_bytes.startswith(b\"##fileformat=VCF\"):\n return \"VCF\"\n\n return None","def get_file_type(self):\n # Save original position\n orig = self.file.tell()\n line = self.file.readline()\n regex_squid = re.compile(settings.SQUID_LOG_RE)\n regex_common = re.compile(settings.APACHE_COMMON_LOG_RE)\n regex_combined = re.compile(settings.APACHE_COMBINED_LOG_RE)\n if regex_squid.match(line):\n # Move cursor back to original\n self.file.seek(orig)\n logging.info(\"File type SQUID detected\")\n return settings.SQUID\n elif regex_common.match(line):\n self.file.seek(orig)\n logging.info(\"File type APACHE COMMON detected\")\n return settings.APACHE_COMMON\n elif regex_combined.match(line):\n self.file.seek(orig)\n logging.info(\"File type APACHE COMBINED detected\")\n return settings.APACHE_COMBINED\n else:\n raise ValueError(\"Unrecognized file format.\\nWe currently support \"\n \"only Apache Web Server Log file and Squid Proxy \"\n \"Server Log file.\")","def get_file_type(filepath):\n\n ext = os.path.splitext(filepath)[1]\n if ext in ['.tif', '.tiff']:\n return \"GeoTIFF\"\n elif ext in ['.nc']:\n return \"NetCDF\"\n else:\n return None","def file_type(self):\n return self.__file_type","def get_file_format(filename):\n if os.path.splitext(filename)[1] == '.gz':\n file_format = os.path.splitext(os.path.splitext(filename)[0])[1]\n else:\n file_format = os.path.splitext(filename)[1]\n return file_format","def get_file_type(file_str):\n process_list = [\"file\", \"--mime-type\", file_str]\n p = subprocess.Popen(process_list, stdout=subprocess.PIPE)\n file_type, err = p.communicate()\n\n return file_type.decode(\"utf-8\")","def find_file_type(file_str):\n try:\n #p = subprocess.Popen(\n # 'file --mime-type %s' % file_str, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n #output, errors = p.communicate()\n #return file_str, output.split(\" \")[-1].strip(), errors\n mime = magic.from_file( file_str, mime=True )\n return file_str, mime, \"\"\n except Exception, e:\n return file_str, \"unknown\", repr( e )","def get_imagetype_from_filename(filename):\n if 'adni' in filename.lower():\n imagetype = 'adni'\n elif 'fmri' in filename.lower():\n imagetype = 'fmri'\n elif 'dti' in filename.lower():\n imagetype = 'dti'\n else:\n print('ERROR: Unknown input file ' + f)\n imagetype = None\n\n return imagetype","def filetype_of(path: Path) -> str:\n\n filetype = \"unsorted\"\n\n if path.suffix == \".json\":\n filetype = \"json\"\n\n elif path.suffix == \".txt\":\n if search(pattern=\"v[0-9][0-9]_[0-9]\", string=path.stem):\n filetype = \"onsets\"\n elif \"subject_info\" in path.stem:\n filetype = \"subject info\"\n\n elif path.suffix == \".nii\":\n if \"_t1_\" in path.stem:\n filetype = \"anat\"\n elif \"_lessvoids_\" in path.stem:\n filetype = \"func\"\n elif \"field_map\" in path.stem:\n filetype = \"fieldmap\"\n\n return filetype","def is_filetype(filename=None, search_str=None):\n if not search_str:\n return False\n results = puremagic.magic_file(filename)\n for result in results:\n if search_str.lower() in result.name.lower():\n return True\n return False","def filetype(file: str):\n suffix = file.split('.')[-1]\n if suffix == 'yml' or suffix == 'yaml':\n return 'yaml'\n elif suffix == 'json' or suffix == 'jsn':\n return 'json'\n else:\n raise Exception('Invalid filetype, file must be either json or yaml!')","def guess_type_from_content(file_obj):\n first_bytes = file_obj.read(2)\n if first_bytes == b\"PK\":\n filetype = \"xlsx\"\n else:\n content = file_obj.read()\n if b\"\\t\" in content:\n filetype = \"tsv\"\n else:\n filetype = \"csv\"\n return filetype","def file_type(self):\n return FileType(self.unpack_dword(0x1C))","def allowed_file_type(file_name):\n\treturn file_name.lower().endswith(ALLOWED_FILE_TYPES)","def file_test(vcf_file):\n if vcf_file.endswith(\".gz\"):\n return gzip.open, \"rt\"\n else:\n return open, \"rt\"","def isgzip(filename):\n magic_number = b'\\x1f\\x8b\\x08'\n with open(filename, 'rb') as f:\n file_start = f.read(len(magic_number))\n\n if magic_number == file_start:\n return True\n return False","def file_check(file):\n # unpacking the tuple\n file_name, file_extension = os.path.splitext(file)\n return file_extension","def file_type(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"file_type\")","def file_type(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"file_type\")","def GetFileType(filename):\n filetype = FileType.UNKNOWN\n\n # try filename\n try:\n with open(filename, \"r\") as f:\n try:\n # try reading as json\n json.load(f)\n filetype = FileType.JSON\n except ValueError:\n filetype = FileType.INVALID_JSON\n # not a valid json, get filesize and compare it with all possible sizes\n try:\n size = os.path.getsize(filename)\n except:\n filetype = FileType.UNKNOWN\n\n sizes = GetTemplateSizes()\n # size is one of a dmp file size\n if size in sizes:\n filetype = FileType.DMP\n elif (size - ((len(hex(BINARYFILE_MAGIC))-2)/2)) in sizes:\n # check if the binary file has the magic header\n with open(filename, \"rb\") as inputfile:\n inputbin = inputfile.read()\n if struct.unpack_from('<L', inputbin, 0)[0] == BINARYFILE_MAGIC:\n filetype = FileType.BIN\n else:\n filetype = FileType.INVALID_BIN\n pass\n\n except:\n filetype = FileType.FILE_NOT_FOUND\n pass\n\n return filetype","def is_file(self):\n return self.type == \"file\"","def file_type(location):\n try:\n return _detect(location, DETECT_TYPE)\n except:\n # TODO: log errors\n return ''","def determine_filetype(self):\n filetype = None\n # Loop through file formats\n for file_format in self._format_registry:\n validator = self._format_registry[file_format](\n self._synapse_client, self.center\n )\n try:\n filenames = [entity.name for entity in self.entitylist]\n filetype = validator.validateFilename(filenames)\n except AssertionError:\n continue\n # If valid filename, return file type.\n if filetype is not None:\n break\n return filetype","def getfiletype(self):\n d = magic.from_file(os.path.join(self.path,self.name))\n d = re.sub(', ',',',d)\n e = d.split(',')\n filetype = e[0]\n array = [False,False]\n if filetype == 'data':\n array = ['ARM','BIN']\n elif filetype == 'HIT archive data':\n array = ['MSP430', 'BIN']\n elif re.search('ELF',filetype):\n arch = e[1]\n if arch == 'ARM':\n array = ['ARM','ELF']\n elif arch == 'TI msp430':\n array = ['MSP430','ELF']\n else:\n pass\n else:\n pass\n\n return array","def getType(file):\n\n with open(file, \"r\") as result:\n return result.readline().strip()","def is_archive(afile):\n return file_ext(os.path.basename(afile)) in ARCHIVE_COMPRESS_FORMATS","def get_pkgtype(filename):\n\n extension = splitext(filename)[1][1:]\n if extension in ['rpm', 'deb', 'dsc']:\n return extension\n else:\n abort(\"Unsupported packagetype: {} for file: {}\".\n format(extension, filename))","def file_type(self):\n try:\n return self.get_driver().ShortName\n except AttributeError:\n return","def method_safe_filetype(self):\n file_type = self.get_filetype(self.file)\n\n if file_type:\n return file_type.replace('.', '')","def is_file(self):\n return self.tipo == 'file' or self.tipo is None","def GetContentType(filename):\r\n return mimetypes.guess_type(filename)[0] or 'application/octet-stream'","def get_file_type(file: Union[BytesIO, StringIO]) -> FileType:\n\n if isinstance(file, BytesIO):\n return FileType.SOUND\n content = file.getvalue()\n if (\n content.startswith('\"\"\"')\n or \"import\" in content\n or \"from \" in content\n or \"def \" in content\n or \"class \" in content\n or \"print(\" in content\n ):\n return FileType.PYTHON\n\n return FileType.CSV","def chk_for_gz(filenm):\n import os\n from os.path import expanduser\n filenm = expanduser(filenm)\n\n # File exist?\n if os.path.lexists(filenm):\n chk=True\n return filenm, chk\n\n # .gz already\n if filenm.find('.gz') > 0:\n chk=0\n return filenm, chk\n\n # Add .gz\n if os.path.lexists(filenm+'.gz'):\n chk=True\n return filenm+'.gz', chk\n else:\n chk=False\n return None, chk","def file_type(filepath):\n imexts = ['.png', '.bmp', '.jpg', 'jpeg']\n textexts = ['.csv', '.txt']\n if filepath.endswith('.hdf5') or filepath.endswith('.h5'):\n return 'hdf5'\n if any([filepath.endswith(ext) for ext in textexts]):\n return 'delim'\n if filepath.endswith('.grm.raw'):\n return 'grm.raw'\n if filepath.endswith('.npy'):\n return 'npy'\n if _is_bed(filepath):\n return 'bed'\n if _is_gen(filepath):\n return 'gen'\n if any([filepath.endswith(ext) for ext in imexts]):\n return 'image'\n return 'unknown'","def is_gz_file(f):\n with open(f, \"rb\") as fin:\n return binascii.hexlify(fin.read(2)) == b\"1f8b\"","def get_content_type(filename):\n return mimetypes.guess_type(filename)[0] or 'application/octet-stream'","def file_is_this_type(cls, path):\n if not os.path.exists(path):\n raise HelperError(2, \"No such file or directory: '{0}'\"\n .format(path))\n if helpers['isoinfo']:\n logger.debug(\"Using 'isoinfo' to check whether %s is an ISO\", path)\n try:\n helpers['isoinfo'].call(['-i', path, '-d'])\n return 100\n except HelperError:\n # Not an ISO\n return 0\n\n # else, try to detect ISO files by file magic number\n with open(path, 'rb') as fileobj:\n for offset in (0x8001, 0x8801, 0x9001):\n fileobj.seek(offset)\n magic = fileobj.read(5).decode('ascii', 'ignore')\n if magic == \"CD001\":\n return 100\n return 0","def infer_ftype(fname):\n if fname.endswith(\".fasta\") or fname.endswith(\".fa\"):\n ftype = \"FASTA\"\n elif fname.endswith(\".txt\"):\n ftype = \"ACCESSIONS\"\n elif fname.endswith(\".json\"):\n ftype = \"JSON\"\n else:\n logger.error(\"Unknown file type for file: {}\".format(fname))\n return ftype","def GetContentType(filename):\n return mimetypes.guess_type(filename)[0] or 'application/octet-stream'","def gettype(self):\n return self.filetype","def _is_archive(local_path: str) -> bool:\n archive_mimetypes = [\n \"application/zip\",\n \"application/x-tar\",\n \"application/x-gzip\",\n \"application/x-bzip2\",\n \"application/x-7z-compressed\",\n \"application/x-rar-compressed\",\n \"application/x-xz\",\n \"application/x-lzip\",\n \"application/x-lzma\",\n \"application/x-lzop\",\n \"application/x-bzip\",\n \"application/x-bzip2\",\n \"application/x-compress\",\n \"application/x-compressed\",\n ]\n\n return mimetypes.guess_type(local_path)[0] in archive_mimetypes","def _get_file_txt (zipname) :\n file = os.path.split (zipname) [1]\n file = file.replace (\".zip\", \".txt\")\n file = file.replace (\".ZIP\", \".txt\")\n file = file.replace (\".gz\", \".txt\")\n file = file.replace (\".GZ\", \".txt\")\n return file","def get_result_file_type(file):\n if file.endswith('.res'):\n file_type = 'results'\n print('\\n--------------\\nResults file detected!\\n--------------')\n elif file.endswith('.req'):\n file_type = 'request'\n print('\\n--------------\\nRequst file detected!\\n--------------')\n else:\n raise AviewError('Files must be .res or .req files.')\n return file_type","def get_s3_file_type(file_id):\n file_object = S3_CLIENT.get_object(Bucket=runtime_context.BUCKET_NAME,\n Key=file_id)\n ct = file_object.get('ContentType')\n return ct.split(';')[0] if ct else 'application/octet-stream'","def getFileType(filename):\n\n fname, fext = os.path.splitext(filename)\n dbf = fname + '.dbf'\n ftype = 'unknown'\n if os.path.isfile(dbf):\n ftype = 'shapefile'\n else:\n try:\n fdict = GMTGrid.getFileGeoDict(filename)\n ftype = 'grid'\n except Exception as error:\n try:\n fdict = GDALGrid.getFileGeoDict(filename)\n ftype = 'grid'\n except:\n pass\n return ftype","def is_archive_ext(filepath):\n file_extension = os.path.splitext(filepath)[1].lower()\n if file_extension in get_archive_extensions():\n return True\n else:\n return False","def get_file_ext(self):\n return self.archive.url.split('.')[-1].lower()","def checkFormat(vcfname):\n if vcfname == '-':\n return 'vcf' #may want to note its a stream\n typ = checkIfGzip(vcfname)\n if typ != 'nozip':\n return typ\n f = open(vcfname)\n l = f.readline()\n f.close()\n VCF_TAG='##fileformat=VCF'\n if l[:len(VCF_TAG)] == VCF_TAG:\n return 'vcf'\n return 'other'","def mime_type(filename):\n mtype, encoding = guess_type(filename, False)\n if encoding is None:\n return mtype or \"application/octet-stream\"\n elif encoding == \"gzip\":\n # application/gzip is defined by RFC 6713\n return \"application/gzip\"\n # Note that there is a \"+gzip\" MIME structured syntax suffix specified\n # in an RFC draft that may one day mean the correct code is:\n # return mtype + '+gzip'\n else:\n return \"application/x-\" + encoding","def get_file_type(file_path):\n ext = pathlib.Path(file_path).suffix\n return \"video\" if ext == \".avi\" else \"image\"","def are_files_gzipped(raw_files):\n files_are_gzipped = None\n for file_name in raw_files:\n if re.search(r\"\\.gz$\", file_name) is not None:\n if files_are_gzipped is False:\n raise Exception(\n \"It seems one file is compressed and the \"\n \"other is \"\n \"not:\\n{}\".format(\"\\n\".join(raw_files))\n )\n files_are_gzipped = True\n else:\n if files_are_gzipped:\n raise Exception(\n \"It seems one file is compressed and the \"\n \"other is \"\n \"not:\\n{}\".format(\"\\n\".join(raw_files))\n )\n files_are_gzipped = False\n return files_are_gzipped","def test_find_file_zipped_allow(self):\n\n this_file_name = satellite_io.find_file(\n top_directory_name=TOP_DIRECTORY_NAME,\n valid_date_string=VALID_DATE_STRING,\n prefer_zipped=True, allow_other_format=True,\n raise_error_if_missing=False\n )\n\n self.assertTrue(this_file_name == FILE_NAME_UNZIPPED)","def get_type(self):\n _, ext = zip_path.splitext(self.get_name())\n ext = ext.lower()\n\n for uid, ext_list in six.iteritems(ebooklib.EXTENSIONS):\n if ext in ext_list:\n return uid\n\n return ebooklib.ITEM_UNKNOWN","def isZipArchive(filepath):\r\n return zipfile.is_zipfile(filepath)","def getTypeFromFileName(filename):\n ext = os.path.splitext(filename)[1]\n fileType = fileExtensionMap.get(ext,None)\n if fileType is not None:\n return fileType\n else:\n logging.warning(\"\"\"Cannot guess type of %s!\n\nThe input file does not have a recognized extension:\n%s\n\nYou must manually set the file type with '-T TYPE' where TYPE is in:\n%s\nOR set the record separator pattern with '-p PATTERN' where PATTERN is a regular expression. E.G. '^>\" for fasta, or '^LOCUS' for gbk.\n\"\"\" % (filename, list(fileExtensionMap.keys()), list(fileExtensionMap.keys())))\n sys.exit(65)","def _IsFile(self, file_message):\n message_type = file_message.message_type\n return (message_type == FileMessage.FILE_DOWNLOAD or\n message_type == FileMessage.FILE_UPLOAD or\n message_type == FileMessage.FILE_CLOUD_COPY or\n message_type == FileMessage.FILE_DAISY_COPY or\n message_type == FileMessage.FILE_LOCAL_COPY or\n message_type == FileMessage.FILE_REWRITE or\n message_type == FileMessage.FILE_HASH)","def get_file_status(plan, shape=False):\n basename = DistrictFile.get_file_name(plan, shape)\n if os.path.exists(basename + '.zip'):\n return 'done'\n if os.path.exists(basename + '_pending.zip'):\n return 'pending'\n else:\n return 'none'","def check_media_file_type(media_file_class):\n if media_file_class == 'AudioFile':\n media_file_type = 'Audio file'\n elif media_file_class == 'VideoFile':\n media_file_type = 'Video file'\n elif media_file_class == 'DocumentFile':\n media_file_type = 'Document file'\n elif media_file_class == 'ImageFile':\n media_file_type = 'Image file'\n\n return media_file_type","def get_output_file_type(self):\n file_name = '.' + self.template_file_name.split('.')[-2]\n return file_name","def get_type(filepath):\n if os.path.isdir(filepath):\n return MIME_DIRECTORY\n\n if not mimetypes.inited:\n mimetypes.init()\n\n # .gz does not return archive type as expected\n if filepath.endswith('.gz'):\n filepath += '.tgz'\n\n try:\n mime_type = mimetypes.types_map[os.path.splitext(filepath)[-1].lower()]\n except KeyError:\n mime_type = ''\n\n if mime_type.startswith('image'):\n return MIME_IMAGE_GENERIC\n\n elif any(tag in mime_type for tag in ('x-gtar', 'x-tar', 'zip', 'rar', 'x-7z')):\n return MIME_ARCHIVE\n\n elif 'audio' in mime_type:\n return MIME_AUDIO\n\n elif any(tag in mime_type for tag in ('iso9660-image', 'diskimage')):\n return MIME_DISK\n\n elif 'font' in mime_type:\n return MIME_FONT\n\n elif any(tag in mime_type for tag in ('msword', 'wordprocessingml.document', 'opendocument.text')):\n return MIME_DOC\n\n elif any(tag in mime_type for tag in ('powerpoint', 'presentation')):\n return MIME_PRESENT\n\n elif any(tag in mime_type for tag in ('spreadsheet', 'excel', 'text/csv')):\n return MIME_SPREADSHEET\n\n elif 'pdf' in mime_type:\n return MIME_PDF\n\n elif 'python' in mime_type:\n return MIME_PYTHON\n\n elif 'x-sh' in mime_type:\n return MIME_SHELL\n\n elif 'video' in mime_type:\n return MIME_VIDEO\n\n elif 'text' in mime_type:\n return MIME_PLAINTEXT\n\n return MIME_BINARY # Generic file","def get_type(ext):\n if ext.lower() in Asset.SUPPORTED_IMAGE_EXT['in']:\n return 'image'\n return 'file'","def is_file_type(file_path, file_type):\n\n if not file_exists(file_path):\n return False\n\n if file_path.endswith(file_type):\n return True\n\n return False","def check_file_type(fname):\n ext = path.splitext(fname)[1]\n return ext in allowed_extensions","def getFiletypeFromDictionary(gpfn, surl_filetype_dictionary):\n\n filetype = 'UNKNOWN'\n try:\n filetype = surl_filetype_dictionary[gpfn]\n except Exception, e:\n tolog(\"!!WARNING!!2240!! Filetype not found for surl=%s: %s\" % (gpfn, e))\n\n return filetype","def s3_input_file_type(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"s3_input_file_type\")","def selection(self):\n self.file.seek(0)\n start = self.file.readline().rstrip().upper()\n if start[0] == \">\":\n self.file_type = \"fasta\"\n elif start[0:1] == \"ID\":\n self.file_type = \"embl_gcg\"\n elif start[0:5] == \"LOCUS\":\n self.file_type = \"genbank\"\n elif start[0] == \";\":\n self.file_type = \"ig\"\n elif not re.search('[^GATCN]', start):\n self.file_type = \"plain\"\n else:\n self.file_type = None\n return self.file_type","def getWebImgType_file(filename):\n data = open(filename,'rb').read(11)\n\n # JPG\n if data[:4] == b'\\xff\\xd8\\xff\\xe0' and data[6:11] == b'JFIF\\x00':\n return 'JPEG'\n # PNG\n if data[:6] == b'\\x89PNG\\r\\n':\n return 'PNG'\n # GIF\n if data[:3] == b'\\x47\\x49\\x46\\x38':\n return 'GIF'\n\n # Format not recognised\n return False","def get_file_type(file_type: str, file_extension: str):\n\n if file_type is None and file_extension is None:\n return None\n\n if file_type is None:\n if len(file_extension) > 0 and file_extension[0] == '.':\n file_extension = file_extension[1:len(file_extension)]\n\n return FileTypes(file_extension)\n\n return FileTypes(file_type)","def get_mime_type(file):\n initial_pos = file.tell()\n file.seek(0)\n mime_type = magic.from_buffer(file.read(2048), mime=True)\n file.seek(initial_pos)\n return mime_type","def test_find_file_zipped_no_allow(self):\n\n this_file_name = satellite_io.find_file(\n top_directory_name=TOP_DIRECTORY_NAME,\n valid_date_string=VALID_DATE_STRING,\n prefer_zipped=True, allow_other_format=False,\n raise_error_if_missing=False\n )\n\n self.assertTrue(this_file_name == FILE_NAME_ZIPPED)","def getMimeType(pathName):\n pnl = pathName.lower()\n for ext, mt in MIME_TYPES:\n ext2 = \".\" + ext\n if pnl[-len(ext2):]==ext2:\n return mt\n #//for\n return \"\"","def detect_content_type(self, path=None, payload=None):\n\n f = file_path(path, payload)\n switches = [\"-d\", f]\n result = self._command_template(switches).lower()\n return result, path, f","def getNametype(self, path):\n if os.path.isdir(path):\n return 'dir'\n elif os.path.isfile(path):\n return 'file'\n else: return None","def ComputeFileTypes(self):\n for rel_path, file_data in self._files.iteritems():\n if 'ftype' in file_data:\n continue\n ftype = self._file_type_decoder.GetType(rel_path)\n if ftype:\n file_data['ftype'] = ftype","def file_format(x):\n return FILE_EXT_FORMAT_MAP.get(genomic_file_ext(x))","def _accept_for_flag (self, filename):\n\t\troot, ext = os.path.splitext(filename)\n\t\tif not ext:\n\t\t\treturn 1\n\t\telse:\n\t\t\tbinary_extensions = ['.jpg', '.gif', '.png', '.jar' ]\n\t\t\treturn ext not in ['.bak', '.off','.old', '.works', '.clean', '.obs', '.log', '.db'] + binary_extensions","def test_get_file_type(self):\n file_list = {'events': 'monol_testA_nustar_fpma_ev',\n 'lc': 'monol_testA_E3-50_lc',\n 'pds': 'monol_testA_E3-50_pds',\n 'gti': 'monol_testA_E3-50_rebin4_gti',\n 'cpds': 'monol_test_E3-50_cpds'}\n for realtype in file_list.keys():\n fname = os.path.join(self.datadir,\n file_list[realtype] + HEN_FILE_EXTENSION)\n ftype, _ = hen.io.get_file_type(fname)\n assert ftype == realtype, \"File types do not match\"","def getFileCategory(fileName):\n extension = __getExt(fileName)\n if extension in (_7z, \"7zip\", ace, air, apk, \"appxbundle\", \"arc\", arj, \"asec\", \"bar\", bz2, \"bzip\", cab, \"cso\", deb, \"dlc\", dmg, gz, \"gzip\", hqx, \"inv\", \"ipa\", iso, \"isz\", jar, \"msu\", \"nbh\", pak, rar, rpm, sis, sisx, sit, \"sitd\", sitx, tar, targz, tgz, \"webarchive\", xap, z, zip):\n return FileCategory.Archive\n\n if extension in (_3ga, aac, aiff, amr, ape, \"arf\", asf, asx, \"cda\", \"dvf\", flac, \"gp4\", \"gp5\", gpx, \"logic\", m4a, m4b, \"m4p\", midi, mp3, ogg, \"pcm\", \"rec\", snd, \"sng\", \"uax\", wav, wma, wpl, \"zab\"):\n return FileCategory.Audio\n\n if extension in (_as, asm, asp, \"aspx\", bat, c, \"cp\", cpp, cs, css, \"gradle\", htm, \"inc\", jad, java, js, json, \"jsp\", \"lib\", m, \"matlab\", ml, o, perl, php, pl, \"ps1\", py, rb, \"rc\", rss, \"scpt\", sh, sql, src, \"swift\", \"vb\", \"vbs\", \"ws\", \"xaml\", \"xcodeproj\", xml, xsd, xsl, xslt, yml):\n return FileCategory.Code\n\n if extension in (abw, \"aww\", azw, \"azw3\", \"azw4\", cbr, cbz, chm, \"cnt\", \"dbx\", djvu, doc, docm, docx, dot, dotm, dotx, epub, fb2, \"iba\", \"ibooks\", \"ind\", \"indd\", \"lit\", mht, mobi, mpp, odf, odt, ott, \"pages\", pmd, \"prn\", \"prproj\", ps, pub, \"pwi\", rep, rtf, sdd, sdw, \"shs\", \"snp\", sxw, tpl, vsd, \"wlmp\", wpd, wps, wri):\n return FileCategory.Document\n\n if extension in (bmp, cpt, dds, dib, dng, \"dt2\", emf, gif, ico, \"icon\", icns, jpeg, jpg, pcx, pic, png, psd, \"psdx\", raw, tga, \"thm\", tif, tiff, wbmp, \"wdp\", webp):\n return FileCategory.Image\n\n if extension in (oxps, pdf, xps):\n return FileCategory.PDF\n\n if extension in (key, \"keynote\", pot, potx, pps, ppsx, ppt, pptm, pptx):\n return FileCategory.Presentation\n\n if extension in (ods, \"numbers\", sdc, xls, xlsx, xlsb):\n return FileCategory.Spreadsheet\n\n if extension in (\"alx\", application, csv, \"eng\", html, log, \"lrc\", \"lst\", nfo, opml, \"plist\", reg, srt, sub, \"tbl\", text, txt):\n return FileCategory.Text\n\n if extension in (\"264\", _3g2, _3gp, avi, \"bik\", \"dash\", \"dat\", \"dvr\", flv, h264, m2t, m2ts, m4v, mkv, mod, mov, mp4, mpeg, mpg, \"mswmm\", mts, ogv, rmvb, swf, \"tod\", \"tp\", ts, vob, webm, wmv):\n return FileCategory.Video\n\n return FileCategory.Binary","def unreal_attachment_type(unreal_file):\n if unreal_file.type == \"minidump\":\n return MINIDUMP_ATTACHMENT_TYPE","def guess_content_type(filename):\n return mimetypes.guess_type(filename)[0]","def getFile(self):\n #try to redetect the filetype\n vim.command(\"filetype detect\")\n #return the filetype\n filetype = vim.eval(\"&ft\")\n #filetype = vim.command(\"&ft\")\n if filetype:\n for file in self.template_files:\n if filetype.lower() in file.lower():\n self.hasTemplate = True\n return open(self.template_folder + \"/\" + file, 'r')\n return None","def layer_type(filename):\n extension = os.path.splitext(filename)[1]\n if extension.lower() in ['.shp']:\n return FeatureType.resource_type\n elif extension.lower() in ['.tif', '.tiff', '.geotiff', '.geotif']:\n return Coverage.resource_type\n else:\n msg = ('Saving of extension [%s] is not implemented' % extension)\n raise Exception(msg)","def file_type(self):\n ftype = str(self.FileType)\n choices = None\n if self.FileType == 'Driver':\n choices = {\n 0x0: 'Unknown',\n 0x1: 'Printer',\n 0x2: 'Keyboard',\n 0x3: 'Language',\n 0x4: 'Display',\n 0x5: 'Mouse',\n 0x6: 'Network',\n 0x7: 'System',\n 0x8: 'Installable',\n 0x9: 'Sound',\n 0xA: 'Comms',\n 0xB: 'Input Method',\n 0xC: 'Versioned Printer',\n }\n elif self.FileType == 'Font':\n choices = {\n 0x1: 'Raster',\n 0x2: 'Vector',\n 0x3: 'Truetype',\n }\n if choices != None:\n subtype = obj.Object('Enumeration', 0x28, vm = self.obj_vm, parent = self, choices = choices)\n ftype += \" (\" + str(subtype) + \")\"\n\n return ftype","def get_ctype(f):\n return mimetypes.guess_type(f)[0]","def splitext_zip(fname):\n base_fname, ext = splitext(fname)\n if ext == '.gz' or ext == '.zip':\n base_fname, ext2 = splitext(base_fname)\n ext = ''.join([ext2, ext])\n return base_fname, ext","def is_accept_type(file_name):\n bare_name, file_extension = os.path.splitext(file_name)\n for ext in ACCEPTED_FILES:\n if file_extension.lower() == ext:\n return True\n return False","def get_filetype(filemode):\n mode_funcs = [\n (stat.S_ISREG, \"-\"),\n (stat.S_ISBLK, \"b\"),\n (stat.S_ISCHR, \"c\"),\n (stat.S_ISDIR, \"d\"),\n (stat.S_ISFIFO, \"p\"),\n (stat.S_ISLNK, \"l\"),\n (stat.S_ISSOCK, \"s\"),\n ]\n for pred, val in mode_funcs:\n if pred(filemode):\n return val\n return \"?\""],"string":"[\n \"def get_file_type(cls, filename):\\n with open(filename) as f:\\n file_header = f.read(cls.MAX_FILE_HEADER_LEN)\\n for magic, filetype in cls.MAGIC_DICT.items():\\n if file_header.startswith(magic):\\n return filetype\\n return \\\"uncompressed\\\"\",\n \"def is_zip(filepath):\\n\\treturn os.path.splitext(filepath)[1] == '.gz'\",\n \"def file_type(filename, stream=False):\\n magic_dict = {\\\"\\\\x1f\\\\x8b\\\\x08\\\": \\\"gz\\\",\\n \\\"\\\\x42\\\\x5a\\\\x68\\\": \\\"bz2\\\",\\n \\\"\\\\x50\\\\x4b\\\\x03\\\\x04\\\": \\\"zip\\\",\\n b\\\"\\\\x50\\\\x4b\\\\x03\\\\x04\\\": \\\"zip\\\",\\n \\\"PK\\\\x03\\\\x04\\\": \\\"zip\\\",\\n b\\\"PK\\\\x03\\\\x04\\\": \\\"zip\\\",\\n }\\n\\n max_len = max(len(x) for x in magic_dict)\\n if not stream:\\n with open(filename) as f:\\n file_start = f.read(max_len)\\n for magic, filetype in magic_dict.items():\\n if file_start.startswith(magic):\\n return filetype\\n else:\\n for magic, filetype in magic_dict.items():\\n if filename[:len(magic)] == magic:\\n return filetype\\n\\n return None\",\n \"def get_file_type(filename):\\n return filename[filename.rfind('.')+1:].lower()\",\n \"def _iszip(self, filename):\\n fname, ext = os.path.splitext(filename)\\n return ext in _file_openers.keys()\",\n \"def identify_compression(file_path: str) -> Optional[str]:\\r\\n sign_dict = {\\r\\n b\\\"\\\\x1f\\\\x8b\\\\x08\\\": \\\"gz\\\",\\r\\n b\\\"\\\\x42\\\\x5a\\\\x68\\\": \\\"bz2\\\",\\r\\n b\\\"\\\\x50\\\\x4b\\\\x03\\\\x04\\\": \\\"zip\\\",\\r\\n b\\\"\\\\x37\\\\x7a\\\\xbc\\\\xaf\\\\x27\\\\x1c\\\": \\\"7z\\\",\\r\\n b\\\"\\\\x75\\\\x73\\\\x74\\\\x61\\\\x72\\\": \\\"tar\\\",\\r\\n b\\\"\\\\x52\\\\x61\\\\x72\\\\x21\\\\x1a\\\\x07\\\\x00\\\": \\\"rar\\\",\\r\\n }\\r\\n\\r\\n max_len = max(len(x) for x in sign_dict)\\r\\n with open(file_path, \\\"rb\\\") as f:\\r\\n file_start = f.read(max_len)\\r\\n for magic, filetype in sign_dict.items():\\r\\n if file_start.startswith(magic):\\r\\n return filetype\\r\\n return None\",\n \"def filename_type(filename):\\n import re\\n\\n nii_re = re.compile(\\\".+(nii.gz)$|.+(nii)$\\\")\\n npy_re = re.compile(\\\".+(npy)$|.+(npz)$\\\")\\n\\n\\n if len(nii_re.findall(filename)):\\n return 'nii'\\n elif len(npy_re.findall(filename)):\\n return 'npy'\\n return None\",\n \"def get_file_type(filename):\\n try:\\n with open(filename, 'rb') as file:\\n magic = file.read(4)\\n #print (magic)\\n file.close()\\n if magic == b'\\\\x7fELF':\\n return \\\"elf\\\"\\n elif int.from_bytes(magic[0:2], \\\"little\\\") == 0xc2:\\n return \\\"coff\\\"\\n else:\\n return \\\"Unexpected file type\\\"\\n \\n except FileNotFoundError:\\n return \\\"File <\\\"+filename+\\\"> not found.\\\"\",\n \"def determine_file_type(input_file):\\r\\n file_info, error = subprocess.Popen([settings.FILE, input_file], stdout=subprocess.PIPE).communicate()\\r\\n\\r\\n file_type = file_info.decode(\\\"utf-8\\\").split()[1]\\r\\n\\r\\n if file_type == \\\"tcpdump\\\":\\r\\n return \\\"pcap\\\"\\r\\n elif file_type == \\\"pcap-ng\\\":\\r\\n return \\\"pcapng\\\"\\r\\n elif file_type == \\\"data\\\" and (b\\\"nfdump\\\" in file_info or b\\\"nfcapd\\\" in file_info):\\r\\n return \\\"nfdump\\\"\\r\\n else:\\r\\n raise UnsupportedFileTypeError(\\\"The file type \\\" + file_type + \\\" is not supported.\\\")\",\n \"def _file_can_be_compressed(filename):\\n content_type = ''\\n with open(filename, 'rb') as f:\\n content_type = _get_content_type(f)\\n return content_type in TEXT_TYPES\",\n \"def valid_package(filename=None, file_type=None):\\n f = File(file_path=filename)\\n if filename and not file_type:\\n file_type = f.get_type()\\n\\n if not file_type:\\n return None\\n\\n if f.get_size() > FILESIZE_LIMIT:\\n return None\\n\\n if \\\"DLL\\\" in file_type and filename.endswith(\\\".cpl\\\"):\\n return \\\"cpl\\\"\\n elif \\\"DLL\\\" in file_type:\\n return \\\"dll\\\"\\n elif \\\"PE32\\\" in file_type or \\\"MS-DOS\\\" in file_type:\\n return \\\"exe\\\"\\n elif \\\"PDF\\\" in file_type:\\n return \\\"pdf\\\"\\n elif \\\"Rich Text Format\\\" in file_type or \\\"Microsoft Office Word\\\" in file_type or filename.endswith(\\\".docx\\\"):\\n return \\\"doc\\\"\\n elif \\\"Microsoft Office Excel\\\" in file_type or \\\"Microsoft Excel\\\" in file_type or filename.endswith(\\\".xlsx\\\"):\\n return \\\"xls\\\"\\n elif \\\"Zip archive\\\" in file_type:\\n return \\\"zip\\\"\\n elif \\\"HTML\\\" in file_type:\\n return \\\"html\\\"\\n else:\\n return None\",\n \"def is_zipfile(filename):\\n\\n import zipfile\\n\\n return zipfile.is_zipfile(filename)\",\n \"def determine_file_type(self, name):\\n for type_key, type_name, type_test in self.filetypes:\\n if type_test(name):\\n return type_key\\n return self.filetypes[-1][0]\",\n \"def detect_file_format(path):\\n with open(path, \\\"rb\\\") as f:\\n first_bytes = f.read(16)\\n if first_bytes.startswith(b\\\"CRAM\\\"):\\n return \\\"CRAM\\\"\\n if first_bytes.startswith(b\\\"##fileformat=VCF\\\"):\\n return \\\"VCF\\\"\\n\\n gzip_header = b\\\"\\\\037\\\\213\\\"\\n if first_bytes.startswith(gzip_header):\\n with gzip.GzipFile(path, \\\"rb\\\") as f:\\n first_bytes = f.read(16)\\n if first_bytes.startswith(b\\\"BAM\\\\1\\\"):\\n return \\\"BAM\\\"\\n elif first_bytes.startswith(b\\\"##fileformat=VCF\\\"):\\n return \\\"VCF\\\"\\n\\n return None\",\n \"def get_file_type(self):\\n # Save original position\\n orig = self.file.tell()\\n line = self.file.readline()\\n regex_squid = re.compile(settings.SQUID_LOG_RE)\\n regex_common = re.compile(settings.APACHE_COMMON_LOG_RE)\\n regex_combined = re.compile(settings.APACHE_COMBINED_LOG_RE)\\n if regex_squid.match(line):\\n # Move cursor back to original\\n self.file.seek(orig)\\n logging.info(\\\"File type SQUID detected\\\")\\n return settings.SQUID\\n elif regex_common.match(line):\\n self.file.seek(orig)\\n logging.info(\\\"File type APACHE COMMON detected\\\")\\n return settings.APACHE_COMMON\\n elif regex_combined.match(line):\\n self.file.seek(orig)\\n logging.info(\\\"File type APACHE COMBINED detected\\\")\\n return settings.APACHE_COMBINED\\n else:\\n raise ValueError(\\\"Unrecognized file format.\\\\nWe currently support \\\"\\n \\\"only Apache Web Server Log file and Squid Proxy \\\"\\n \\\"Server Log file.\\\")\",\n \"def get_file_type(filepath):\\n\\n ext = os.path.splitext(filepath)[1]\\n if ext in ['.tif', '.tiff']:\\n return \\\"GeoTIFF\\\"\\n elif ext in ['.nc']:\\n return \\\"NetCDF\\\"\\n else:\\n return None\",\n \"def file_type(self):\\n return self.__file_type\",\n \"def get_file_format(filename):\\n if os.path.splitext(filename)[1] == '.gz':\\n file_format = os.path.splitext(os.path.splitext(filename)[0])[1]\\n else:\\n file_format = os.path.splitext(filename)[1]\\n return file_format\",\n \"def get_file_type(file_str):\\n process_list = [\\\"file\\\", \\\"--mime-type\\\", file_str]\\n p = subprocess.Popen(process_list, stdout=subprocess.PIPE)\\n file_type, err = p.communicate()\\n\\n return file_type.decode(\\\"utf-8\\\")\",\n \"def find_file_type(file_str):\\n try:\\n #p = subprocess.Popen(\\n # 'file --mime-type %s' % file_str, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n #output, errors = p.communicate()\\n #return file_str, output.split(\\\" \\\")[-1].strip(), errors\\n mime = magic.from_file( file_str, mime=True )\\n return file_str, mime, \\\"\\\"\\n except Exception, e:\\n return file_str, \\\"unknown\\\", repr( e )\",\n \"def get_imagetype_from_filename(filename):\\n if 'adni' in filename.lower():\\n imagetype = 'adni'\\n elif 'fmri' in filename.lower():\\n imagetype = 'fmri'\\n elif 'dti' in filename.lower():\\n imagetype = 'dti'\\n else:\\n print('ERROR: Unknown input file ' + f)\\n imagetype = None\\n\\n return imagetype\",\n \"def filetype_of(path: Path) -> str:\\n\\n filetype = \\\"unsorted\\\"\\n\\n if path.suffix == \\\".json\\\":\\n filetype = \\\"json\\\"\\n\\n elif path.suffix == \\\".txt\\\":\\n if search(pattern=\\\"v[0-9][0-9]_[0-9]\\\", string=path.stem):\\n filetype = \\\"onsets\\\"\\n elif \\\"subject_info\\\" in path.stem:\\n filetype = \\\"subject info\\\"\\n\\n elif path.suffix == \\\".nii\\\":\\n if \\\"_t1_\\\" in path.stem:\\n filetype = \\\"anat\\\"\\n elif \\\"_lessvoids_\\\" in path.stem:\\n filetype = \\\"func\\\"\\n elif \\\"field_map\\\" in path.stem:\\n filetype = \\\"fieldmap\\\"\\n\\n return filetype\",\n \"def is_filetype(filename=None, search_str=None):\\n if not search_str:\\n return False\\n results = puremagic.magic_file(filename)\\n for result in results:\\n if search_str.lower() in result.name.lower():\\n return True\\n return False\",\n \"def filetype(file: str):\\n suffix = file.split('.')[-1]\\n if suffix == 'yml' or suffix == 'yaml':\\n return 'yaml'\\n elif suffix == 'json' or suffix == 'jsn':\\n return 'json'\\n else:\\n raise Exception('Invalid filetype, file must be either json or yaml!')\",\n \"def guess_type_from_content(file_obj):\\n first_bytes = file_obj.read(2)\\n if first_bytes == b\\\"PK\\\":\\n filetype = \\\"xlsx\\\"\\n else:\\n content = file_obj.read()\\n if b\\\"\\\\t\\\" in content:\\n filetype = \\\"tsv\\\"\\n else:\\n filetype = \\\"csv\\\"\\n return filetype\",\n \"def file_type(self):\\n return FileType(self.unpack_dword(0x1C))\",\n \"def allowed_file_type(file_name):\\n\\treturn file_name.lower().endswith(ALLOWED_FILE_TYPES)\",\n \"def file_test(vcf_file):\\n if vcf_file.endswith(\\\".gz\\\"):\\n return gzip.open, \\\"rt\\\"\\n else:\\n return open, \\\"rt\\\"\",\n \"def isgzip(filename):\\n magic_number = b'\\\\x1f\\\\x8b\\\\x08'\\n with open(filename, 'rb') as f:\\n file_start = f.read(len(magic_number))\\n\\n if magic_number == file_start:\\n return True\\n return False\",\n \"def file_check(file):\\n # unpacking the tuple\\n file_name, file_extension = os.path.splitext(file)\\n return file_extension\",\n \"def file_type(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"file_type\\\")\",\n \"def file_type(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"file_type\\\")\",\n \"def GetFileType(filename):\\n filetype = FileType.UNKNOWN\\n\\n # try filename\\n try:\\n with open(filename, \\\"r\\\") as f:\\n try:\\n # try reading as json\\n json.load(f)\\n filetype = FileType.JSON\\n except ValueError:\\n filetype = FileType.INVALID_JSON\\n # not a valid json, get filesize and compare it with all possible sizes\\n try:\\n size = os.path.getsize(filename)\\n except:\\n filetype = FileType.UNKNOWN\\n\\n sizes = GetTemplateSizes()\\n # size is one of a dmp file size\\n if size in sizes:\\n filetype = FileType.DMP\\n elif (size - ((len(hex(BINARYFILE_MAGIC))-2)/2)) in sizes:\\n # check if the binary file has the magic header\\n with open(filename, \\\"rb\\\") as inputfile:\\n inputbin = inputfile.read()\\n if struct.unpack_from('<L', inputbin, 0)[0] == BINARYFILE_MAGIC:\\n filetype = FileType.BIN\\n else:\\n filetype = FileType.INVALID_BIN\\n pass\\n\\n except:\\n filetype = FileType.FILE_NOT_FOUND\\n pass\\n\\n return filetype\",\n \"def is_file(self):\\n return self.type == \\\"file\\\"\",\n \"def file_type(location):\\n try:\\n return _detect(location, DETECT_TYPE)\\n except:\\n # TODO: log errors\\n return ''\",\n \"def determine_filetype(self):\\n filetype = None\\n # Loop through file formats\\n for file_format in self._format_registry:\\n validator = self._format_registry[file_format](\\n self._synapse_client, self.center\\n )\\n try:\\n filenames = [entity.name for entity in self.entitylist]\\n filetype = validator.validateFilename(filenames)\\n except AssertionError:\\n continue\\n # If valid filename, return file type.\\n if filetype is not None:\\n break\\n return filetype\",\n \"def getfiletype(self):\\n d = magic.from_file(os.path.join(self.path,self.name))\\n d = re.sub(', ',',',d)\\n e = d.split(',')\\n filetype = e[0]\\n array = [False,False]\\n if filetype == 'data':\\n array = ['ARM','BIN']\\n elif filetype == 'HIT archive data':\\n array = ['MSP430', 'BIN']\\n elif re.search('ELF',filetype):\\n arch = e[1]\\n if arch == 'ARM':\\n array = ['ARM','ELF']\\n elif arch == 'TI msp430':\\n array = ['MSP430','ELF']\\n else:\\n pass\\n else:\\n pass\\n\\n return array\",\n \"def getType(file):\\n\\n with open(file, \\\"r\\\") as result:\\n return result.readline().strip()\",\n \"def is_archive(afile):\\n return file_ext(os.path.basename(afile)) in ARCHIVE_COMPRESS_FORMATS\",\n \"def get_pkgtype(filename):\\n\\n extension = splitext(filename)[1][1:]\\n if extension in ['rpm', 'deb', 'dsc']:\\n return extension\\n else:\\n abort(\\\"Unsupported packagetype: {} for file: {}\\\".\\n format(extension, filename))\",\n \"def file_type(self):\\n try:\\n return self.get_driver().ShortName\\n except AttributeError:\\n return\",\n \"def method_safe_filetype(self):\\n file_type = self.get_filetype(self.file)\\n\\n if file_type:\\n return file_type.replace('.', '')\",\n \"def is_file(self):\\n return self.tipo == 'file' or self.tipo is None\",\n \"def GetContentType(filename):\\r\\n return mimetypes.guess_type(filename)[0] or 'application/octet-stream'\",\n \"def get_file_type(file: Union[BytesIO, StringIO]) -> FileType:\\n\\n if isinstance(file, BytesIO):\\n return FileType.SOUND\\n content = file.getvalue()\\n if (\\n content.startswith('\\\"\\\"\\\"')\\n or \\\"import\\\" in content\\n or \\\"from \\\" in content\\n or \\\"def \\\" in content\\n or \\\"class \\\" in content\\n or \\\"print(\\\" in content\\n ):\\n return FileType.PYTHON\\n\\n return FileType.CSV\",\n \"def chk_for_gz(filenm):\\n import os\\n from os.path import expanduser\\n filenm = expanduser(filenm)\\n\\n # File exist?\\n if os.path.lexists(filenm):\\n chk=True\\n return filenm, chk\\n\\n # .gz already\\n if filenm.find('.gz') > 0:\\n chk=0\\n return filenm, chk\\n\\n # Add .gz\\n if os.path.lexists(filenm+'.gz'):\\n chk=True\\n return filenm+'.gz', chk\\n else:\\n chk=False\\n return None, chk\",\n \"def file_type(filepath):\\n imexts = ['.png', '.bmp', '.jpg', 'jpeg']\\n textexts = ['.csv', '.txt']\\n if filepath.endswith('.hdf5') or filepath.endswith('.h5'):\\n return 'hdf5'\\n if any([filepath.endswith(ext) for ext in textexts]):\\n return 'delim'\\n if filepath.endswith('.grm.raw'):\\n return 'grm.raw'\\n if filepath.endswith('.npy'):\\n return 'npy'\\n if _is_bed(filepath):\\n return 'bed'\\n if _is_gen(filepath):\\n return 'gen'\\n if any([filepath.endswith(ext) for ext in imexts]):\\n return 'image'\\n return 'unknown'\",\n \"def is_gz_file(f):\\n with open(f, \\\"rb\\\") as fin:\\n return binascii.hexlify(fin.read(2)) == b\\\"1f8b\\\"\",\n \"def get_content_type(filename):\\n return mimetypes.guess_type(filename)[0] or 'application/octet-stream'\",\n \"def file_is_this_type(cls, path):\\n if not os.path.exists(path):\\n raise HelperError(2, \\\"No such file or directory: '{0}'\\\"\\n .format(path))\\n if helpers['isoinfo']:\\n logger.debug(\\\"Using 'isoinfo' to check whether %s is an ISO\\\", path)\\n try:\\n helpers['isoinfo'].call(['-i', path, '-d'])\\n return 100\\n except HelperError:\\n # Not an ISO\\n return 0\\n\\n # else, try to detect ISO files by file magic number\\n with open(path, 'rb') as fileobj:\\n for offset in (0x8001, 0x8801, 0x9001):\\n fileobj.seek(offset)\\n magic = fileobj.read(5).decode('ascii', 'ignore')\\n if magic == \\\"CD001\\\":\\n return 100\\n return 0\",\n \"def infer_ftype(fname):\\n if fname.endswith(\\\".fasta\\\") or fname.endswith(\\\".fa\\\"):\\n ftype = \\\"FASTA\\\"\\n elif fname.endswith(\\\".txt\\\"):\\n ftype = \\\"ACCESSIONS\\\"\\n elif fname.endswith(\\\".json\\\"):\\n ftype = \\\"JSON\\\"\\n else:\\n logger.error(\\\"Unknown file type for file: {}\\\".format(fname))\\n return ftype\",\n \"def GetContentType(filename):\\n return mimetypes.guess_type(filename)[0] or 'application/octet-stream'\",\n \"def gettype(self):\\n return self.filetype\",\n \"def _is_archive(local_path: str) -> bool:\\n archive_mimetypes = [\\n \\\"application/zip\\\",\\n \\\"application/x-tar\\\",\\n \\\"application/x-gzip\\\",\\n \\\"application/x-bzip2\\\",\\n \\\"application/x-7z-compressed\\\",\\n \\\"application/x-rar-compressed\\\",\\n \\\"application/x-xz\\\",\\n \\\"application/x-lzip\\\",\\n \\\"application/x-lzma\\\",\\n \\\"application/x-lzop\\\",\\n \\\"application/x-bzip\\\",\\n \\\"application/x-bzip2\\\",\\n \\\"application/x-compress\\\",\\n \\\"application/x-compressed\\\",\\n ]\\n\\n return mimetypes.guess_type(local_path)[0] in archive_mimetypes\",\n \"def _get_file_txt (zipname) :\\n file = os.path.split (zipname) [1]\\n file = file.replace (\\\".zip\\\", \\\".txt\\\")\\n file = file.replace (\\\".ZIP\\\", \\\".txt\\\")\\n file = file.replace (\\\".gz\\\", \\\".txt\\\")\\n file = file.replace (\\\".GZ\\\", \\\".txt\\\")\\n return file\",\n \"def get_result_file_type(file):\\n if file.endswith('.res'):\\n file_type = 'results'\\n print('\\\\n--------------\\\\nResults file detected!\\\\n--------------')\\n elif file.endswith('.req'):\\n file_type = 'request'\\n print('\\\\n--------------\\\\nRequst file detected!\\\\n--------------')\\n else:\\n raise AviewError('Files must be .res or .req files.')\\n return file_type\",\n \"def get_s3_file_type(file_id):\\n file_object = S3_CLIENT.get_object(Bucket=runtime_context.BUCKET_NAME,\\n Key=file_id)\\n ct = file_object.get('ContentType')\\n return ct.split(';')[0] if ct else 'application/octet-stream'\",\n \"def getFileType(filename):\\n\\n fname, fext = os.path.splitext(filename)\\n dbf = fname + '.dbf'\\n ftype = 'unknown'\\n if os.path.isfile(dbf):\\n ftype = 'shapefile'\\n else:\\n try:\\n fdict = GMTGrid.getFileGeoDict(filename)\\n ftype = 'grid'\\n except Exception as error:\\n try:\\n fdict = GDALGrid.getFileGeoDict(filename)\\n ftype = 'grid'\\n except:\\n pass\\n return ftype\",\n \"def is_archive_ext(filepath):\\n file_extension = os.path.splitext(filepath)[1].lower()\\n if file_extension in get_archive_extensions():\\n return True\\n else:\\n return False\",\n \"def get_file_ext(self):\\n return self.archive.url.split('.')[-1].lower()\",\n \"def checkFormat(vcfname):\\n if vcfname == '-':\\n return 'vcf' #may want to note its a stream\\n typ = checkIfGzip(vcfname)\\n if typ != 'nozip':\\n return typ\\n f = open(vcfname)\\n l = f.readline()\\n f.close()\\n VCF_TAG='##fileformat=VCF'\\n if l[:len(VCF_TAG)] == VCF_TAG:\\n return 'vcf'\\n return 'other'\",\n \"def mime_type(filename):\\n mtype, encoding = guess_type(filename, False)\\n if encoding is None:\\n return mtype or \\\"application/octet-stream\\\"\\n elif encoding == \\\"gzip\\\":\\n # application/gzip is defined by RFC 6713\\n return \\\"application/gzip\\\"\\n # Note that there is a \\\"+gzip\\\" MIME structured syntax suffix specified\\n # in an RFC draft that may one day mean the correct code is:\\n # return mtype + '+gzip'\\n else:\\n return \\\"application/x-\\\" + encoding\",\n \"def get_file_type(file_path):\\n ext = pathlib.Path(file_path).suffix\\n return \\\"video\\\" if ext == \\\".avi\\\" else \\\"image\\\"\",\n \"def are_files_gzipped(raw_files):\\n files_are_gzipped = None\\n for file_name in raw_files:\\n if re.search(r\\\"\\\\.gz$\\\", file_name) is not None:\\n if files_are_gzipped is False:\\n raise Exception(\\n \\\"It seems one file is compressed and the \\\"\\n \\\"other is \\\"\\n \\\"not:\\\\n{}\\\".format(\\\"\\\\n\\\".join(raw_files))\\n )\\n files_are_gzipped = True\\n else:\\n if files_are_gzipped:\\n raise Exception(\\n \\\"It seems one file is compressed and the \\\"\\n \\\"other is \\\"\\n \\\"not:\\\\n{}\\\".format(\\\"\\\\n\\\".join(raw_files))\\n )\\n files_are_gzipped = False\\n return files_are_gzipped\",\n \"def test_find_file_zipped_allow(self):\\n\\n this_file_name = satellite_io.find_file(\\n top_directory_name=TOP_DIRECTORY_NAME,\\n valid_date_string=VALID_DATE_STRING,\\n prefer_zipped=True, allow_other_format=True,\\n raise_error_if_missing=False\\n )\\n\\n self.assertTrue(this_file_name == FILE_NAME_UNZIPPED)\",\n \"def get_type(self):\\n _, ext = zip_path.splitext(self.get_name())\\n ext = ext.lower()\\n\\n for uid, ext_list in six.iteritems(ebooklib.EXTENSIONS):\\n if ext in ext_list:\\n return uid\\n\\n return ebooklib.ITEM_UNKNOWN\",\n \"def isZipArchive(filepath):\\r\\n return zipfile.is_zipfile(filepath)\",\n \"def getTypeFromFileName(filename):\\n ext = os.path.splitext(filename)[1]\\n fileType = fileExtensionMap.get(ext,None)\\n if fileType is not None:\\n return fileType\\n else:\\n logging.warning(\\\"\\\"\\\"Cannot guess type of %s!\\n\\nThe input file does not have a recognized extension:\\n%s\\n\\nYou must manually set the file type with '-T TYPE' where TYPE is in:\\n%s\\nOR set the record separator pattern with '-p PATTERN' where PATTERN is a regular expression. E.G. '^>\\\" for fasta, or '^LOCUS' for gbk.\\n\\\"\\\"\\\" % (filename, list(fileExtensionMap.keys()), list(fileExtensionMap.keys())))\\n sys.exit(65)\",\n \"def _IsFile(self, file_message):\\n message_type = file_message.message_type\\n return (message_type == FileMessage.FILE_DOWNLOAD or\\n message_type == FileMessage.FILE_UPLOAD or\\n message_type == FileMessage.FILE_CLOUD_COPY or\\n message_type == FileMessage.FILE_DAISY_COPY or\\n message_type == FileMessage.FILE_LOCAL_COPY or\\n message_type == FileMessage.FILE_REWRITE or\\n message_type == FileMessage.FILE_HASH)\",\n \"def get_file_status(plan, shape=False):\\n basename = DistrictFile.get_file_name(plan, shape)\\n if os.path.exists(basename + '.zip'):\\n return 'done'\\n if os.path.exists(basename + '_pending.zip'):\\n return 'pending'\\n else:\\n return 'none'\",\n \"def check_media_file_type(media_file_class):\\n if media_file_class == 'AudioFile':\\n media_file_type = 'Audio file'\\n elif media_file_class == 'VideoFile':\\n media_file_type = 'Video file'\\n elif media_file_class == 'DocumentFile':\\n media_file_type = 'Document file'\\n elif media_file_class == 'ImageFile':\\n media_file_type = 'Image file'\\n\\n return media_file_type\",\n \"def get_output_file_type(self):\\n file_name = '.' + self.template_file_name.split('.')[-2]\\n return file_name\",\n \"def get_type(filepath):\\n if os.path.isdir(filepath):\\n return MIME_DIRECTORY\\n\\n if not mimetypes.inited:\\n mimetypes.init()\\n\\n # .gz does not return archive type as expected\\n if filepath.endswith('.gz'):\\n filepath += '.tgz'\\n\\n try:\\n mime_type = mimetypes.types_map[os.path.splitext(filepath)[-1].lower()]\\n except KeyError:\\n mime_type = ''\\n\\n if mime_type.startswith('image'):\\n return MIME_IMAGE_GENERIC\\n\\n elif any(tag in mime_type for tag in ('x-gtar', 'x-tar', 'zip', 'rar', 'x-7z')):\\n return MIME_ARCHIVE\\n\\n elif 'audio' in mime_type:\\n return MIME_AUDIO\\n\\n elif any(tag in mime_type for tag in ('iso9660-image', 'diskimage')):\\n return MIME_DISK\\n\\n elif 'font' in mime_type:\\n return MIME_FONT\\n\\n elif any(tag in mime_type for tag in ('msword', 'wordprocessingml.document', 'opendocument.text')):\\n return MIME_DOC\\n\\n elif any(tag in mime_type for tag in ('powerpoint', 'presentation')):\\n return MIME_PRESENT\\n\\n elif any(tag in mime_type for tag in ('spreadsheet', 'excel', 'text/csv')):\\n return MIME_SPREADSHEET\\n\\n elif 'pdf' in mime_type:\\n return MIME_PDF\\n\\n elif 'python' in mime_type:\\n return MIME_PYTHON\\n\\n elif 'x-sh' in mime_type:\\n return MIME_SHELL\\n\\n elif 'video' in mime_type:\\n return MIME_VIDEO\\n\\n elif 'text' in mime_type:\\n return MIME_PLAINTEXT\\n\\n return MIME_BINARY # Generic file\",\n \"def get_type(ext):\\n if ext.lower() in Asset.SUPPORTED_IMAGE_EXT['in']:\\n return 'image'\\n return 'file'\",\n \"def is_file_type(file_path, file_type):\\n\\n if not file_exists(file_path):\\n return False\\n\\n if file_path.endswith(file_type):\\n return True\\n\\n return False\",\n \"def check_file_type(fname):\\n ext = path.splitext(fname)[1]\\n return ext in allowed_extensions\",\n \"def getFiletypeFromDictionary(gpfn, surl_filetype_dictionary):\\n\\n filetype = 'UNKNOWN'\\n try:\\n filetype = surl_filetype_dictionary[gpfn]\\n except Exception, e:\\n tolog(\\\"!!WARNING!!2240!! Filetype not found for surl=%s: %s\\\" % (gpfn, e))\\n\\n return filetype\",\n \"def s3_input_file_type(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"s3_input_file_type\\\")\",\n \"def selection(self):\\n self.file.seek(0)\\n start = self.file.readline().rstrip().upper()\\n if start[0] == \\\">\\\":\\n self.file_type = \\\"fasta\\\"\\n elif start[0:1] == \\\"ID\\\":\\n self.file_type = \\\"embl_gcg\\\"\\n elif start[0:5] == \\\"LOCUS\\\":\\n self.file_type = \\\"genbank\\\"\\n elif start[0] == \\\";\\\":\\n self.file_type = \\\"ig\\\"\\n elif not re.search('[^GATCN]', start):\\n self.file_type = \\\"plain\\\"\\n else:\\n self.file_type = None\\n return self.file_type\",\n \"def getWebImgType_file(filename):\\n data = open(filename,'rb').read(11)\\n\\n # JPG\\n if data[:4] == b'\\\\xff\\\\xd8\\\\xff\\\\xe0' and data[6:11] == b'JFIF\\\\x00':\\n return 'JPEG'\\n # PNG\\n if data[:6] == b'\\\\x89PNG\\\\r\\\\n':\\n return 'PNG'\\n # GIF\\n if data[:3] == b'\\\\x47\\\\x49\\\\x46\\\\x38':\\n return 'GIF'\\n\\n # Format not recognised\\n return False\",\n \"def get_file_type(file_type: str, file_extension: str):\\n\\n if file_type is None and file_extension is None:\\n return None\\n\\n if file_type is None:\\n if len(file_extension) > 0 and file_extension[0] == '.':\\n file_extension = file_extension[1:len(file_extension)]\\n\\n return FileTypes(file_extension)\\n\\n return FileTypes(file_type)\",\n \"def get_mime_type(file):\\n initial_pos = file.tell()\\n file.seek(0)\\n mime_type = magic.from_buffer(file.read(2048), mime=True)\\n file.seek(initial_pos)\\n return mime_type\",\n \"def test_find_file_zipped_no_allow(self):\\n\\n this_file_name = satellite_io.find_file(\\n top_directory_name=TOP_DIRECTORY_NAME,\\n valid_date_string=VALID_DATE_STRING,\\n prefer_zipped=True, allow_other_format=False,\\n raise_error_if_missing=False\\n )\\n\\n self.assertTrue(this_file_name == FILE_NAME_ZIPPED)\",\n \"def getMimeType(pathName):\\n pnl = pathName.lower()\\n for ext, mt in MIME_TYPES:\\n ext2 = \\\".\\\" + ext\\n if pnl[-len(ext2):]==ext2:\\n return mt\\n #//for\\n return \\\"\\\"\",\n \"def detect_content_type(self, path=None, payload=None):\\n\\n f = file_path(path, payload)\\n switches = [\\\"-d\\\", f]\\n result = self._command_template(switches).lower()\\n return result, path, f\",\n \"def getNametype(self, path):\\n if os.path.isdir(path):\\n return 'dir'\\n elif os.path.isfile(path):\\n return 'file'\\n else: return None\",\n \"def ComputeFileTypes(self):\\n for rel_path, file_data in self._files.iteritems():\\n if 'ftype' in file_data:\\n continue\\n ftype = self._file_type_decoder.GetType(rel_path)\\n if ftype:\\n file_data['ftype'] = ftype\",\n \"def file_format(x):\\n return FILE_EXT_FORMAT_MAP.get(genomic_file_ext(x))\",\n \"def _accept_for_flag (self, filename):\\n\\t\\troot, ext = os.path.splitext(filename)\\n\\t\\tif not ext:\\n\\t\\t\\treturn 1\\n\\t\\telse:\\n\\t\\t\\tbinary_extensions = ['.jpg', '.gif', '.png', '.jar' ]\\n\\t\\t\\treturn ext not in ['.bak', '.off','.old', '.works', '.clean', '.obs', '.log', '.db'] + binary_extensions\",\n \"def test_get_file_type(self):\\n file_list = {'events': 'monol_testA_nustar_fpma_ev',\\n 'lc': 'monol_testA_E3-50_lc',\\n 'pds': 'monol_testA_E3-50_pds',\\n 'gti': 'monol_testA_E3-50_rebin4_gti',\\n 'cpds': 'monol_test_E3-50_cpds'}\\n for realtype in file_list.keys():\\n fname = os.path.join(self.datadir,\\n file_list[realtype] + HEN_FILE_EXTENSION)\\n ftype, _ = hen.io.get_file_type(fname)\\n assert ftype == realtype, \\\"File types do not match\\\"\",\n \"def getFileCategory(fileName):\\n extension = __getExt(fileName)\\n if extension in (_7z, \\\"7zip\\\", ace, air, apk, \\\"appxbundle\\\", \\\"arc\\\", arj, \\\"asec\\\", \\\"bar\\\", bz2, \\\"bzip\\\", cab, \\\"cso\\\", deb, \\\"dlc\\\", dmg, gz, \\\"gzip\\\", hqx, \\\"inv\\\", \\\"ipa\\\", iso, \\\"isz\\\", jar, \\\"msu\\\", \\\"nbh\\\", pak, rar, rpm, sis, sisx, sit, \\\"sitd\\\", sitx, tar, targz, tgz, \\\"webarchive\\\", xap, z, zip):\\n return FileCategory.Archive\\n\\n if extension in (_3ga, aac, aiff, amr, ape, \\\"arf\\\", asf, asx, \\\"cda\\\", \\\"dvf\\\", flac, \\\"gp4\\\", \\\"gp5\\\", gpx, \\\"logic\\\", m4a, m4b, \\\"m4p\\\", midi, mp3, ogg, \\\"pcm\\\", \\\"rec\\\", snd, \\\"sng\\\", \\\"uax\\\", wav, wma, wpl, \\\"zab\\\"):\\n return FileCategory.Audio\\n\\n if extension in (_as, asm, asp, \\\"aspx\\\", bat, c, \\\"cp\\\", cpp, cs, css, \\\"gradle\\\", htm, \\\"inc\\\", jad, java, js, json, \\\"jsp\\\", \\\"lib\\\", m, \\\"matlab\\\", ml, o, perl, php, pl, \\\"ps1\\\", py, rb, \\\"rc\\\", rss, \\\"scpt\\\", sh, sql, src, \\\"swift\\\", \\\"vb\\\", \\\"vbs\\\", \\\"ws\\\", \\\"xaml\\\", \\\"xcodeproj\\\", xml, xsd, xsl, xslt, yml):\\n return FileCategory.Code\\n\\n if extension in (abw, \\\"aww\\\", azw, \\\"azw3\\\", \\\"azw4\\\", cbr, cbz, chm, \\\"cnt\\\", \\\"dbx\\\", djvu, doc, docm, docx, dot, dotm, dotx, epub, fb2, \\\"iba\\\", \\\"ibooks\\\", \\\"ind\\\", \\\"indd\\\", \\\"lit\\\", mht, mobi, mpp, odf, odt, ott, \\\"pages\\\", pmd, \\\"prn\\\", \\\"prproj\\\", ps, pub, \\\"pwi\\\", rep, rtf, sdd, sdw, \\\"shs\\\", \\\"snp\\\", sxw, tpl, vsd, \\\"wlmp\\\", wpd, wps, wri):\\n return FileCategory.Document\\n\\n if extension in (bmp, cpt, dds, dib, dng, \\\"dt2\\\", emf, gif, ico, \\\"icon\\\", icns, jpeg, jpg, pcx, pic, png, psd, \\\"psdx\\\", raw, tga, \\\"thm\\\", tif, tiff, wbmp, \\\"wdp\\\", webp):\\n return FileCategory.Image\\n\\n if extension in (oxps, pdf, xps):\\n return FileCategory.PDF\\n\\n if extension in (key, \\\"keynote\\\", pot, potx, pps, ppsx, ppt, pptm, pptx):\\n return FileCategory.Presentation\\n\\n if extension in (ods, \\\"numbers\\\", sdc, xls, xlsx, xlsb):\\n return FileCategory.Spreadsheet\\n\\n if extension in (\\\"alx\\\", application, csv, \\\"eng\\\", html, log, \\\"lrc\\\", \\\"lst\\\", nfo, opml, \\\"plist\\\", reg, srt, sub, \\\"tbl\\\", text, txt):\\n return FileCategory.Text\\n\\n if extension in (\\\"264\\\", _3g2, _3gp, avi, \\\"bik\\\", \\\"dash\\\", \\\"dat\\\", \\\"dvr\\\", flv, h264, m2t, m2ts, m4v, mkv, mod, mov, mp4, mpeg, mpg, \\\"mswmm\\\", mts, ogv, rmvb, swf, \\\"tod\\\", \\\"tp\\\", ts, vob, webm, wmv):\\n return FileCategory.Video\\n\\n return FileCategory.Binary\",\n \"def unreal_attachment_type(unreal_file):\\n if unreal_file.type == \\\"minidump\\\":\\n return MINIDUMP_ATTACHMENT_TYPE\",\n \"def guess_content_type(filename):\\n return mimetypes.guess_type(filename)[0]\",\n \"def getFile(self):\\n #try to redetect the filetype\\n vim.command(\\\"filetype detect\\\")\\n #return the filetype\\n filetype = vim.eval(\\\"&ft\\\")\\n #filetype = vim.command(\\\"&ft\\\")\\n if filetype:\\n for file in self.template_files:\\n if filetype.lower() in file.lower():\\n self.hasTemplate = True\\n return open(self.template_folder + \\\"/\\\" + file, 'r')\\n return None\",\n \"def layer_type(filename):\\n extension = os.path.splitext(filename)[1]\\n if extension.lower() in ['.shp']:\\n return FeatureType.resource_type\\n elif extension.lower() in ['.tif', '.tiff', '.geotiff', '.geotif']:\\n return Coverage.resource_type\\n else:\\n msg = ('Saving of extension [%s] is not implemented' % extension)\\n raise Exception(msg)\",\n \"def file_type(self):\\n ftype = str(self.FileType)\\n choices = None\\n if self.FileType == 'Driver':\\n choices = {\\n 0x0: 'Unknown',\\n 0x1: 'Printer',\\n 0x2: 'Keyboard',\\n 0x3: 'Language',\\n 0x4: 'Display',\\n 0x5: 'Mouse',\\n 0x6: 'Network',\\n 0x7: 'System',\\n 0x8: 'Installable',\\n 0x9: 'Sound',\\n 0xA: 'Comms',\\n 0xB: 'Input Method',\\n 0xC: 'Versioned Printer',\\n }\\n elif self.FileType == 'Font':\\n choices = {\\n 0x1: 'Raster',\\n 0x2: 'Vector',\\n 0x3: 'Truetype',\\n }\\n if choices != None:\\n subtype = obj.Object('Enumeration', 0x28, vm = self.obj_vm, parent = self, choices = choices)\\n ftype += \\\" (\\\" + str(subtype) + \\\")\\\"\\n\\n return ftype\",\n \"def get_ctype(f):\\n return mimetypes.guess_type(f)[0]\",\n \"def splitext_zip(fname):\\n base_fname, ext = splitext(fname)\\n if ext == '.gz' or ext == '.zip':\\n base_fname, ext2 = splitext(base_fname)\\n ext = ''.join([ext2, ext])\\n return base_fname, ext\",\n \"def is_accept_type(file_name):\\n bare_name, file_extension = os.path.splitext(file_name)\\n for ext in ACCEPTED_FILES:\\n if file_extension.lower() == ext:\\n return True\\n return False\",\n \"def get_filetype(filemode):\\n mode_funcs = [\\n (stat.S_ISREG, \\\"-\\\"),\\n (stat.S_ISBLK, \\\"b\\\"),\\n (stat.S_ISCHR, \\\"c\\\"),\\n (stat.S_ISDIR, \\\"d\\\"),\\n (stat.S_ISFIFO, \\\"p\\\"),\\n (stat.S_ISLNK, \\\"l\\\"),\\n (stat.S_ISSOCK, \\\"s\\\"),\\n ]\\n for pred, val in mode_funcs:\\n if pred(filemode):\\n return val\\n return \\\"?\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75641257","0.739077","0.7374025","0.7309392","0.69896644","0.6765388","0.6685862","0.6668622","0.66228014","0.6619521","0.6540485","0.6445927","0.64198005","0.641593","0.6397573","0.6389309","0.63834107","0.63234156","0.6313959","0.6312306","0.63119596","0.62599087","0.62448436","0.62428564","0.6240239","0.62348974","0.61915684","0.6176116","0.6173916","0.614354","0.6113108","0.6113108","0.6110758","0.609114","0.60881466","0.60733354","0.60708857","0.60659534","0.60637975","0.6036876","0.60188615","0.5992262","0.5979413","0.5972433","0.59705037","0.5969908","0.59639597","0.5962821","0.59557784","0.59375465","0.592544","0.59200853","0.59163123","0.5914999","0.59089625","0.5893873","0.5887659","0.58806145","0.5874682","0.5859943","0.58532727","0.58527637","0.5850407","0.5848576","0.5842954","0.58428895","0.58411837","0.58350664","0.58220714","0.58149815","0.5754179","0.575308","0.57348746","0.5731974","0.57231224","0.571791","0.5703985","0.5680504","0.56694233","0.56686133","0.5635276","0.56201124","0.5618037","0.56002814","0.55987674","0.559079","0.5585036","0.5584332","0.5583962","0.5581788","0.55697995","0.5551536","0.5548672","0.553869","0.55377233","0.5528509","0.55279344","0.55249757","0.5520315","0.5517405"],"string":"[\n \"0.75641257\",\n \"0.739077\",\n \"0.7374025\",\n \"0.7309392\",\n \"0.69896644\",\n \"0.6765388\",\n \"0.6685862\",\n \"0.6668622\",\n \"0.66228014\",\n \"0.6619521\",\n \"0.6540485\",\n \"0.6445927\",\n \"0.64198005\",\n \"0.641593\",\n \"0.6397573\",\n \"0.6389309\",\n \"0.63834107\",\n \"0.63234156\",\n \"0.6313959\",\n \"0.6312306\",\n \"0.63119596\",\n \"0.62599087\",\n \"0.62448436\",\n \"0.62428564\",\n \"0.6240239\",\n \"0.62348974\",\n \"0.61915684\",\n \"0.6176116\",\n \"0.6173916\",\n \"0.614354\",\n \"0.6113108\",\n \"0.6113108\",\n \"0.6110758\",\n \"0.609114\",\n \"0.60881466\",\n \"0.60733354\",\n \"0.60708857\",\n \"0.60659534\",\n \"0.60637975\",\n \"0.6036876\",\n \"0.60188615\",\n \"0.5992262\",\n \"0.5979413\",\n \"0.5972433\",\n \"0.59705037\",\n \"0.5969908\",\n \"0.59639597\",\n \"0.5962821\",\n \"0.59557784\",\n \"0.59375465\",\n \"0.592544\",\n \"0.59200853\",\n \"0.59163123\",\n \"0.5914999\",\n \"0.59089625\",\n \"0.5893873\",\n \"0.5887659\",\n \"0.58806145\",\n \"0.5874682\",\n \"0.5859943\",\n \"0.58532727\",\n \"0.58527637\",\n \"0.5850407\",\n \"0.5848576\",\n \"0.5842954\",\n \"0.58428895\",\n \"0.58411837\",\n \"0.58350664\",\n \"0.58220714\",\n \"0.58149815\",\n \"0.5754179\",\n \"0.575308\",\n \"0.57348746\",\n \"0.5731974\",\n \"0.57231224\",\n \"0.571791\",\n \"0.5703985\",\n \"0.5680504\",\n \"0.56694233\",\n \"0.56686133\",\n \"0.5635276\",\n \"0.56201124\",\n \"0.5618037\",\n \"0.56002814\",\n \"0.55987674\",\n \"0.559079\",\n \"0.5585036\",\n \"0.5584332\",\n \"0.5583962\",\n \"0.5581788\",\n \"0.55697995\",\n \"0.5551536\",\n \"0.5548672\",\n \"0.553869\",\n \"0.55377233\",\n \"0.5528509\",\n \"0.55279344\",\n \"0.55249757\",\n \"0.5520315\",\n \"0.5517405\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69038486"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":83191,"cells":{"query":{"kind":"string","value":"Return (gzipped) file names in directory containing the given extension."},"document":{"kind":"string","value":"def glob_ext_files(dirname, ext=\"fa\") -> list:\n fnames = glob(os.path.join(dirname, f\"*.{ext}*\"))\n return [f for f in fnames if f.endswith((ext, f\"{ext}.gz\"))]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_file_names(path, extension='.json'):\n fn = os.listdir(path)\n l = []\n for f in fn:\n if f.endswith(extension, 4):\n l.append(f)\n l = sorted(l)\n return l","def list_all_files_with_extension(path, extension, do_unzip=True):\n files = []\n for file in os.listdir(path):\n if file.endswith(extension):\n files.append(file)\n if do_unzip and file.endswith(\".zip\"):\n new_path = unzip(os.path.join(path, file))\n os.remove(os.path.join(path, file))\n files = files + list_all_files_with_extension(new_path, extension)\n # Dive into subfolders.\n if os.path.isdir(os.path.join(path, file)):\n files = files + list_all_files_with_extension(os.path.join(path, file), extension)\n return files","def get_path_files_with_ext(extension, directory):\n\n return [\n directory + file_name for file_name in os.listdir(directory)\n if file_name.endswith(extension)\n ]","def get_files(path, extension):\n extension = listify(extension)\n return [p for p in path.ls() if p.suffix in extension and \"(\" not in p.stem]","def get_files(folder=\"\", extension=\"\"):\n return sorted(glob.glob(folder + \"*\" + extension), reverse=True)","def walk_files_with(extension, directory='.'):\r\n filelist = []\r\n for root, dirnames, filenames in os.walk(directory):\r\n for filename in filenames:\r\n if filename.lower().endswith('.' + extension):\r\n filelist.append(os.path.join(root, filename))\r\n return filelist","def files_from_dir(dirname, exts=[\"obj\", \"h5\"]):\n filenames = list()\n for ext in exts:\n ext_expr = os.path.join(dirname, f\"*.{ext}\")\n filenames.extend(glob.glob(ext_expr))\n\n return sorted(filenames, key=os.path.basename)","def getFiles(searchDir = './', extension = 'source'):\n from glob import glob \n\n return glob(searchDir+'/*.'+extension)","def getAllFilesWithExtension(directory,extension):\n filesWithExtension = []\n for root, dirs, files in os.walk(directory):\n for file in files:\n if file.endswith(extension):\n filesWithExtension.append(os.path.realpath(os.path.join(root, file)))\n return filesWithExtension","def get_files_names_from_dir(directory: str, ext: str) -> List[str]:\n files_names = [\n file_name\n for file_name in listdir(directory) if file_name.endswith(ext)\n ]\n files_names.sort()\n return files_names","def collect_files_with_extensions(self, extension: str) -> List[str]:\n occurrences = []\n for position in os.listdir(self.directory):\n if os.path.isdir(position):\n for file in os.listdir(position):\n if os.path.isfile(os.path.join(position, file)) and file.endswith(\n extension\n ):\n occurrences.append(os.path.join(self.directory, position, file))\n return occurrences","def list_files(directory, extension):\n file_list = listdir(directory)\n included_list = []\n for f in file_list:\n for ext in extension:\n if f.endswith('.' + ext):\n included_list.append(f)\n break\n return included_list","def get_files(suffix):\n lst = os.listdir(\".\")\n return filter(lambda x: x.endswith(suffix), lst)","def find_files(extensions):\n\n return [fname for fname in os.listdir('.') if fname.endswith(extensions)]","def getFiles(directory, extension):\n matches = []\n for root, dirnames, filenames in os.walk(directory):\n for filename in fnmatch.filter(filenames, '*.{0}'.format(extension)):\n filepath = os.path.abspath(os.path.join(root, filename))\n matches.append([filepath, os.path.getsize(os.path.join(root, filename))])\n\n #sort by size\n #matches.sort(key=lambda filename: filename[1], reverse=False)\n\n matches = [x[0] for x in matches]\n\n return matches","def get_all_files(directory, extension):\n return (f for f in os.listdir(directory) if f.endswith(extension) and os.path.isfile(os.path.join(directory, f)))","def get_gswe_paths(dirpath, extension = '.tif'):\n\n\textension = '*' + extension\n\tpath = os.path.join(dirpath, extension)\n\tfile_path_list = glob.glob(path)\n\tfile_path_list.sort()\n\treturn file_path_list","def get_all_compressed_files_in_directory(directory: str):\n\n all_files_and_folders = os.listdir(directory)\n\n only_compressed_files = []\n for file in all_files_and_folders:\n if '.zip' in file or '.7z' in file:\n only_compressed_files.append(file)\n ...\n\n return only_compressed_files","def getListOfFiles(directory, extension):\n allFiles = [f for f in os.listdir(directory) if\n os.path.isfile(os.path.join(directory, f)) and f.endswith(extension)]\n return allFiles","def extract_filenames(folder, name=\"\", extension='pdb'):\n\n files = []\n # Extract all the paths corresponding to the request\n paths = glob.glob(folder + \"/\" + name + \"*.\" + extension)\n\n # Extract only the filenames (without parent folder path and extension) from each filename\n for path in paths:\n base = os.path.basename(path)\n file = os.path.splitext(base)[0]\n files.append(file)\n\n return sorted(files)","def search_extension(path, ext):\n output = []\n for root, dirs, files in os.walk(path, topdown=True):\n for file in files:\n if file.endswith(ext):\n path = os.path.join(root, file)\n output.append(path)\n\n return output","def get_files_with_extension(self, extension=sys.argv[1]) -> list:\n if extension == \"\":\n raise EnvironmentError(\"No extension provided!\")\n\n result = []\n for idx, file in enumerate(self.file_list):\n if re.search(extension + \"$\", file):\n result.append(file)\n\n if len(result) == 0:\n raise Exception(\"No {} files found.\".format(extension))\n\n return result","def files_with_suffix(directory, suffix, pure=False):\n files = [os.path.abspath(path) for path in glob.glob(os.path.join(directory, '**', f'*{suffix}'), recursive=True)]\n if pure:\n files = [os.path.split(file)[-1] for file in files]\n return files","def getFiles(directory, showName, extension):\n os.chdir(directory)\n \n list = []\n \n for file in glob.glob(\"*\"+showName+\"*.\"+extension):\n list.append(file)\n \n return list","def listar_extension(dir_name, ext='.png'):\n\n list_ext = []\n for root, dirs, files in os.walk(directorio):\n for name in files:\n if ext in name:\n list_ext.append(name)\n for name in dirs:\n if ext in name:\n list_ext.append(name)\n\n return list_ext","def get_files(path: str, extension: str = '.wav') -> List[Path]:\n\n return list(Path(path).expanduser().resolve().rglob(f'*{extension}'))","def _glob_files(directories, extensions):\n pwd = Path(__file__).resolve().parent\n open3d_root_dir = pwd.parent\n\n file_paths = []\n for directory in directories:\n directory = open3d_root_dir / directory\n for extension in extensions:\n extension_regex = \"*.\" + extension\n file_paths.extend(directory.rglob(extension_regex))\n file_paths = [str(file_path) for file_path in file_paths]\n file_paths = sorted(list(set(file_paths)))\n return file_paths","def get_files(imagedir, ext='jpg|jpeg|bmp|png'):\n rex = re.compile(r'^.*\\.({})$'.format(ext), re.I)\n return [os.path.join(imagedir,base) for base in os.listdir(imagedir)\n if rex.match(base)]","def get_files(data_dir, extension):\n files = []\n if data_dir and os.path.exists(data_dir):\n files = glob.glob(data_dir + \"/*.\" + extension)\n return files","def getFiles(directory):\n # os.listdir only for locally downloaded files\n _files=[]\n for item in os.listdir(directory):\n path = os.path.join(directory, item)\n if not os.path.isdir(path) and \".lhe.gz\" in path:\n _files.append(path)\n elif os.path.isdir(path):\n getFiles(path)\n return _files","def dir_search(ext, file_path='./'):\n try:\n return [file_path + \"/\" + file for file in os.listdir(file_path) if file.endswith(ext)]\n except OSError as e:\n logger.error(e)\n return []\n except Exception as e:\n logger.error(e)\n return []","def get_file_extensions():\n my_files_ext = []\n for file in os.listdir(os.getcwd()):\n if os.path.isfile(file):\n file_info = os.path.splitext(file)\n file_ext = file_info[1]\n my_files_ext.append(file_ext)\n return [file for file in my_files_ext]","def dir_ftype(directory,extension):\n\textension = extension.replace(\".\",\"\") # make sure theres no \".\"\n\tfnames = directory+os.sep+\"*\"+\".\"+extension\n\tfnames = glob.glob(fnames)\n\tfnames = np.sort(fnames) # order files from 0 to last\n\treturn fnames","def _package_files(directory: str, suffix: str) -> list:\n\n paths = []\n\n for (path, directories, filenames) in os.walk(directory):\n for filename in filenames:\n if filename.endswith(suffix):\n paths.append(os.path.join('..', path, filename))\n\n return paths","def __get_files(self, directory, file_extension):\n path_spec = \"{}**/*.{}\" if self.__config.recursive() else \"{}*.{}\"\n return glob.glob(path_spec.format(directory, file_extension), recursive=self.__config.recursive())","def getFilenameList(path, pattern='*.nii.gz'):\n\n filename = [os.path.basename(x) for x in sorted(glob.glob(os.path.join(path, pattern)))]\n\n return filename","def filter_files_by_extension(\n files: list ,\n extensions: list\n):\n filtered_files = []\n for file in files:\n file_ext = os.path.splitext(file)[-1].lower()\n file_ext = _remove_dot_from_extension(file_ext)\n for extension in extensions:\n ext = _remove_dot_from_extension(extension).lower()\n # print(\"ext \\n\", ext)\n # print(\"file_ext \\n\", file_ext)\n if file_ext == ext:\n filtered_files.append(file)\n\n return filtered_files\n ...","def get_extensionless_filenames(path):\n return [\n filename.replace('.pdf', '')\n for filename in os.listdir(path)\n if isfile(join(path, filename))\n ]","def list_type_in_dir(path, extension):\n path, extension = check_args(path, extension)\n files = os.listdir(path)\n file_list = [os.path.join(path, f)\n for f in fnmatch.filter(files, '*' + extension)]\n\n return file_list","def list_files(folder, number_of_files=None):\n paths = glob.glob(folder + \"/*.gz\")\n\n if number_of_files is None:\n return paths\n else:\n return paths[:number_of_files]","def filelisting(directory, suffix = 'tcx'):\n files = []\n for f in os.listdir(directory):\n fullpath = os.path.join(directory, f)\n if os.path.isfile(fullpath) and f.endswith(suffix):\n files.append(fullpath)\n return files","def find_files(directory, extensions):\n res = set()\n for filename in os.listdir(directory):\n if filename.endswith(extensions):\n res.add(\"{}/{}\".format(directory, filename))\n return list(res)","def zip_all(search_dir, extensions, output_path):\r\n with ZipFile(output_path, 'w') as zip_object:\r\n for folder, _, filenames in os.walk(search_dir):\r\n rel_path = os.path.relpath(folder, search_dir)\r\n for filename in filenames:\r\n if pathlib.Path(filename).suffix in extensions:\r\n zip_object.write(\r\n os.path.join(folder, filename),\r\n os.path.join(rel_path, filename)\r\n )","def recursive_glob(self, rootdir='.', suffix=''):\n return [os.path.join(rootdir, filename)\n for filename in sorted(os.listdir(rootdir)) if filename.endswith(suffix)]","def get_files_in_dir(dir, ext):\n import os\n\n for root, dirs, files in os.walk(dir):\n for file in files:\n if file.split('.')[1].lower() == ext.lower() or not ext:\n file_full_path = os.path.join(root, file)\n yield file_full_path","def create_file_list(path, extension='.png'):\n file_list = []\n for root, _, files in os.walk(path, topdown=False):\n for name in files:\n if name.endswith(extension):\n full_name = os.path.join(root, name)\n file_list.append(full_name)\n\n return file_list","def load_filenames_from_directory(directory_path: str, extension: str='.bin') -> List[str]:\n sorted_filenames_list = []\n if(os.path.exists(directory_path)):\n filename_list = [filename for filename in os.listdir(directory_path)\n if (os.path.isfile(\n os.path.join(directory_path, filename)\n ) and extension in filename) ]\n \n filename_list = sort_list(filename_list, extension=extension)\n\n sorted_filenames_list += [os.path.join(directory_path, filename) for filename in filename_list]\n else:\n raise FileNotFoundError\n \n return sorted_filenames_list\n\n\n \"\"\"\n \"\"\"","def get_files(self, extension, recurs=True):\n if self._dirname is None:\n return []\n\n if os.path.exists(self._dirname) is False:\n raise NoDirectoryError(dirname=self._dirname)\n\n return sppasDirUtils.dir_entries(self._dirname, extension, recurs)","def getFilenames(dir_path, remove_file_ext=False):\n filename_list = []\n \n dir_obj = os.fsencode(dir_path)\n for file in os.listdir(dir_obj):\n filename = os.fsdecode(file)\n if remove_file_ext: filename = os.path.splitext(filename)[0]\n \n file_path = os.path.join(dir_path, filename)\n \n if os.path.isdir(file_path) == False:\n filename_list.append(filename)\n \n return filename_list","def _extract_all_gz_in_dir(directory):\n for file in os.listdir(directory):\n if file.endswith(\".gz\"):\n gz_fname = os.path.join(directory, file)\n _extract_gz(gz_fname, os.path.dirname(gz_fname))\n os.remove(gz_fname)","def split_ext(filepath):\n\t(fn, ext) = os.path.splitext(filepath)\n\tif ext=='.gz':\n\t\t(fn, ext) = os.path.splitext(fn)\n\t\text += '.gz'\n\treturn (fn, ext)","def get_filelist(import_path, extension):\n filelist = []\n for root, dirs, files in os.walk(import_path):\n filelist += glob.glob(os.path.join(root, '*.' + extension))\n return filelist","def get_files_from_of_type(path: str, ext: str) -> List[str]:\n files = []\n for root, dirnames, filenames in os.walk(path):\n for filename in fnmatch.filter(filenames, \"*.\" + str(ext)):\n files.append(os.path.join(root, filename))\n if not files:\n logging.error(\"No language files found in folder: \" + str(os.sep.join([convert_vars.BASE_PATH, \"source\"])))\n logging.debug(f\" --- found {len(files)} files of type {ext}. Showing first few:\\n* \" + str(\"\\n* \".join(files[:3])))\n return files","def find_specific_file_extension_in_dir(dir_path, extension):\r\n return glob.glob(os.path.join(dir_path, r'*{}'.format(extension)))[0].replace('\\\\', '/').split('/')[-1]","def get_sorted_filenames_in_dir_with_suffix(dir_path: str, suffix: (str, list)):\n if isinstance(suffix, str):\n suffix = [suffix]\n\n paths = []\n for s in suffix:\n paths += glob.glob(os.path.join(dir_path, \"**\", \"*.\" + s), recursive=True)\n return sorted(paths)","def test_get_filenames_by_ext():\n tmpdir = os.path.join(tempfile.gettempdir(), \"jade-test-tmp87alkj8ew\")\n os.makedirs(tmpdir, exist_ok=True)\n\n data = {\"A\": 1, \"B\": 2}\n json_file = os.path.join(tmpdir, \"a.json\")\n dump_data(data, json_file)\n\n toml_file = os.path.join(tmpdir, \"b.toml\")\n dump_data(data, toml_file)\n\n filenames = get_filenames_by_ext(tmpdir, \".json\")\n assert \"a.json\" in next(filenames)\n\n filenames = get_filenames_by_ext(tmpdir, \".toml\")\n assert \"b.toml\" in next(filenames)","def list_all_files(\n dir_path: str = \"./domain\", ext: str = \".py\", excludes=None, includes=None, return_base_name=False\n) -> List[str]:\n files = []\n for entry in os.scandir(dir_path):\n if entry.is_dir():\n files += list_all_files(entry.path, ext=ext, excludes=excludes, return_base_name=return_base_name)\n elif entry.is_file():\n if not ext or (ext and entry.path.endswith(ext)):\n if excludes and entry.path.endswith(excludes):\n continue\n if includes and not entry.path.endswith(includes):\n continue\n if return_base_name:\n files.append(os.path.basename(entry.path))\n else:\n files.append(entry.path)\n else:\n pass\n return files","def _collect_files(folders, extention='Default'):\r\n if isinstance(extention, str):\r\n if extention.lower() == 'default':\r\n extention = ['.*']\r\n else:\r\n extention = [extention]\r\n files = []\r\n for f in folders:\r\n for e in extention:\r\n files += glob(os.path.join(f, f'*{e}'))\r\n return files","def list_files(file, folder, extension = '*.evtx'):\r\n if file:\r\n return [file]\r\n elif folder:\r\n return [ y for x in os.walk(folder) for y in glob(os.path.join(x[0], extension))]\r\n else:\r\n return []","def get_files_from_folder(input_dir, extensions=None):\n output = []\n if extensions is None:\n extensions = [\"\"]\n elif not isinstance(extensions, (tuple, list)):\n extensions = [extensions]\n\n for ext in extensions:\n files = Path(input_dir).rglob(\"*{}\".format(ext))\n output.extend([f.as_posix() for f in files if f.is_file()])\n\n return output","def find_files_by_extensions(cls, search_path, allowed_ext):\n file_list = []\n for root, dirnames, filenames in os.walk(search_path):\n for filename in filenames:\n name, extension = os.path.splitext(filename)\n if extension in allowed_ext:\n file_list.append(os.path.join(root, filename))\n\n return file_list","def recursive_glob(rootdir=\".\", suffix=\".tif\"):\r\n return [\r\n os.path.join(looproot,filename)\r\n for looproot, _, filenames in os.walk(rootdir)\r\n for filename in filenames\r\n if filename.endswith(suffix)\r\n ]","def get_file_paths(dir, ext):\n files = []\n for root, dirs, filenames in os.walk(dir):\n for filename in filenames:\n if filename.endswith(ext):\n files.append(os.path.join(root, filename))\n return files","def list_a_file_type(path, extension):\n path, extension = check_args(path, extension)\n file_list = [os.path.join(dirpath, f)\n for dirpath, dirnames, files in os.walk(path)\n for f in fnmatch.filter(files, '*' + extension)]\n\n return file_list","def get_files_from_directory(directory):\n file_list = []\n for root, dirs, files in os.walk(directory.replace('/', '\\\\'), topdown=False):\n for name in files:\n if os.path.splitext(name)[1] in supported_extensions:\n file_list.append(os.path.join(root, name))\n return file_list","def namelist(self):\n\n # try to create a name from the archive name\n # because a gzipped file doesn't have information about the\n # original filename\n # gzipping a file creates the archive name by appending \".gz\"\n genericfilename = self._archivename\n\n if not genericfilename:\n genericfilename = \"generic.unknown.gz\"\n\n try:\n # get list of file extensions\n fileendinglist = Archivehandle.avail_archive_extensionlist4type['gz']\n replacedict = {\"wmz\": \"wmf\",\n \"emz\": \"emf\"}\n for ending in fileendinglist:\n endingwithdot = \".\"+ending\n if genericfilename.endswith(endingwithdot):\n if ending in replacedict:\n genericfilename = genericfilename[:-len(ending)]+replacedict[ending]\n else:\n genericfilename = genericfilename[:-len(endingwithdot)]\n break\n\n except Exception as e:\n print(e)\n pass\n return [genericfilename]","def list_pictures(directory, ext='JPEG'):\n return [os.path.join(root, f)\n for root, _, files in os.walk(directory) for f in files\n if re.match(r'([\\w]+\\.(?:' + ext + '))', f)]","def grab_files(folder_path, ext='.h5', first4=None):\r\n folder_path=os.path.normpath(folder_path)\r\n if first4 in locals():\r\n # incorporate the excerpt of the filename\r\n dir_List=[f for f in os.scandir(folder_path) if f.is_file()==True and \r\n f.name[-len(ext):]==ext and f.name[:4]==first4] \r\n else:\r\n #do it without the excerpt\r\n dir_List=[f for f in os.scandir(folder_path) if f.is_file()==True and \r\n f.name[-len(ext):]==ext]\r\n \r\n return dir_List","def dir_fname(directory,nametype):\n\tfnames = directory+os.sep+nametype\n\tfnames = glob.glob(fnames)\n\tfnames = np.sort(fnames) # order files from 0 to last\n\treturn fnames","def listflat(path, ext=None):\n if os.path.isdir(path):\n if ext:\n files = glob.glob(os.path.join(path, '*.' + ext))\n else:\n files = [os.path.join(path, fname) for fname in os.listdir(path)]\n else:\n files = glob.glob(path)\n # filter out directories\n files = [fpath for fpath in files if not os.path.isdir(fpath)]\n return sorted(files)","def get_filestream(data_dir: str, ext: str) -> Iterable[str]:\n return listdir(data_dir) \\\n | where(lambda p: p.endswith(ext)) \\\n | select( lambda p: join(data_dir,p))","def __get_files_to_rename(self, directory):\n return [file for file in self.__get_files(directory, \"pdf\") if \"_compress_\" in file]","def batchfiles(fdir='.'):\n \n os.chdir(fdir)\n names = glob.iglob('*')\n # Absolute path rather than relative path allows changing of directories in fn_name.\n names = sorted([os.path.abspath(name) for name in names])\n return(names)","def list_all_exts(top_path, exts):\n if not top_path.endswith('/'):\n top_path += '/'\n ext_list = []\n for extension in exts:\n if not extension.startswith('.'):\n extension = '.' + extension\n ext_list.append(extension.lower())\n file_list = []\n for dirpath, dirnames, filenames in os.walk(top_path):\n for filename in filenames:\n if os.path.splitext(filename)[1].lower() in ext_list:\n file_list.append(os.path.join(dirpath, filename))\n return file_list","def get_filepaths(directory, suffix='.tsv'):\n for dir_ in Path(directory).glob('**'):\n if dir_.is_dir():\n yield [str(f) for f in dir_.glob('*') if f.is_file() and f.suffix == suffix]","def recursive_glob(rootdir='.', suffix=''):\n return [os.path.join(looproot, filename)\n for looproot, _, filenames in os.walk(rootdir)\n for filename in filenames if filename.endswith(suffix)]","def get_file_name_from_directory(file_dir):\n L = []\n for root, dirs, files in os.walk(file_dir):\n for file in files:\n if os.path.splitext(file):\n L.append(os.path.join(root, file))\n return L","def find_by_ext(dirname, ext):\n # Get all fasta-files\n try:\n files = os.listdir(dirname)\n except OSError:\n if os.path.exists(dirname):\n cmd = 'find {0} -maxdepth 1 -name \"*\"'.format(dirname)\n p = sp.Popen(cmd, shell=True, stdout=sp.PIPE, stderr=sp.PIPE)\n stdout, _stderr = p.communicate()\n files = [os.path.basename(fname) for fname in stdout.decode().splitlines()]\n else:\n raise\n\n retfiles = [\n os.path.join(dirname, fname)\n for fname in files\n if os.path.splitext(fname)[-1] in ext\n ]\n\n return retfiles","def list_pictures(directory, ext='jpg'):\r\n\r\n return [os.path.join(root, f)\r\n for root, _, files in os.walk(directory) for f in files\r\n if re.match(r'([\\w]+\\.(?:' + ext + '))', f)]","def get_files(dirs):\n for dir in dirs:\n for root, _, files in os.walk(dir):\n for file in files:\n path = Path(os.path.join(root, file))\n if path.suffix in EXTENSIONS:\n yield path","def organize_by_ext(current_path,extension):\n\tfor file in os.listdir(current_path):\n\t\text = extension\n\t\tif fnmatch.fnmatch(file,'*' + ext):\n\t\t click.secho(('Found File:{}'.format(file)),fg='blue')\n\t\t # If the file is truly a file...\n\t\t if os.path.isfile(file):\n\t\t try:\n\t\t # Make a directory with the extension name...\n\t\t new_dir = ext.strip(\".\")\n\t\t os.makedirs(new_dir)\n\t\t except:\n\t\t None\n\t\t # Copy that file to the directory with that extension name\n\t\t shutil.move(file,new_dir)\n\tclick.secho(('Finished Moving {} to:{} folder'.format(file,new_dir)),fg='green')","def find_files(path, extension):\n matches = []\n for root, dirnames, filenames in os.walk(path):\n for filename in fnmatch.filter(filenames, extension):\n matches.append(os.path.join(root, filename))\n return matches","def get_ordered_file_names(dir_path, suffix):\n\tfiles=os.listdir(dir_path)\n\n\t# extract the numbers from file names\n\tsorted_int=[]\n\tsorted_str=[]\n\ttemp=[]\n\tfor f in files:\n\t\ttemp=f.split('.')\n\t\tsorted_int.append(int(temp[0]))\n\tsorted_int.sort(key=int)\n\n\t# concatenate the full path after numerically sorting the files in the folder\n\tfor s in sorted_int:\n\t\ttemp=dir_path+str(s)+suffix\n\t\tsorted_str.append(temp)\n\n\treturn sorted_str","def findFiles(path, ext='txt'):\n if not os.path.exists(path):\n print 'no such directory: %s' %path\n return []\n files=[]\n for dirname, dirnames, filenames in os.walk(path):\n for f in filenames:\n name = os.path.join(dirname, f)\n if f.endswith(ext):\n files.append(name)\n return files","def get_files(root_dir, extension = \".tsv\"):\n fp_arr = []\n bn_arr = []\n for root, dirs, files in os.walk(root_dir):\n for fn in files:\n bn, ext = os.path.splitext(fn)\n if ext != extension:\n continue\n fp = os.path.join(root, fn)\n fp_arr.append(fp)\n bn_arr.append(bn)\n return fp_arr, bn_arr","def ls_json(directory):\n return_list = [\n f for f in os.listdir(directory) if f.endswith(\".json.gz\")\n ]\n return_list.sort()\n return return_list","def test_extensions(self):\n dummy_folder = TestOspaListDir.get_dummy_folder()\n need_result = []\n for i in range(1, 4):\n need_result.append(os.path.join(dummy_folder, 'memes', 'meme monty python', 'meme{}.jpg'.format(i)))\n need_result.append(os.path.join(dummy_folder, 'memes', 'meme1.jpg'))\n need_result.append(os.path.join(dummy_folder, 'memes', 'meme2.png'))\n need_result.append(os.path.join(dummy_folder, 'memes', 'meme4.jpg'))\n need_result.append(os.path.join(dummy_folder, 'memes', 'meme4.png'))\n\n for i in ['antigravity.png',\n 'egg.png',\n 'holy_grenade.png',\n 'spam.jpg',\n ]:\n need_result.append(os.path.join(dummy_folder, i))\n\n result = listdir(dummy_folder, full_path=True, only_files=True, walk=True, extensions=['jpg', 'png'])\n self.assertEqual(sorted(result), sorted(need_result))\n result = listdir(dummy_folder, full_path=True, only_files=True, walk=True, extensions=['.jpg', '.png'])\n self.assertEqual(sorted(result), sorted(need_result))\n result = listdir(dummy_folder, full_path=True, only_files=True, walk=True, extensions=['.JPG', 'png'])\n self.assertEqual(sorted(result), sorted(need_result))\n result = listdir(dummy_folder, full_path=True, only_files=True, walk=True, extensions=('.JPG', 'png'))\n self.assertEqual(sorted(result), sorted(need_result))\n result = listdir(dummy_folder, full_path=True, only_files=True, walk=True, extensions={'.JPG', 'png'})\n self.assertEqual(sorted(result), sorted(need_result))","def get_filenames(level, pattern=None, env='stage', ext='.fits.gz',\n iterator=True):\n if pattern is None:\n pattern = '*'\n else:\n pattern = '*' + pattern + '*'\n path = get_data_path(level, env)\n if not os.access(str(path), os.R_OK):\n raise PathNotReadableError(path)\n result = map(str, path.glob(pattern + ext))\n return result if iterator else list(result)","def get_all_json_files_in_dir(dirpath):\n files = []\n for file in os.listdir(dirpath):\n if file.endswith('.json'):\n files.append(os.path.join(dirpath, file))\n return files","def list_files(path):\n return list(sorted([f for f in os.listdir(path=path) if\n f.endswith('.json')]))","def get_reps_filenames(celltype): \n prefix = os.path.join(os.getcwd(),'peaks',celltype,'MACS2')\n reps = os.listdir(prefix)\n return [os.path.join(prefix,rep) for rep in reps if rep.endswith('sorted.bdg')]","def find_files(input_directory: str, extension: str):\n # Get all filenames under the directory\n file_paths_list = []\n for file_path in tqdm(Path(input_directory).glob(f'**/*{extension}')):\n file_paths_list.append(file_path)\n return file_paths_list","def getAllFileNames(self):\n #images = [\"image1.jpg\",\"image2.jpg\",\"image3.jpg\"]\n \n os.chdir(self.dataDir)\n filenames = glob.glob(\"*.*\")\n filenames.sort() \n return filenames","def find_files(suffix, path):\n \n\n files = []\n for file in os.listdir(path):\n filepath = os.path.join(path, file)\n if os.path.isfile(filepath):\n if file.endswith(suffix):\n files.append(filepath)\n else:\n rec_files = find_files(suffix, filepath)\n files.extend(rec_files)\n\n return files","def load_filenames_from_path(path: str, extension: str ='.bin') -> List[str]:\n sorted_filenames_list = []\n if(os.path.exists(path)):\n directory_list = load_directory_list_from_path(path)\n \n for directory in directory_list:\n filename_list = [filename for filename in os.listdir(os.path.join(path, directory))\n if (os.path.isfile(\n os.path.join(path, \n os.path.join(directory, filename)\n )) and extension in filename) ]\n \n filename_list = sort_list(filename_list)\n\n sorted_filenames_list += [os.path.join(path, os.path.join(directory, filename)) for filename in filename_list]\n else:\n raise FileNotFoundError\n \n return sorted_filenames_list","def read_all_file_names(path, extension, key=\"time\"):\n file_paths = glob.glob(path + '**/*' + extension, recursive=True)\n\n if key == 'time':\n return sorted(file_paths, key=time_key)\n \n elif key == 'natural':\n return sorted(file_paths, key=natural_key)","def splitext_zip(fname):\n base_fname, ext = splitext(fname)\n if ext == '.gz' or ext == '.zip':\n base_fname, ext2 = splitext(base_fname)\n ext = ''.join([ext2, ext])\n return base_fname, ext","def get_extension(filename: str) -> str:\n return Path(filename).suffix[1:]","def list_filenames(self):\n l = []\n for path, dirs, files in os.walk(self.archive_path):\n for file in files:\n l.append(os.path.relpath(os.path.join(path,file),self.archive_path))\n l.sort()\n return l","def recursive_glob(rootdir=\".\", suffix=\"\"):\n return [\n os.path.join(looproot, filename)\n for looproot, _, filenames in os.walk(rootdir)\n for filename in filenames\n if filename.endswith(suffix)\n ]"],"string":"[\n \"def get_file_names(path, extension='.json'):\\n fn = os.listdir(path)\\n l = []\\n for f in fn:\\n if f.endswith(extension, 4):\\n l.append(f)\\n l = sorted(l)\\n return l\",\n \"def list_all_files_with_extension(path, extension, do_unzip=True):\\n files = []\\n for file in os.listdir(path):\\n if file.endswith(extension):\\n files.append(file)\\n if do_unzip and file.endswith(\\\".zip\\\"):\\n new_path = unzip(os.path.join(path, file))\\n os.remove(os.path.join(path, file))\\n files = files + list_all_files_with_extension(new_path, extension)\\n # Dive into subfolders.\\n if os.path.isdir(os.path.join(path, file)):\\n files = files + list_all_files_with_extension(os.path.join(path, file), extension)\\n return files\",\n \"def get_path_files_with_ext(extension, directory):\\n\\n return [\\n directory + file_name for file_name in os.listdir(directory)\\n if file_name.endswith(extension)\\n ]\",\n \"def get_files(path, extension):\\n extension = listify(extension)\\n return [p for p in path.ls() if p.suffix in extension and \\\"(\\\" not in p.stem]\",\n \"def get_files(folder=\\\"\\\", extension=\\\"\\\"):\\n return sorted(glob.glob(folder + \\\"*\\\" + extension), reverse=True)\",\n \"def walk_files_with(extension, directory='.'):\\r\\n filelist = []\\r\\n for root, dirnames, filenames in os.walk(directory):\\r\\n for filename in filenames:\\r\\n if filename.lower().endswith('.' + extension):\\r\\n filelist.append(os.path.join(root, filename))\\r\\n return filelist\",\n \"def files_from_dir(dirname, exts=[\\\"obj\\\", \\\"h5\\\"]):\\n filenames = list()\\n for ext in exts:\\n ext_expr = os.path.join(dirname, f\\\"*.{ext}\\\")\\n filenames.extend(glob.glob(ext_expr))\\n\\n return sorted(filenames, key=os.path.basename)\",\n \"def getFiles(searchDir = './', extension = 'source'):\\n from glob import glob \\n\\n return glob(searchDir+'/*.'+extension)\",\n \"def getAllFilesWithExtension(directory,extension):\\n filesWithExtension = []\\n for root, dirs, files in os.walk(directory):\\n for file in files:\\n if file.endswith(extension):\\n filesWithExtension.append(os.path.realpath(os.path.join(root, file)))\\n return filesWithExtension\",\n \"def get_files_names_from_dir(directory: str, ext: str) -> List[str]:\\n files_names = [\\n file_name\\n for file_name in listdir(directory) if file_name.endswith(ext)\\n ]\\n files_names.sort()\\n return files_names\",\n \"def collect_files_with_extensions(self, extension: str) -> List[str]:\\n occurrences = []\\n for position in os.listdir(self.directory):\\n if os.path.isdir(position):\\n for file in os.listdir(position):\\n if os.path.isfile(os.path.join(position, file)) and file.endswith(\\n extension\\n ):\\n occurrences.append(os.path.join(self.directory, position, file))\\n return occurrences\",\n \"def list_files(directory, extension):\\n file_list = listdir(directory)\\n included_list = []\\n for f in file_list:\\n for ext in extension:\\n if f.endswith('.' + ext):\\n included_list.append(f)\\n break\\n return included_list\",\n \"def get_files(suffix):\\n lst = os.listdir(\\\".\\\")\\n return filter(lambda x: x.endswith(suffix), lst)\",\n \"def find_files(extensions):\\n\\n return [fname for fname in os.listdir('.') if fname.endswith(extensions)]\",\n \"def getFiles(directory, extension):\\n matches = []\\n for root, dirnames, filenames in os.walk(directory):\\n for filename in fnmatch.filter(filenames, '*.{0}'.format(extension)):\\n filepath = os.path.abspath(os.path.join(root, filename))\\n matches.append([filepath, os.path.getsize(os.path.join(root, filename))])\\n\\n #sort by size\\n #matches.sort(key=lambda filename: filename[1], reverse=False)\\n\\n matches = [x[0] for x in matches]\\n\\n return matches\",\n \"def get_all_files(directory, extension):\\n return (f for f in os.listdir(directory) if f.endswith(extension) and os.path.isfile(os.path.join(directory, f)))\",\n \"def get_gswe_paths(dirpath, extension = '.tif'):\\n\\n\\textension = '*' + extension\\n\\tpath = os.path.join(dirpath, extension)\\n\\tfile_path_list = glob.glob(path)\\n\\tfile_path_list.sort()\\n\\treturn file_path_list\",\n \"def get_all_compressed_files_in_directory(directory: str):\\n\\n all_files_and_folders = os.listdir(directory)\\n\\n only_compressed_files = []\\n for file in all_files_and_folders:\\n if '.zip' in file or '.7z' in file:\\n only_compressed_files.append(file)\\n ...\\n\\n return only_compressed_files\",\n \"def getListOfFiles(directory, extension):\\n allFiles = [f for f in os.listdir(directory) if\\n os.path.isfile(os.path.join(directory, f)) and f.endswith(extension)]\\n return allFiles\",\n \"def extract_filenames(folder, name=\\\"\\\", extension='pdb'):\\n\\n files = []\\n # Extract all the paths corresponding to the request\\n paths = glob.glob(folder + \\\"/\\\" + name + \\\"*.\\\" + extension)\\n\\n # Extract only the filenames (without parent folder path and extension) from each filename\\n for path in paths:\\n base = os.path.basename(path)\\n file = os.path.splitext(base)[0]\\n files.append(file)\\n\\n return sorted(files)\",\n \"def search_extension(path, ext):\\n output = []\\n for root, dirs, files in os.walk(path, topdown=True):\\n for file in files:\\n if file.endswith(ext):\\n path = os.path.join(root, file)\\n output.append(path)\\n\\n return output\",\n \"def get_files_with_extension(self, extension=sys.argv[1]) -> list:\\n if extension == \\\"\\\":\\n raise EnvironmentError(\\\"No extension provided!\\\")\\n\\n result = []\\n for idx, file in enumerate(self.file_list):\\n if re.search(extension + \\\"$\\\", file):\\n result.append(file)\\n\\n if len(result) == 0:\\n raise Exception(\\\"No {} files found.\\\".format(extension))\\n\\n return result\",\n \"def files_with_suffix(directory, suffix, pure=False):\\n files = [os.path.abspath(path) for path in glob.glob(os.path.join(directory, '**', f'*{suffix}'), recursive=True)]\\n if pure:\\n files = [os.path.split(file)[-1] for file in files]\\n return files\",\n \"def getFiles(directory, showName, extension):\\n os.chdir(directory)\\n \\n list = []\\n \\n for file in glob.glob(\\\"*\\\"+showName+\\\"*.\\\"+extension):\\n list.append(file)\\n \\n return list\",\n \"def listar_extension(dir_name, ext='.png'):\\n\\n list_ext = []\\n for root, dirs, files in os.walk(directorio):\\n for name in files:\\n if ext in name:\\n list_ext.append(name)\\n for name in dirs:\\n if ext in name:\\n list_ext.append(name)\\n\\n return list_ext\",\n \"def get_files(path: str, extension: str = '.wav') -> List[Path]:\\n\\n return list(Path(path).expanduser().resolve().rglob(f'*{extension}'))\",\n \"def _glob_files(directories, extensions):\\n pwd = Path(__file__).resolve().parent\\n open3d_root_dir = pwd.parent\\n\\n file_paths = []\\n for directory in directories:\\n directory = open3d_root_dir / directory\\n for extension in extensions:\\n extension_regex = \\\"*.\\\" + extension\\n file_paths.extend(directory.rglob(extension_regex))\\n file_paths = [str(file_path) for file_path in file_paths]\\n file_paths = sorted(list(set(file_paths)))\\n return file_paths\",\n \"def get_files(imagedir, ext='jpg|jpeg|bmp|png'):\\n rex = re.compile(r'^.*\\\\.({})$'.format(ext), re.I)\\n return [os.path.join(imagedir,base) for base in os.listdir(imagedir)\\n if rex.match(base)]\",\n \"def get_files(data_dir, extension):\\n files = []\\n if data_dir and os.path.exists(data_dir):\\n files = glob.glob(data_dir + \\\"/*.\\\" + extension)\\n return files\",\n \"def getFiles(directory):\\n # os.listdir only for locally downloaded files\\n _files=[]\\n for item in os.listdir(directory):\\n path = os.path.join(directory, item)\\n if not os.path.isdir(path) and \\\".lhe.gz\\\" in path:\\n _files.append(path)\\n elif os.path.isdir(path):\\n getFiles(path)\\n return _files\",\n \"def dir_search(ext, file_path='./'):\\n try:\\n return [file_path + \\\"/\\\" + file for file in os.listdir(file_path) if file.endswith(ext)]\\n except OSError as e:\\n logger.error(e)\\n return []\\n except Exception as e:\\n logger.error(e)\\n return []\",\n \"def get_file_extensions():\\n my_files_ext = []\\n for file in os.listdir(os.getcwd()):\\n if os.path.isfile(file):\\n file_info = os.path.splitext(file)\\n file_ext = file_info[1]\\n my_files_ext.append(file_ext)\\n return [file for file in my_files_ext]\",\n \"def dir_ftype(directory,extension):\\n\\textension = extension.replace(\\\".\\\",\\\"\\\") # make sure theres no \\\".\\\"\\n\\tfnames = directory+os.sep+\\\"*\\\"+\\\".\\\"+extension\\n\\tfnames = glob.glob(fnames)\\n\\tfnames = np.sort(fnames) # order files from 0 to last\\n\\treturn fnames\",\n \"def _package_files(directory: str, suffix: str) -> list:\\n\\n paths = []\\n\\n for (path, directories, filenames) in os.walk(directory):\\n for filename in filenames:\\n if filename.endswith(suffix):\\n paths.append(os.path.join('..', path, filename))\\n\\n return paths\",\n \"def __get_files(self, directory, file_extension):\\n path_spec = \\\"{}**/*.{}\\\" if self.__config.recursive() else \\\"{}*.{}\\\"\\n return glob.glob(path_spec.format(directory, file_extension), recursive=self.__config.recursive())\",\n \"def getFilenameList(path, pattern='*.nii.gz'):\\n\\n filename = [os.path.basename(x) for x in sorted(glob.glob(os.path.join(path, pattern)))]\\n\\n return filename\",\n \"def filter_files_by_extension(\\n files: list ,\\n extensions: list\\n):\\n filtered_files = []\\n for file in files:\\n file_ext = os.path.splitext(file)[-1].lower()\\n file_ext = _remove_dot_from_extension(file_ext)\\n for extension in extensions:\\n ext = _remove_dot_from_extension(extension).lower()\\n # print(\\\"ext \\\\n\\\", ext)\\n # print(\\\"file_ext \\\\n\\\", file_ext)\\n if file_ext == ext:\\n filtered_files.append(file)\\n\\n return filtered_files\\n ...\",\n \"def get_extensionless_filenames(path):\\n return [\\n filename.replace('.pdf', '')\\n for filename in os.listdir(path)\\n if isfile(join(path, filename))\\n ]\",\n \"def list_type_in_dir(path, extension):\\n path, extension = check_args(path, extension)\\n files = os.listdir(path)\\n file_list = [os.path.join(path, f)\\n for f in fnmatch.filter(files, '*' + extension)]\\n\\n return file_list\",\n \"def list_files(folder, number_of_files=None):\\n paths = glob.glob(folder + \\\"/*.gz\\\")\\n\\n if number_of_files is None:\\n return paths\\n else:\\n return paths[:number_of_files]\",\n \"def filelisting(directory, suffix = 'tcx'):\\n files = []\\n for f in os.listdir(directory):\\n fullpath = os.path.join(directory, f)\\n if os.path.isfile(fullpath) and f.endswith(suffix):\\n files.append(fullpath)\\n return files\",\n \"def find_files(directory, extensions):\\n res = set()\\n for filename in os.listdir(directory):\\n if filename.endswith(extensions):\\n res.add(\\\"{}/{}\\\".format(directory, filename))\\n return list(res)\",\n \"def zip_all(search_dir, extensions, output_path):\\r\\n with ZipFile(output_path, 'w') as zip_object:\\r\\n for folder, _, filenames in os.walk(search_dir):\\r\\n rel_path = os.path.relpath(folder, search_dir)\\r\\n for filename in filenames:\\r\\n if pathlib.Path(filename).suffix in extensions:\\r\\n zip_object.write(\\r\\n os.path.join(folder, filename),\\r\\n os.path.join(rel_path, filename)\\r\\n )\",\n \"def recursive_glob(self, rootdir='.', suffix=''):\\n return [os.path.join(rootdir, filename)\\n for filename in sorted(os.listdir(rootdir)) if filename.endswith(suffix)]\",\n \"def get_files_in_dir(dir, ext):\\n import os\\n\\n for root, dirs, files in os.walk(dir):\\n for file in files:\\n if file.split('.')[1].lower() == ext.lower() or not ext:\\n file_full_path = os.path.join(root, file)\\n yield file_full_path\",\n \"def create_file_list(path, extension='.png'):\\n file_list = []\\n for root, _, files in os.walk(path, topdown=False):\\n for name in files:\\n if name.endswith(extension):\\n full_name = os.path.join(root, name)\\n file_list.append(full_name)\\n\\n return file_list\",\n \"def load_filenames_from_directory(directory_path: str, extension: str='.bin') -> List[str]:\\n sorted_filenames_list = []\\n if(os.path.exists(directory_path)):\\n filename_list = [filename for filename in os.listdir(directory_path)\\n if (os.path.isfile(\\n os.path.join(directory_path, filename)\\n ) and extension in filename) ]\\n \\n filename_list = sort_list(filename_list, extension=extension)\\n\\n sorted_filenames_list += [os.path.join(directory_path, filename) for filename in filename_list]\\n else:\\n raise FileNotFoundError\\n \\n return sorted_filenames_list\\n\\n\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\",\n \"def get_files(self, extension, recurs=True):\\n if self._dirname is None:\\n return []\\n\\n if os.path.exists(self._dirname) is False:\\n raise NoDirectoryError(dirname=self._dirname)\\n\\n return sppasDirUtils.dir_entries(self._dirname, extension, recurs)\",\n \"def getFilenames(dir_path, remove_file_ext=False):\\n filename_list = []\\n \\n dir_obj = os.fsencode(dir_path)\\n for file in os.listdir(dir_obj):\\n filename = os.fsdecode(file)\\n if remove_file_ext: filename = os.path.splitext(filename)[0]\\n \\n file_path = os.path.join(dir_path, filename)\\n \\n if os.path.isdir(file_path) == False:\\n filename_list.append(filename)\\n \\n return filename_list\",\n \"def _extract_all_gz_in_dir(directory):\\n for file in os.listdir(directory):\\n if file.endswith(\\\".gz\\\"):\\n gz_fname = os.path.join(directory, file)\\n _extract_gz(gz_fname, os.path.dirname(gz_fname))\\n os.remove(gz_fname)\",\n \"def split_ext(filepath):\\n\\t(fn, ext) = os.path.splitext(filepath)\\n\\tif ext=='.gz':\\n\\t\\t(fn, ext) = os.path.splitext(fn)\\n\\t\\text += '.gz'\\n\\treturn (fn, ext)\",\n \"def get_filelist(import_path, extension):\\n filelist = []\\n for root, dirs, files in os.walk(import_path):\\n filelist += glob.glob(os.path.join(root, '*.' + extension))\\n return filelist\",\n \"def get_files_from_of_type(path: str, ext: str) -> List[str]:\\n files = []\\n for root, dirnames, filenames in os.walk(path):\\n for filename in fnmatch.filter(filenames, \\\"*.\\\" + str(ext)):\\n files.append(os.path.join(root, filename))\\n if not files:\\n logging.error(\\\"No language files found in folder: \\\" + str(os.sep.join([convert_vars.BASE_PATH, \\\"source\\\"])))\\n logging.debug(f\\\" --- found {len(files)} files of type {ext}. Showing first few:\\\\n* \\\" + str(\\\"\\\\n* \\\".join(files[:3])))\\n return files\",\n \"def find_specific_file_extension_in_dir(dir_path, extension):\\r\\n return glob.glob(os.path.join(dir_path, r'*{}'.format(extension)))[0].replace('\\\\\\\\', '/').split('/')[-1]\",\n \"def get_sorted_filenames_in_dir_with_suffix(dir_path: str, suffix: (str, list)):\\n if isinstance(suffix, str):\\n suffix = [suffix]\\n\\n paths = []\\n for s in suffix:\\n paths += glob.glob(os.path.join(dir_path, \\\"**\\\", \\\"*.\\\" + s), recursive=True)\\n return sorted(paths)\",\n \"def test_get_filenames_by_ext():\\n tmpdir = os.path.join(tempfile.gettempdir(), \\\"jade-test-tmp87alkj8ew\\\")\\n os.makedirs(tmpdir, exist_ok=True)\\n\\n data = {\\\"A\\\": 1, \\\"B\\\": 2}\\n json_file = os.path.join(tmpdir, \\\"a.json\\\")\\n dump_data(data, json_file)\\n\\n toml_file = os.path.join(tmpdir, \\\"b.toml\\\")\\n dump_data(data, toml_file)\\n\\n filenames = get_filenames_by_ext(tmpdir, \\\".json\\\")\\n assert \\\"a.json\\\" in next(filenames)\\n\\n filenames = get_filenames_by_ext(tmpdir, \\\".toml\\\")\\n assert \\\"b.toml\\\" in next(filenames)\",\n \"def list_all_files(\\n dir_path: str = \\\"./domain\\\", ext: str = \\\".py\\\", excludes=None, includes=None, return_base_name=False\\n) -> List[str]:\\n files = []\\n for entry in os.scandir(dir_path):\\n if entry.is_dir():\\n files += list_all_files(entry.path, ext=ext, excludes=excludes, return_base_name=return_base_name)\\n elif entry.is_file():\\n if not ext or (ext and entry.path.endswith(ext)):\\n if excludes and entry.path.endswith(excludes):\\n continue\\n if includes and not entry.path.endswith(includes):\\n continue\\n if return_base_name:\\n files.append(os.path.basename(entry.path))\\n else:\\n files.append(entry.path)\\n else:\\n pass\\n return files\",\n \"def _collect_files(folders, extention='Default'):\\r\\n if isinstance(extention, str):\\r\\n if extention.lower() == 'default':\\r\\n extention = ['.*']\\r\\n else:\\r\\n extention = [extention]\\r\\n files = []\\r\\n for f in folders:\\r\\n for e in extention:\\r\\n files += glob(os.path.join(f, f'*{e}'))\\r\\n return files\",\n \"def list_files(file, folder, extension = '*.evtx'):\\r\\n if file:\\r\\n return [file]\\r\\n elif folder:\\r\\n return [ y for x in os.walk(folder) for y in glob(os.path.join(x[0], extension))]\\r\\n else:\\r\\n return []\",\n \"def get_files_from_folder(input_dir, extensions=None):\\n output = []\\n if extensions is None:\\n extensions = [\\\"\\\"]\\n elif not isinstance(extensions, (tuple, list)):\\n extensions = [extensions]\\n\\n for ext in extensions:\\n files = Path(input_dir).rglob(\\\"*{}\\\".format(ext))\\n output.extend([f.as_posix() for f in files if f.is_file()])\\n\\n return output\",\n \"def find_files_by_extensions(cls, search_path, allowed_ext):\\n file_list = []\\n for root, dirnames, filenames in os.walk(search_path):\\n for filename in filenames:\\n name, extension = os.path.splitext(filename)\\n if extension in allowed_ext:\\n file_list.append(os.path.join(root, filename))\\n\\n return file_list\",\n \"def recursive_glob(rootdir=\\\".\\\", suffix=\\\".tif\\\"):\\r\\n return [\\r\\n os.path.join(looproot,filename)\\r\\n for looproot, _, filenames in os.walk(rootdir)\\r\\n for filename in filenames\\r\\n if filename.endswith(suffix)\\r\\n ]\",\n \"def get_file_paths(dir, ext):\\n files = []\\n for root, dirs, filenames in os.walk(dir):\\n for filename in filenames:\\n if filename.endswith(ext):\\n files.append(os.path.join(root, filename))\\n return files\",\n \"def list_a_file_type(path, extension):\\n path, extension = check_args(path, extension)\\n file_list = [os.path.join(dirpath, f)\\n for dirpath, dirnames, files in os.walk(path)\\n for f in fnmatch.filter(files, '*' + extension)]\\n\\n return file_list\",\n \"def get_files_from_directory(directory):\\n file_list = []\\n for root, dirs, files in os.walk(directory.replace('/', '\\\\\\\\'), topdown=False):\\n for name in files:\\n if os.path.splitext(name)[1] in supported_extensions:\\n file_list.append(os.path.join(root, name))\\n return file_list\",\n \"def namelist(self):\\n\\n # try to create a name from the archive name\\n # because a gzipped file doesn't have information about the\\n # original filename\\n # gzipping a file creates the archive name by appending \\\".gz\\\"\\n genericfilename = self._archivename\\n\\n if not genericfilename:\\n genericfilename = \\\"generic.unknown.gz\\\"\\n\\n try:\\n # get list of file extensions\\n fileendinglist = Archivehandle.avail_archive_extensionlist4type['gz']\\n replacedict = {\\\"wmz\\\": \\\"wmf\\\",\\n \\\"emz\\\": \\\"emf\\\"}\\n for ending in fileendinglist:\\n endingwithdot = \\\".\\\"+ending\\n if genericfilename.endswith(endingwithdot):\\n if ending in replacedict:\\n genericfilename = genericfilename[:-len(ending)]+replacedict[ending]\\n else:\\n genericfilename = genericfilename[:-len(endingwithdot)]\\n break\\n\\n except Exception as e:\\n print(e)\\n pass\\n return [genericfilename]\",\n \"def list_pictures(directory, ext='JPEG'):\\n return [os.path.join(root, f)\\n for root, _, files in os.walk(directory) for f in files\\n if re.match(r'([\\\\w]+\\\\.(?:' + ext + '))', f)]\",\n \"def grab_files(folder_path, ext='.h5', first4=None):\\r\\n folder_path=os.path.normpath(folder_path)\\r\\n if first4 in locals():\\r\\n # incorporate the excerpt of the filename\\r\\n dir_List=[f for f in os.scandir(folder_path) if f.is_file()==True and \\r\\n f.name[-len(ext):]==ext and f.name[:4]==first4] \\r\\n else:\\r\\n #do it without the excerpt\\r\\n dir_List=[f for f in os.scandir(folder_path) if f.is_file()==True and \\r\\n f.name[-len(ext):]==ext]\\r\\n \\r\\n return dir_List\",\n \"def dir_fname(directory,nametype):\\n\\tfnames = directory+os.sep+nametype\\n\\tfnames = glob.glob(fnames)\\n\\tfnames = np.sort(fnames) # order files from 0 to last\\n\\treturn fnames\",\n \"def listflat(path, ext=None):\\n if os.path.isdir(path):\\n if ext:\\n files = glob.glob(os.path.join(path, '*.' + ext))\\n else:\\n files = [os.path.join(path, fname) for fname in os.listdir(path)]\\n else:\\n files = glob.glob(path)\\n # filter out directories\\n files = [fpath for fpath in files if not os.path.isdir(fpath)]\\n return sorted(files)\",\n \"def get_filestream(data_dir: str, ext: str) -> Iterable[str]:\\n return listdir(data_dir) \\\\\\n | where(lambda p: p.endswith(ext)) \\\\\\n | select( lambda p: join(data_dir,p))\",\n \"def __get_files_to_rename(self, directory):\\n return [file for file in self.__get_files(directory, \\\"pdf\\\") if \\\"_compress_\\\" in file]\",\n \"def batchfiles(fdir='.'):\\n \\n os.chdir(fdir)\\n names = glob.iglob('*')\\n # Absolute path rather than relative path allows changing of directories in fn_name.\\n names = sorted([os.path.abspath(name) for name in names])\\n return(names)\",\n \"def list_all_exts(top_path, exts):\\n if not top_path.endswith('/'):\\n top_path += '/'\\n ext_list = []\\n for extension in exts:\\n if not extension.startswith('.'):\\n extension = '.' + extension\\n ext_list.append(extension.lower())\\n file_list = []\\n for dirpath, dirnames, filenames in os.walk(top_path):\\n for filename in filenames:\\n if os.path.splitext(filename)[1].lower() in ext_list:\\n file_list.append(os.path.join(dirpath, filename))\\n return file_list\",\n \"def get_filepaths(directory, suffix='.tsv'):\\n for dir_ in Path(directory).glob('**'):\\n if dir_.is_dir():\\n yield [str(f) for f in dir_.glob('*') if f.is_file() and f.suffix == suffix]\",\n \"def recursive_glob(rootdir='.', suffix=''):\\n return [os.path.join(looproot, filename)\\n for looproot, _, filenames in os.walk(rootdir)\\n for filename in filenames if filename.endswith(suffix)]\",\n \"def get_file_name_from_directory(file_dir):\\n L = []\\n for root, dirs, files in os.walk(file_dir):\\n for file in files:\\n if os.path.splitext(file):\\n L.append(os.path.join(root, file))\\n return L\",\n \"def find_by_ext(dirname, ext):\\n # Get all fasta-files\\n try:\\n files = os.listdir(dirname)\\n except OSError:\\n if os.path.exists(dirname):\\n cmd = 'find {0} -maxdepth 1 -name \\\"*\\\"'.format(dirname)\\n p = sp.Popen(cmd, shell=True, stdout=sp.PIPE, stderr=sp.PIPE)\\n stdout, _stderr = p.communicate()\\n files = [os.path.basename(fname) for fname in stdout.decode().splitlines()]\\n else:\\n raise\\n\\n retfiles = [\\n os.path.join(dirname, fname)\\n for fname in files\\n if os.path.splitext(fname)[-1] in ext\\n ]\\n\\n return retfiles\",\n \"def list_pictures(directory, ext='jpg'):\\r\\n\\r\\n return [os.path.join(root, f)\\r\\n for root, _, files in os.walk(directory) for f in files\\r\\n if re.match(r'([\\\\w]+\\\\.(?:' + ext + '))', f)]\",\n \"def get_files(dirs):\\n for dir in dirs:\\n for root, _, files in os.walk(dir):\\n for file in files:\\n path = Path(os.path.join(root, file))\\n if path.suffix in EXTENSIONS:\\n yield path\",\n \"def organize_by_ext(current_path,extension):\\n\\tfor file in os.listdir(current_path):\\n\\t\\text = extension\\n\\t\\tif fnmatch.fnmatch(file,'*' + ext):\\n\\t\\t click.secho(('Found File:{}'.format(file)),fg='blue')\\n\\t\\t # If the file is truly a file...\\n\\t\\t if os.path.isfile(file):\\n\\t\\t try:\\n\\t\\t # Make a directory with the extension name...\\n\\t\\t new_dir = ext.strip(\\\".\\\")\\n\\t\\t os.makedirs(new_dir)\\n\\t\\t except:\\n\\t\\t None\\n\\t\\t # Copy that file to the directory with that extension name\\n\\t\\t shutil.move(file,new_dir)\\n\\tclick.secho(('Finished Moving {} to:{} folder'.format(file,new_dir)),fg='green')\",\n \"def find_files(path, extension):\\n matches = []\\n for root, dirnames, filenames in os.walk(path):\\n for filename in fnmatch.filter(filenames, extension):\\n matches.append(os.path.join(root, filename))\\n return matches\",\n \"def get_ordered_file_names(dir_path, suffix):\\n\\tfiles=os.listdir(dir_path)\\n\\n\\t# extract the numbers from file names\\n\\tsorted_int=[]\\n\\tsorted_str=[]\\n\\ttemp=[]\\n\\tfor f in files:\\n\\t\\ttemp=f.split('.')\\n\\t\\tsorted_int.append(int(temp[0]))\\n\\tsorted_int.sort(key=int)\\n\\n\\t# concatenate the full path after numerically sorting the files in the folder\\n\\tfor s in sorted_int:\\n\\t\\ttemp=dir_path+str(s)+suffix\\n\\t\\tsorted_str.append(temp)\\n\\n\\treturn sorted_str\",\n \"def findFiles(path, ext='txt'):\\n if not os.path.exists(path):\\n print 'no such directory: %s' %path\\n return []\\n files=[]\\n for dirname, dirnames, filenames in os.walk(path):\\n for f in filenames:\\n name = os.path.join(dirname, f)\\n if f.endswith(ext):\\n files.append(name)\\n return files\",\n \"def get_files(root_dir, extension = \\\".tsv\\\"):\\n fp_arr = []\\n bn_arr = []\\n for root, dirs, files in os.walk(root_dir):\\n for fn in files:\\n bn, ext = os.path.splitext(fn)\\n if ext != extension:\\n continue\\n fp = os.path.join(root, fn)\\n fp_arr.append(fp)\\n bn_arr.append(bn)\\n return fp_arr, bn_arr\",\n \"def ls_json(directory):\\n return_list = [\\n f for f in os.listdir(directory) if f.endswith(\\\".json.gz\\\")\\n ]\\n return_list.sort()\\n return return_list\",\n \"def test_extensions(self):\\n dummy_folder = TestOspaListDir.get_dummy_folder()\\n need_result = []\\n for i in range(1, 4):\\n need_result.append(os.path.join(dummy_folder, 'memes', 'meme monty python', 'meme{}.jpg'.format(i)))\\n need_result.append(os.path.join(dummy_folder, 'memes', 'meme1.jpg'))\\n need_result.append(os.path.join(dummy_folder, 'memes', 'meme2.png'))\\n need_result.append(os.path.join(dummy_folder, 'memes', 'meme4.jpg'))\\n need_result.append(os.path.join(dummy_folder, 'memes', 'meme4.png'))\\n\\n for i in ['antigravity.png',\\n 'egg.png',\\n 'holy_grenade.png',\\n 'spam.jpg',\\n ]:\\n need_result.append(os.path.join(dummy_folder, i))\\n\\n result = listdir(dummy_folder, full_path=True, only_files=True, walk=True, extensions=['jpg', 'png'])\\n self.assertEqual(sorted(result), sorted(need_result))\\n result = listdir(dummy_folder, full_path=True, only_files=True, walk=True, extensions=['.jpg', '.png'])\\n self.assertEqual(sorted(result), sorted(need_result))\\n result = listdir(dummy_folder, full_path=True, only_files=True, walk=True, extensions=['.JPG', 'png'])\\n self.assertEqual(sorted(result), sorted(need_result))\\n result = listdir(dummy_folder, full_path=True, only_files=True, walk=True, extensions=('.JPG', 'png'))\\n self.assertEqual(sorted(result), sorted(need_result))\\n result = listdir(dummy_folder, full_path=True, only_files=True, walk=True, extensions={'.JPG', 'png'})\\n self.assertEqual(sorted(result), sorted(need_result))\",\n \"def get_filenames(level, pattern=None, env='stage', ext='.fits.gz',\\n iterator=True):\\n if pattern is None:\\n pattern = '*'\\n else:\\n pattern = '*' + pattern + '*'\\n path = get_data_path(level, env)\\n if not os.access(str(path), os.R_OK):\\n raise PathNotReadableError(path)\\n result = map(str, path.glob(pattern + ext))\\n return result if iterator else list(result)\",\n \"def get_all_json_files_in_dir(dirpath):\\n files = []\\n for file in os.listdir(dirpath):\\n if file.endswith('.json'):\\n files.append(os.path.join(dirpath, file))\\n return files\",\n \"def list_files(path):\\n return list(sorted([f for f in os.listdir(path=path) if\\n f.endswith('.json')]))\",\n \"def get_reps_filenames(celltype): \\n prefix = os.path.join(os.getcwd(),'peaks',celltype,'MACS2')\\n reps = os.listdir(prefix)\\n return [os.path.join(prefix,rep) for rep in reps if rep.endswith('sorted.bdg')]\",\n \"def find_files(input_directory: str, extension: str):\\n # Get all filenames under the directory\\n file_paths_list = []\\n for file_path in tqdm(Path(input_directory).glob(f'**/*{extension}')):\\n file_paths_list.append(file_path)\\n return file_paths_list\",\n \"def getAllFileNames(self):\\n #images = [\\\"image1.jpg\\\",\\\"image2.jpg\\\",\\\"image3.jpg\\\"]\\n \\n os.chdir(self.dataDir)\\n filenames = glob.glob(\\\"*.*\\\")\\n filenames.sort() \\n return filenames\",\n \"def find_files(suffix, path):\\n \\n\\n files = []\\n for file in os.listdir(path):\\n filepath = os.path.join(path, file)\\n if os.path.isfile(filepath):\\n if file.endswith(suffix):\\n files.append(filepath)\\n else:\\n rec_files = find_files(suffix, filepath)\\n files.extend(rec_files)\\n\\n return files\",\n \"def load_filenames_from_path(path: str, extension: str ='.bin') -> List[str]:\\n sorted_filenames_list = []\\n if(os.path.exists(path)):\\n directory_list = load_directory_list_from_path(path)\\n \\n for directory in directory_list:\\n filename_list = [filename for filename in os.listdir(os.path.join(path, directory))\\n if (os.path.isfile(\\n os.path.join(path, \\n os.path.join(directory, filename)\\n )) and extension in filename) ]\\n \\n filename_list = sort_list(filename_list)\\n\\n sorted_filenames_list += [os.path.join(path, os.path.join(directory, filename)) for filename in filename_list]\\n else:\\n raise FileNotFoundError\\n \\n return sorted_filenames_list\",\n \"def read_all_file_names(path, extension, key=\\\"time\\\"):\\n file_paths = glob.glob(path + '**/*' + extension, recursive=True)\\n\\n if key == 'time':\\n return sorted(file_paths, key=time_key)\\n \\n elif key == 'natural':\\n return sorted(file_paths, key=natural_key)\",\n \"def splitext_zip(fname):\\n base_fname, ext = splitext(fname)\\n if ext == '.gz' or ext == '.zip':\\n base_fname, ext2 = splitext(base_fname)\\n ext = ''.join([ext2, ext])\\n return base_fname, ext\",\n \"def get_extension(filename: str) -> str:\\n return Path(filename).suffix[1:]\",\n \"def list_filenames(self):\\n l = []\\n for path, dirs, files in os.walk(self.archive_path):\\n for file in files:\\n l.append(os.path.relpath(os.path.join(path,file),self.archive_path))\\n l.sort()\\n return l\",\n \"def recursive_glob(rootdir=\\\".\\\", suffix=\\\"\\\"):\\n return [\\n os.path.join(looproot, filename)\\n for looproot, _, filenames in os.walk(rootdir)\\n for filename in filenames\\n if filename.endswith(suffix)\\n ]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7269909","0.71443665","0.71007","0.6931686","0.68851805","0.68763983","0.6823714","0.67866296","0.67852724","0.6752004","0.6724506","0.6646473","0.6645157","0.66420186","0.6624232","0.6605461","0.65348715","0.65346175","0.6510529","0.64909226","0.6480302","0.64490163","0.6429176","0.64225453","0.64216024","0.6407706","0.6393943","0.63892406","0.6371471","0.6368342","0.63513875","0.6349818","0.63446087","0.6341376","0.633758","0.6319953","0.6319475","0.6279485","0.62751484","0.62412286","0.62094724","0.61924016","0.61861676","0.6169533","0.6160685","0.61405647","0.6133677","0.6110408","0.6104494","0.60901123","0.6082364","0.6065261","0.6057923","0.6040349","0.6018533","0.6016595","0.60107476","0.59871316","0.5975841","0.59687626","0.59683496","0.5946413","0.5939296","0.59262353","0.5920621","0.59125096","0.59099233","0.5909441","0.590905","0.5907908","0.58973145","0.5888777","0.5888573","0.58882135","0.5886613","0.5885672","0.58780533","0.58646274","0.58502626","0.5848664","0.58465874","0.58435804","0.5831967","0.5827311","0.58251184","0.5821912","0.58202714","0.58117783","0.5805507","0.5801694","0.57891846","0.5784611","0.5782961","0.57773066","0.5776279","0.57447803","0.574017","0.5739548","0.5733527","0.57314503"],"string":"[\n \"0.7269909\",\n \"0.71443665\",\n \"0.71007\",\n \"0.6931686\",\n \"0.68851805\",\n \"0.68763983\",\n \"0.6823714\",\n \"0.67866296\",\n \"0.67852724\",\n \"0.6752004\",\n \"0.6724506\",\n \"0.6646473\",\n \"0.6645157\",\n \"0.66420186\",\n \"0.6624232\",\n \"0.6605461\",\n \"0.65348715\",\n \"0.65346175\",\n \"0.6510529\",\n \"0.64909226\",\n \"0.6480302\",\n \"0.64490163\",\n \"0.6429176\",\n \"0.64225453\",\n \"0.64216024\",\n \"0.6407706\",\n \"0.6393943\",\n \"0.63892406\",\n \"0.6371471\",\n \"0.6368342\",\n \"0.63513875\",\n \"0.6349818\",\n \"0.63446087\",\n \"0.6341376\",\n \"0.633758\",\n \"0.6319953\",\n \"0.6319475\",\n \"0.6279485\",\n \"0.62751484\",\n \"0.62412286\",\n \"0.62094724\",\n \"0.61924016\",\n \"0.61861676\",\n \"0.6169533\",\n \"0.6160685\",\n \"0.61405647\",\n \"0.6133677\",\n \"0.6110408\",\n \"0.6104494\",\n \"0.60901123\",\n \"0.6082364\",\n \"0.6065261\",\n \"0.6057923\",\n \"0.6040349\",\n \"0.6018533\",\n \"0.6016595\",\n \"0.60107476\",\n \"0.59871316\",\n \"0.5975841\",\n \"0.59687626\",\n \"0.59683496\",\n \"0.5946413\",\n \"0.5939296\",\n \"0.59262353\",\n \"0.5920621\",\n \"0.59125096\",\n \"0.59099233\",\n \"0.5909441\",\n \"0.590905\",\n \"0.5907908\",\n \"0.58973145\",\n \"0.5888777\",\n \"0.5888573\",\n \"0.58882135\",\n \"0.5886613\",\n \"0.5885672\",\n \"0.58780533\",\n \"0.58646274\",\n \"0.58502626\",\n \"0.5848664\",\n \"0.58465874\",\n \"0.58435804\",\n \"0.5831967\",\n \"0.5827311\",\n \"0.58251184\",\n \"0.5821912\",\n \"0.58202714\",\n \"0.58117783\",\n \"0.5805507\",\n \"0.5801694\",\n \"0.57891846\",\n \"0.5784611\",\n \"0.5782961\",\n \"0.57773066\",\n \"0.5776279\",\n \"0.57447803\",\n \"0.574017\",\n \"0.5739548\",\n \"0.5733527\",\n \"0.57314503\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77469283"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83192,"cells":{"query":{"kind":"string","value":"filter a Fasta using the regex function."},"document":{"kind":"string","value":"def _apply_fasta_regex_func(infa, regex_func, outfa=None):\n # move the original file to a tmp folder\n out_dir = os.path.dirname(infa)\n tmp_dir = mkdtemp(dir=out_dir)\n old_fname = os.path.join(tmp_dir, \"original\") if outfa is None else infa\n new_fname = os.path.join(tmp_dir, \"filtered\")\n shutil.move(infa, old_fname)\n\n # perform the filtering\n excluded_contigs = []\n keep_contig = True\n with open(old_fname) as old, open(new_fname, \"w\") as new:\n for line in tqdm(old, desc=\"Filtering Fasta\", unit_scale=1, unit=\" lines\"):\n if line[0] == \">\":\n keep_contig = regex_func(line)\n if keep_contig is False:\n excluded_contigs.append(line[1:].split(\" \")[0].strip())\n if keep_contig:\n new.write(line)\n\n # move the filtered file to the original folder\n shutil.move(new_fname, outfa if outfa else infa)\n rm_rf(tmp_dir)\n\n return excluded_contigs"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def filter_fasta(\n infa: str,\n outfa: str = None,\n regex: str = \".*\",\n invert_match: Optional[bool] = False,\n) -> list:\n pattern = re.compile(regex)\n\n def keep(header):\n return bool(pattern.search(header)) is not invert_match\n\n return _apply_fasta_regex_func(infa, keep, outfa)","def filterRansac():\n pass","def filt(seq, lst):\n regex = \"(\" + \")|(\".join(seq) + \")\"\n regex = re.compile(regex)\n slst = list(filter(regex.search, lst))\n return slst\n\n\n # still need a checkUsername function ","def test_filter_fasta(self):\r\n input_seqs = [('Seq1 some comment', 'ACCTTGG'),\r\n ('s2 some other comment', 'TTGG'),\r\n ('S3', 'AAGGCCGG'),\r\n ('S5 some comment', 'CGT'),\r\n ('seq6 some other comment', 'AA'),\r\n ('S7', 'T')]\r\n seqs_to_keep = {}.fromkeys(['Seq1',\r\n 's2 some other comment',\r\n 'S3 no comment'])\r\n\r\n actual = fake_output_f()\r\n filter_fasta(input_seqs,\r\n actual,\r\n seqs_to_keep,\r\n negate=False)\r\n self.assertEqual(actual.s, self.filter_fasta_expected1)\r\n\r\n actual = fake_output_f()\r\n filter_fasta(input_seqs,\r\n actual,\r\n seqs_to_keep,\r\n negate=True)\r\n self.assertEqual(actual.s, self.filter_fasta_expected2)","def __filter( self, text ):\n return text","def filter_by_regex(self, dictlist, fidname, regex, outputfidlist=[]):\n result = [item for item in dictlist if re.match(regex, item[fidname]) != None]\n return self.filter_output(result, outputfidlist)","def filter_nmt_file(filename,filter_fn=None):\r\n \r\n if filter_fn is None:\r\n filter_fn = lambda en : en.lower().startswith('i am') or \\\r\n en.lower().startswith('he is') or \\\r\n en.lower().startswith('she is') or \\\r\n en.lower().startswith('they are') or \\\r\n en.lower().startswith('you are') or \\\r\n en.lower().startswith('we are')\r\n \r\n filtered_lines = []\r\n with open(filename) as file:\r\n lines = file.readlines()\r\n for line in lines:\r\n text = line.split('\\t')\r\n en = text[0]\r\n fra = text[1]\r\n if filter_fn(en):\r\n filtered_lines.append(en.lower() + '\\t' + fra.lower())\r\n\r\n return filtered_lines","def filter(self, fn):\r\n\t\treturn FilterProjectedList(self, [fn])","def filter(self, ffun):\n # BEGIN\n lst = []\n for item in WordSet(self.text).words():\n # if len(item) == len(ffun):\n # lst.append(item)\n if ffun(item) == True:\n lst.append(item)\n return lst\n\n # END","def transfer_filter(s, reg_exps, verbose=False):\n # Default: no match is found\n match = None\n\n # Reformat string to lowercase without new line characters\n s = s.replace('\\n', ' ').lower()\n\n # See if a match can be found with the unpredictable transfer filter regex\n match = reg_exps['re_trans_filter'].search(s)\n\n return match","def filter_text(self, text):\n yield from map(self._filter,\n (m.group(0) for m in re.finditer(self.pattern, text)))","def match(self, *args):\n return _ida_hexrays.microcode_filter_t_match(self, *args)","def _filter(self, minLength=None, maxLength=None, removeGaps=False,\n whitelist=None, blacklist=None,\n titleRegex=None, negativeTitleRegex=None,\n truncateTitlesAfter=None, indices=None, head=None,\n removeDuplicates=False, modifier=None):\n if (whitelist or blacklist or titleRegex or negativeTitleRegex or\n truncateTitlesAfter):\n titleFilter = TitleFilter(\n whitelist=whitelist, blacklist=blacklist,\n positiveRegex=titleRegex, negativeRegex=negativeTitleRegex,\n truncateAfter=truncateTitlesAfter)\n else:\n titleFilter = None\n\n if removeDuplicates:\n sequencesSeen = set()\n\n for readIndex, read in enumerate(self):\n\n if head is not None and readIndex == head:\n # We're completely done.\n return\n\n readLen = len(read)\n if ((minLength is not None and readLen < minLength) or\n (maxLength is not None and readLen > maxLength)):\n continue\n\n if removeGaps:\n sequence = read.sequence.replace('-', '')\n read = read.__class__(read.id, sequence, read.quality)\n\n if (titleFilter and\n titleFilter.accept(read.id) == TitleFilter.REJECT):\n continue\n\n if indices is not None and readIndex not in indices:\n continue\n\n if removeDuplicates:\n if read.sequence in sequencesSeen:\n continue\n sequencesSeen.add(read.sequence)\n\n if modifier:\n modified = modifier(read)\n if modified is None:\n continue\n else:\n read = modified\n\n yield read","def filter(self, function):\n return FunctionalWrapper(filter(function, self.data))","def filter_macro(out, scope, args, children):\n len(args) == 2 or syntax_error(\"'filter' macro takes exactly 2 arguments.\")\n regex, l = args\n if not isinstance(l, list):\n syntax_error(\"Invalid list in 'filter' macro: '%s'\" % str(list))\n if not isinstance(regex, str):\n syntax_error(\"Invalid regex in 'filter' macro: '%s'\" % str(regex))\n def match(s):\n return re.search(regex, s)\n return list(filter(match, l))","def filter(self, pattern):\n if isinstance(pattern, REGEX_TYPE):\n func = tools.filter_regex\n elif pattern.startswith('/'):\n pattern = re.compile(pattern.strip('/'))\n func = tools.filter_regex\n else:\n func = tools.filter_wildcard\n\n return SeeResult(func(self, pattern))","def filt(rec):\n return True # Show everything","def filter(self, filters):","def filter(self, *args):\n exps = []\n\n #this ones can be improved. some are not getting extracted\n if \"retweets\" in args:\n exps.append(re.compile(\"^RT ?(?<=^|(?<=[^a-zA-Z0-9-_\\.]))@([A-Za-z]+[A-Za-z0-9-_]+):\"))\n if \"emoticons\" in args:\n exps.append(\"emoticons\")\n if \"flags\" in args:\n exps.append(re.compile(u\"[\\U0001F1E6-\\U0001F1FF]\"))\n if \"handles\" in args:\n # Handles at start of string\n exps.append(re.compile(\"^\\s*((?<=^|(?<=[^\\S]))@([\\S]+)\\s*)*\"))\n # Handles at end of string\n exps.append(re.compile(\"\\s+((?<=^|(?<=[^\\S]))@(\\S+)\\s*)*$\"))\n if \"urls\" in args:\n exps.append(re.compile(\"(https?|ftp)://[^\\s/$.?#].[^\\s]*\"))\n if \"hashtags\" in args:\n # Hastags at start of string\n exps.append(re.compile(\"^\\s*((?<=^|(?<=[^\\S]))#([\\S]+)\\s*)*\"))\n # Hashtags at end of string\n exps.append(re.compile(\"\\s+((?<=^|(?<=[^\\S]))#(\\S+)\\s*)*$\"))\n\n\n # Use all filters\n if \"*\" in args and not exps:\n return self.filter(\"retweets\", \"emoticons\", \"flags\", \"handles\", \"urls\", \"hashtags\")\n\n filtering_text = self.raw_text\n\n for expression in exps:\n if expression == \"emoticons\":\n filtering_text = ''.join(c for c in filtering_text if c not in emoji.UNICODE_EMOJI)\n else:\n filtering_text = re.sub(expression, \"\", filtering_text)\n\n # Remove extra spaces\n self.clean_text = re.sub(r\"\\s\\s+\", ' ', filtering_text.strip())\n return self.clean_text","def search(self, filtro):\n return [nota for nota in self.notas if nota.match(filtro)]","def filter_fasta_fp(input_seqs_fp, output_seqs_fp, seqs_to_keep, negate=False):\r\n input_seqs = parse_fasta(open(input_seqs_fp, 'U'))\r\n output_f = open(output_seqs_fp, 'w')\r\n return filter_fasta(input_seqs, output_f, seqs_to_keep, negate)","def filter_ignoring_case(self, pattern):\n return self.filter(re.compile(pattern, re.I))","def ft_filter(fnct, tab):\n res = []\n for i in tab:\n if fnct:\n if fnct(i):\n res.append(i)\n else:\n if i:\n res.append(i)\n return res","def filter_on_regexp(strings, pattern):\n filtered_strings = filter(lambda x: re.search(pattern, x), strings)\n return filtered_strings","def test_filter_fastq(self):\r\n input_seqs = [('Seq1 some comment', 'ACCTTGG', 'BBBBBBB'),\r\n ('s2 some other comment', 'TTGG', 'BBBB'),\r\n ('S3', 'AAGGCCGG', 'BBCtatcc'),\r\n ('S5 some comment', 'CGT', 'BBB'),\r\n ('seq6 some other comment', 'AA', 'BB'),\r\n ('S7', 'T', 's')]\r\n seqs_to_keep = {}.fromkeys(['Seq1',\r\n 's2 some other comment',\r\n 'S3 no comment'])\r\n\r\n actual = fake_output_f()\r\n filter_fastq(input_seqs,\r\n actual,\r\n seqs_to_keep,\r\n negate=False)\r\n self.assertEqual(actual.s, self.filter_fastq_expected1)\r\n\r\n actual = fake_output_f()\r\n filter_fastq(input_seqs,\r\n actual,\r\n seqs_to_keep,\r\n negate=True)\r\n self.assertEqual(actual.s, self.filter_fastq_expected2)","def filterfn(read):\n return (read.is_proper_pair and read.is_paired and read.tlen > 0 and not read.is_supplementary and not read.is_duplicate and not read.is_unmapped and not read.mate_is_unmapped)","def filter(self, func):\r\n\r\n d = self.data\r\n f = []\r\n for i in d:\r\n if func(i):\r\n f.append(i)\r\n return Records(f)","def apply_ngram_filter(self, fn):\n self._apply_filter(lambda ng, f: fn(*ng))","def filter(self, minLength=None, maxLength=None, removeGaps=False,\n whitelist=None, blacklist=None,\n titleRegex=None, negativeTitleRegex=None,\n truncateTitlesAfter=None, indices=None, head=None,\n removeDuplicates=False, modifier=None):\n return Reads(self._filter(\n minLength=minLength, maxLength=maxLength, removeGaps=removeGaps,\n whitelist=whitelist, blacklist=blacklist, titleRegex=titleRegex,\n negativeTitleRegex=negativeTitleRegex,\n truncateTitlesAfter=truncateTitlesAfter, indices=indices,\n head=head, removeDuplicates=removeDuplicates, modifier=modifier))","def filter_patterns(self,threshold):\n if threshold is not None:\n pass #learn threshold\n return filter(lambda pattern: pattern.score > threshold, self.patterns)","def _filterTaxa(self, taxaString):\n if self.taxRegex is None:\n if not self.taxFilterType in regexTaxFilters:\n self.taxFilterType = re.compile(taxFilterType)\n else:\n self.taxFilterType = regexTaxFilters[taxFilterType]\n\n try:\n #Parse out genus and species if exists\n taxInfo = self.taxFilterType.findall(taxaString)[0] \n if len(taxInfo.split()) == 1: \n #Error finding taxonomic info\n taxInfo = taxaString\n except:\n taxInfo = taxaString\n finally:\n #Only return HSP if the filter is not found within the taxInfo string\n return self.taxFilter not in taxInfo","def test_filtered_scan(self):\n self.run_scan(self.tempdir, self.root_fcount + self.nest_fcount, ext=\".txt\")","def lst_and_pattern (filer_lst, pattern):\r\n new_filter_lst=[]\r\n for word in filer_lst:\r\n if word_and_pattern(word,pattern):\r\n new_filter_lst.append(word)\r\n return new_filter_lst","def filter_non_running_NFs (self, nffg, log=logging.getLogger(\"FILTER\")):\n # TODO implement\n pass","def filter(self, b, a=[1]):\n return self.from_time(self.fs, lfilter(b, a, self.in_time, axis=-1))","def filter_scan(scan, filter_pattern, parent):\n filter_line = scan.get('filterLine')\n filter_m = re.search(filter_pattern, filter_line)\n if filter_m is None:\n parent.remove(scan)\n return 0\n else:\n return 1","def filter(iteratee, seq):\n return _filter(fnc.iteratee(iteratee), seq)","def test_filter_wea_zero_entry():\n pass","def pattern_filter(patterns, name):\n return [pat for pat in patterns if fnmatch.fnmatchcase(name, pat)]","def test_filter_function_any(self):\n self.es.register_filter(lambda x: True, ftype='any')\n self.assertTrue(self.es.streamfilter(self.data))\n self.es.register_filter(lambda x: False, ftype='any')\n self.assertTrue(self.es.streamfilter(self.data))","def filter_chants_with_F_clef(chants, logger=None):\n contains_F_clef = chants.volpiano.str.contains('2') == True\n return chants[contains_F_clef == False]","def filter_extract(self, x):\n b, a = self.c_extract\n return filtfilt(b, a, x)","def filter(self, *args, **kwargs):","def regex_filter_list(file_list, pattern, output=True):\n r = re.compile(pattern)\n matches = filter(r.match, file_list)\n\n if (len(matches) > 0 and output is True):\n #print colors.BLUE + '\\033[1m' + \"matches:\" + '\\033[0m'\n for match in matches:\n print colors.BLUE + match + colors.ENDC\n\n return matches","def regex_filter(regex_str, versions):\n regex = re.compile(regex_str)\n return [v for v in versions if regex.search(v)]","def match(self, *args):\n return _ida_hexrays.udc_filter_t_match(self, *args)","def apply_word_filter(self, fn):\n self._apply_filter(lambda ng, f: any(fn(w) for w in ng))","def filter_it(self, _filter):\n with open(self.path) as _file:\n for line in _file:\n tokens = self._tokenize(line)\n if tokens:\n _ip = tokens.group('ip')\n if _filter.match(_ip):\n yield line","def filter(self, regex_pattern: str) -> None:\n self._filter_attachment_list(regex_pattern)\n self._filter_url_list(regex_pattern)","def filter_fastq_fp(input_seqs_fp, output_seqs_fp, seqs_to_keep, negate=False):\r\n input_seqs = parse_fastq(open(input_seqs_fp, 'U'), strict=False)\r\n output_f = open(output_seqs_fp, 'w')\r\n return filter_fastq(input_seqs, output_f, seqs_to_keep, negate)","def FilterLine(self, a_line):\n return a_line","async def wordfilter(self, ctx):\n pass","def Filter(sourcesarray, match, include=1):\n if include:\n return Array(*[item for item in sourcesarray if item.find(match) > -1])\n else:\n return Array(*[item for item in sourcesarray if item.find(match) == -1])","def test_filter_regex(re_arg, re_src, re_dest):\n args = parser.parse_args(['-re', *re_arg])\n filters = renamer.initfilters(args)\n dest = renamer.get_renames(re_src, filters, args.extension, args.raw)\n assert dest == re_dest","def filter_fasta(input_seqs, output_seqs_f, seqs_to_keep, negate=False):\r\n seqs_to_keep_lookup = {}.fromkeys([seq_id.split()[0]\r\n for seq_id in seqs_to_keep])\r\n # Define a function based on the value of negate\r\n if not negate:\r\n def keep_seq(seq_id):\r\n return seq_id.split()[0] in seqs_to_keep_lookup\r\n else:\r\n def keep_seq(seq_id):\r\n return seq_id.split()[0] not in seqs_to_keep_lookup\r\n\r\n for seq_id, seq in input_seqs:\r\n if keep_seq(seq_id):\r\n output_seqs_f.write('>%s\\n%s\\n' % (seq_id, seq))\r\n output_seqs_f.close()","def remove(data, pattern):\n return [''.join(filter(pattern, str)) for str in data]","def test_filter_remove(self):\n words = ['cart', 'fate', 'date', 'daft']\n filtered = filter_scores(score_words(words), 'fate', -1)\n self.assertEqual([(8, 'daft'), (7, 'date'), (7, 'cart')], filtered)","def filter(self, func=bool):\n return _(filter(func, self._))","def search(self, filter):\n return [note for note in self.notes if note.match(filter)]","def _pass_filter(self, match: str, filter_: Tuple[str, Collection[str]]) -> bool:\n match_l = match.lower()\n last_match_idx = match_l.find(filter_[0])\n\n while last_match_idx != -1:\n # Check args\n end_of_if = match_l.find(\"/\", last_match_idx)\n # This should be aug.get (vars are not used e.g. parser.aug_get)\n expression = self.aug.get(match[:end_of_if] + \"/arg\")\n\n if expression.startswith(\"!\"):\n # Strip off \"!\"\n if expression[1:] in filter_[1]:\n return False\n else:\n if expression not in filter_[1]:\n return False\n\n last_match_idx = match_l.find(filter_[0], end_of_if)\n\n return True","def _filterfunc(self,*args,**kwargs):\n self._filterfunc = self.f\n return self.f(*args,**kwargs)","def filter(args):\n p = OptionParser(filter.__doc__)\n p.add_option(\n \"--less\",\n default=False,\n action=\"store_true\",\n help=\"filter the sizes < certain cutoff [default: >=]\",\n )\n p.set_outfile()\n\n opts, args = p.parse_args(args)\n\n if len(args) != 2:\n sys.exit(not p.print_help())\n\n fastafile, cutoff = args\n try:\n cutoff = int(cutoff)\n except ValueError:\n sys.exit(not p.print_help())\n\n f = Fasta(fastafile, lazy=True)\n\n fw = must_open(opts.outfile, \"w\")\n for name, rec in f.iteritems_ordered():\n\n if opts.less and len(rec) >= cutoff:\n continue\n\n if (not opts.less) and len(rec) < cutoff:\n continue\n\n SeqIO.write([rec], fw, \"fasta\")\n fw.flush()\n\n return fw.name","def filter_files(self, pattern, filter_fn=None):\n def filter_function(f):\n return re.search(pattern, f) != None\n if not filter_fn:\n filter_fn = filter_function\n return filter(filter_fn, self.files)","def fn_to_reg(self, searchItems):\n return [re.compile(fnmatch.translate(s)) for s in searchItems]","def test():\n # Separate generator objects.\n infilename = 'filter2.py'\n infile = open(infilename, 'r')\n g1 = filter(infile, skip_if_emptystring)\n g2 = filter(g1, add_double_mash)\n g3 = filter(g2, rstrip_line)\n for line in g3:\n print line\n infile.close()\n # Nested calls to generator functions.\n print '-' * 50\n infile = open(infilename, 'r')\n for line in filter(\n filter(\n filter(infile, skip_if_emptystring),\n add_double_mash),\n rstrip_line):\n print line\n infile.close()","def generate_filter(filter_text):\n if ':' in filter_text:\n file_path_filter, _, contract_filter = filter_text.partition(':')\n else:\n file_path_filter = contract_filter = filter_text\n\n return functools.partial(check_if_matches_filter, file_path_filter, contract_filter)","def buffer_build_regex(buffer):\n\n\thdata = weechat.hdata_get(\"buffer\")\n\tinput = weechat.hdata_string(hdata, buffer, \"input_buffer\")\n\texact = weechat.hdata_integer(hdata, buffer, \"text_search_exact\")\n\twhere = weechat.hdata_integer(hdata, buffer, \"text_search_where\")\n\tregex = weechat.hdata_integer(hdata, buffer, \"text_search_regex\")\n\n\tif not regex:\n\t\tinput = re.escape(input)\n\n\tif exact:\n\t\tinput = \"(?-i)%s\" % input\n\n\tfilter_regex = None\n\tif where == 1: # message\n\t\tfilter_regex = input\n\telif where == 2: # prefix\n\t\tfilter_regex = \"%s\\\\t\" % input\n\telse: # prefix | message\n\t\tfilter_regex = input # TODO: impossible with current filter regex\n\n\treturn \"!%s\" % filter_regex","def regex_compiled():\n return re.compile(SBE19DataParticle.regex())","def filter_DNA(c):\n if c in \"ACGTacgt\":\n return True\n else:\n return False","def filter_ngram(gram, mode='any'):\n filtered = [filter_word(w) for w in gram]\n if mode == 'any':\n return any(filtered)\n elif mode == 'all':\n return all(filtered)\n elif mode == 'ends':\n return filtered[0] or filtered[-1]\n else:\n raise ValueError('Invalid mode: %s' % mode)","def filter_all(_):\n return True","def grep(string,list):\n import re\n expr = re.compile(string)\n return filter(expr.search,list)","def filter_lines(lines, filter_regex, groups=None):\n pattern = re.compile(filter_regex)\n for line in lines:\n match = pattern.search(line)\n if match:\n if groups is None:\n yield line\n elif len(groups) == 1:\n yield match.group(groups[0])\n else:\n matched_groups = match.groupdict()\n yield tuple(matched_groups.get(group) for group in groups)","def _apply_filter(self, fn=lambda ngram, freq: False):\n tmp_ngram = FreqDist()\n for ngram, freq in self.ngram_fd.items():\n if not fn(ngram, freq):\n tmp_ngram[ngram] = freq\n self.ngram_fd = tmp_ngram","def test_can_filter_tags(self):\n text = '<b><i>Example</i></b><!-- comment -->'\n filter = Bleach(tags=['b'], strip=True)\n filtered = filter.filter(text)\n expected = '<b>Example</b>'\n self.assertEquals(expected, filtered)","def apply(self, *args):\n return _ida_hexrays.microcode_filter_t_apply(self, *args)","def _match_filter(self, meta, field):\r\n val = meta[field]\r\n if field in self.ignored_values:\r\n for pattern in self.ignored_values[field]:\r\n val = val.replace(pattern, '')\r\n return val","def filter_profanities(text,replace_handler=profanity_word_handler):\n profanities=CensoredWord.objects.get_profanities_wordlist()\n return word_filter(text,profanities,replace_handler)","def test_illumina_data_to_fastq_no_pass_filter_field(self):\r\n in1 = (\r\n \"M10\",\r\n \"68\",\r\n \"1\",\r\n \"1\",\r\n \"28680\",\r\n \"29475\",\r\n \"0\",\r\n \"1\",\r\n \"AACGAAAGGCAGTTTTGGAAGTAGGCGAATTAGGGTAACGCATATAGGATGCTAATACAACGTGAATGAAGTACTGCATCTATGTCACCAGCTTATTACAGCAGCTTGTCATACATGGCCGTACAGGAAACACACATCATAGCATCACACG.\",\r\n \"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\")\r\n expected = \"\"\"@M10_68:1:1:28680:29475#0/1\\nAACGAAAGGCAGTTTTGGAAGTAGGCGAATTAGGGTAACGCATATAGGATGCTAATACAACGTGAATGAAGTACTGCATCTATGTCACCAGCTTATTACAGCAGCTTGTCATACATGGCCGTACAGGAAACACACATCATAGCATCACACGN\\n+\\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\"\"\", 2\r\n\r\n self.assertEqual(illumina_data_to_fastq(in1), expected)","def array_filter(item, func):\n return filter(func, item)","def filter_detect(self, x):\n b, a = self.c_detect\n return filtfilt(b, a, x)","def filter_test(self, test_index=-1):\n if test_index == -1:\n for data in inputs:\n self.input(data)\n self.lexer.lexer.lineno = 1\n self._print_input(data)\n\n for token in self.filtered_stream:\n self._pretty_print_token(token)\n print('\\n')\n\n else:\n data = inputs[test_index]\n self.input(data)\n self.lexer.lexer.lineno = 1\n self._print_input(data)\n\n for token in self.filtered_stream:\n self._pretty_print_token(token)\n print('\\n')","def negative_filtering(patterns: list, file_list):\n if len(patterns) == 0:\n return file_list\n prog = re.compile(patterns.pop())\n it = (i for i in file_list if not prog.search(i))\n return negative_filtering(patterns, it)","def filter_query(self):\n with open(self.mash_out_path, \"r\") as f:\n for line in f.readlines():\n line = \" \".join(line.split())\n hold = []\n for x in line.split(' '):\n hold.append(x)\n self.mash_all[str(hold[1])] = [\"--\", hold[2], hold[3]] ## Holds entire mash output\n if (float(hold[3]) > 0.001 or float(hold[3]) == 0):\n self.mash_dict[str(hold[1])] = [\"--\", hold[2], hold[3]] ## key = fasta id = [name, distance, p-val], holds filtered mash output\n\n q = SeqIO.parse(open(self.path3), 'fasta')\n self.filtered_out_path = os.getcwd() + \"/filtered_query.fasta\" ## Holds sequences for off-target algorithm\n with open(self.filtered_out_path, 'w') as outfile:\n for fasta in q:\n id, description = fasta.id, fasta.description\n if id in self.mash_dict.keys():\n line = description.replace(\",\",\"\")\n hold = []\n name = \"\"\n for x in line.split(' '):\n hold.append(x)\n for i in range(1,len(hold)-2):\n name += hold[i] + \" \"\n self.mash_dict[id][0] = name\n SeqIO.write(fasta, outfile, 'fasta')\n\n self.progress_val += 100/6","def ifilter(self, func: Callable[[T], bool]) -> '_[T]':\n return _(filter(func, self.array))","def filter_re_search(val, pattern: str):\n if not isinstance(val, str):\n return val\n result = re.search(pattern, val, re.IGNORECASE)\n if result:\n return result.group(0)\n return ''","def raw_string(seq):\n\n def f(s):\n \"\"\" Filter latex \"\"\"\n r = s.replace('\\\\', '\\\\\\\\').replace('_', '\\_').replace('^', '\\^')\n return r\n\n return [ f(k) for k in seq ]","def filter(self, record):\n\n if self.config[\"filter\"].get(\"whitelist\"):\n return any(name.filter(record) for name in self.parse_list)\n return not any(name.filter(record) for name in self.parse_list)","def filter(self, fn):\n self.__filter_chain.append(fn)","def regexp_predicate(value):\n return re.compile(value).match","def filter(self, func):\n return AnyPyProcessOutputList(filter(func, self))","def filterRawNodes(self, data):\n def filterFun(str):\n if ('/' in str):\n return True\n else:\n return False\n return filter(filterFun, data)","def test_filter_sequence_false(self):\n self.es.register_filter(bar=list('baz'))\n self.assertFalse(self.es.streamfilter(self.data))","def fnmatch_filter(names, pat):\r\n import os,posixpath\r\n result=[]\r\n pat=os.path.normcase(pat)\r\n if not pat in _cache:\r\n res = translate(pat)\r\n if len(_cache) >= _MAXCACHE:\r\n _cache.clear()\r\n _cache[pat] = re.compile(res)\r\n match=_cache[pat].match\r\n if os.path is posixpath:\r\n # normcase on posix is NOP. Optimize it away from the loop.\r\n for name in names:\r\n m = match(name)\r\n if m:\r\n result.append((name, m.groups()))\r\n else:\r\n for name in names:\r\n m = match(os.path.normcase(name))\r\n if m:\r\n result.append((name, m.groups()))\r\n return result","def filterFunction(region):\n inset = abs(region.stopGene.location[1] - region.stopGene.location[0])/2 if region.stopGene else 0\n return region.stop + inset - region.start > minLength","def get_filtered_record(csv_fname):\n with open(csv_fname, \"r\") as student_records:\n for student_record in csv.reader(student_records):\n converted = [re.sub('[^a-z0-9]+', '', x.lower()) for x in student_record]\n yield converted","def filter(self, filter_strings):\n if filter_strings is None:\n filter_strings = []\n\n result = RowSet()\n for row in self.rows:\n match = True\n for s in filter_strings:\n if not row.filter(s):\n match = False\n break\n if match:\n result.append(row)\n return result","def umem_search(self, regex):\n regex = utils.re_to_unicode(regex)\n for _, i in self.mem_search(str(regex), ftype=\"re\"):\n yield i","def address_regex(self) -> Any:","def test_filter_function_all(self):\n self.es.register_filter(lambda x: True)\n self.assertTrue(self.es.streamfilter(self.data))\n self.es.register_filter(lambda x: False)\n self.assertFalse(self.es.streamfilter(self.data))"],"string":"[\n \"def filter_fasta(\\n infa: str,\\n outfa: str = None,\\n regex: str = \\\".*\\\",\\n invert_match: Optional[bool] = False,\\n) -> list:\\n pattern = re.compile(regex)\\n\\n def keep(header):\\n return bool(pattern.search(header)) is not invert_match\\n\\n return _apply_fasta_regex_func(infa, keep, outfa)\",\n \"def filterRansac():\\n pass\",\n \"def filt(seq, lst):\\n regex = \\\"(\\\" + \\\")|(\\\".join(seq) + \\\")\\\"\\n regex = re.compile(regex)\\n slst = list(filter(regex.search, lst))\\n return slst\\n\\n\\n # still need a checkUsername function \",\n \"def test_filter_fasta(self):\\r\\n input_seqs = [('Seq1 some comment', 'ACCTTGG'),\\r\\n ('s2 some other comment', 'TTGG'),\\r\\n ('S3', 'AAGGCCGG'),\\r\\n ('S5 some comment', 'CGT'),\\r\\n ('seq6 some other comment', 'AA'),\\r\\n ('S7', 'T')]\\r\\n seqs_to_keep = {}.fromkeys(['Seq1',\\r\\n 's2 some other comment',\\r\\n 'S3 no comment'])\\r\\n\\r\\n actual = fake_output_f()\\r\\n filter_fasta(input_seqs,\\r\\n actual,\\r\\n seqs_to_keep,\\r\\n negate=False)\\r\\n self.assertEqual(actual.s, self.filter_fasta_expected1)\\r\\n\\r\\n actual = fake_output_f()\\r\\n filter_fasta(input_seqs,\\r\\n actual,\\r\\n seqs_to_keep,\\r\\n negate=True)\\r\\n self.assertEqual(actual.s, self.filter_fasta_expected2)\",\n \"def __filter( self, text ):\\n return text\",\n \"def filter_by_regex(self, dictlist, fidname, regex, outputfidlist=[]):\\n result = [item for item in dictlist if re.match(regex, item[fidname]) != None]\\n return self.filter_output(result, outputfidlist)\",\n \"def filter_nmt_file(filename,filter_fn=None):\\r\\n \\r\\n if filter_fn is None:\\r\\n filter_fn = lambda en : en.lower().startswith('i am') or \\\\\\r\\n en.lower().startswith('he is') or \\\\\\r\\n en.lower().startswith('she is') or \\\\\\r\\n en.lower().startswith('they are') or \\\\\\r\\n en.lower().startswith('you are') or \\\\\\r\\n en.lower().startswith('we are')\\r\\n \\r\\n filtered_lines = []\\r\\n with open(filename) as file:\\r\\n lines = file.readlines()\\r\\n for line in lines:\\r\\n text = line.split('\\\\t')\\r\\n en = text[0]\\r\\n fra = text[1]\\r\\n if filter_fn(en):\\r\\n filtered_lines.append(en.lower() + '\\\\t' + fra.lower())\\r\\n\\r\\n return filtered_lines\",\n \"def filter(self, fn):\\r\\n\\t\\treturn FilterProjectedList(self, [fn])\",\n \"def filter(self, ffun):\\n # BEGIN\\n lst = []\\n for item in WordSet(self.text).words():\\n # if len(item) == len(ffun):\\n # lst.append(item)\\n if ffun(item) == True:\\n lst.append(item)\\n return lst\\n\\n # END\",\n \"def transfer_filter(s, reg_exps, verbose=False):\\n # Default: no match is found\\n match = None\\n\\n # Reformat string to lowercase without new line characters\\n s = s.replace('\\\\n', ' ').lower()\\n\\n # See if a match can be found with the unpredictable transfer filter regex\\n match = reg_exps['re_trans_filter'].search(s)\\n\\n return match\",\n \"def filter_text(self, text):\\n yield from map(self._filter,\\n (m.group(0) for m in re.finditer(self.pattern, text)))\",\n \"def match(self, *args):\\n return _ida_hexrays.microcode_filter_t_match(self, *args)\",\n \"def _filter(self, minLength=None, maxLength=None, removeGaps=False,\\n whitelist=None, blacklist=None,\\n titleRegex=None, negativeTitleRegex=None,\\n truncateTitlesAfter=None, indices=None, head=None,\\n removeDuplicates=False, modifier=None):\\n if (whitelist or blacklist or titleRegex or negativeTitleRegex or\\n truncateTitlesAfter):\\n titleFilter = TitleFilter(\\n whitelist=whitelist, blacklist=blacklist,\\n positiveRegex=titleRegex, negativeRegex=negativeTitleRegex,\\n truncateAfter=truncateTitlesAfter)\\n else:\\n titleFilter = None\\n\\n if removeDuplicates:\\n sequencesSeen = set()\\n\\n for readIndex, read in enumerate(self):\\n\\n if head is not None and readIndex == head:\\n # We're completely done.\\n return\\n\\n readLen = len(read)\\n if ((minLength is not None and readLen < minLength) or\\n (maxLength is not None and readLen > maxLength)):\\n continue\\n\\n if removeGaps:\\n sequence = read.sequence.replace('-', '')\\n read = read.__class__(read.id, sequence, read.quality)\\n\\n if (titleFilter and\\n titleFilter.accept(read.id) == TitleFilter.REJECT):\\n continue\\n\\n if indices is not None and readIndex not in indices:\\n continue\\n\\n if removeDuplicates:\\n if read.sequence in sequencesSeen:\\n continue\\n sequencesSeen.add(read.sequence)\\n\\n if modifier:\\n modified = modifier(read)\\n if modified is None:\\n continue\\n else:\\n read = modified\\n\\n yield read\",\n \"def filter(self, function):\\n return FunctionalWrapper(filter(function, self.data))\",\n \"def filter_macro(out, scope, args, children):\\n len(args) == 2 or syntax_error(\\\"'filter' macro takes exactly 2 arguments.\\\")\\n regex, l = args\\n if not isinstance(l, list):\\n syntax_error(\\\"Invalid list in 'filter' macro: '%s'\\\" % str(list))\\n if not isinstance(regex, str):\\n syntax_error(\\\"Invalid regex in 'filter' macro: '%s'\\\" % str(regex))\\n def match(s):\\n return re.search(regex, s)\\n return list(filter(match, l))\",\n \"def filter(self, pattern):\\n if isinstance(pattern, REGEX_TYPE):\\n func = tools.filter_regex\\n elif pattern.startswith('/'):\\n pattern = re.compile(pattern.strip('/'))\\n func = tools.filter_regex\\n else:\\n func = tools.filter_wildcard\\n\\n return SeeResult(func(self, pattern))\",\n \"def filt(rec):\\n return True # Show everything\",\n \"def filter(self, filters):\",\n \"def filter(self, *args):\\n exps = []\\n\\n #this ones can be improved. some are not getting extracted\\n if \\\"retweets\\\" in args:\\n exps.append(re.compile(\\\"^RT ?(?<=^|(?<=[^a-zA-Z0-9-_\\\\.]))@([A-Za-z]+[A-Za-z0-9-_]+):\\\"))\\n if \\\"emoticons\\\" in args:\\n exps.append(\\\"emoticons\\\")\\n if \\\"flags\\\" in args:\\n exps.append(re.compile(u\\\"[\\\\U0001F1E6-\\\\U0001F1FF]\\\"))\\n if \\\"handles\\\" in args:\\n # Handles at start of string\\n exps.append(re.compile(\\\"^\\\\s*((?<=^|(?<=[^\\\\S]))@([\\\\S]+)\\\\s*)*\\\"))\\n # Handles at end of string\\n exps.append(re.compile(\\\"\\\\s+((?<=^|(?<=[^\\\\S]))@(\\\\S+)\\\\s*)*$\\\"))\\n if \\\"urls\\\" in args:\\n exps.append(re.compile(\\\"(https?|ftp)://[^\\\\s/$.?#].[^\\\\s]*\\\"))\\n if \\\"hashtags\\\" in args:\\n # Hastags at start of string\\n exps.append(re.compile(\\\"^\\\\s*((?<=^|(?<=[^\\\\S]))#([\\\\S]+)\\\\s*)*\\\"))\\n # Hashtags at end of string\\n exps.append(re.compile(\\\"\\\\s+((?<=^|(?<=[^\\\\S]))#(\\\\S+)\\\\s*)*$\\\"))\\n\\n\\n # Use all filters\\n if \\\"*\\\" in args and not exps:\\n return self.filter(\\\"retweets\\\", \\\"emoticons\\\", \\\"flags\\\", \\\"handles\\\", \\\"urls\\\", \\\"hashtags\\\")\\n\\n filtering_text = self.raw_text\\n\\n for expression in exps:\\n if expression == \\\"emoticons\\\":\\n filtering_text = ''.join(c for c in filtering_text if c not in emoji.UNICODE_EMOJI)\\n else:\\n filtering_text = re.sub(expression, \\\"\\\", filtering_text)\\n\\n # Remove extra spaces\\n self.clean_text = re.sub(r\\\"\\\\s\\\\s+\\\", ' ', filtering_text.strip())\\n return self.clean_text\",\n \"def search(self, filtro):\\n return [nota for nota in self.notas if nota.match(filtro)]\",\n \"def filter_fasta_fp(input_seqs_fp, output_seqs_fp, seqs_to_keep, negate=False):\\r\\n input_seqs = parse_fasta(open(input_seqs_fp, 'U'))\\r\\n output_f = open(output_seqs_fp, 'w')\\r\\n return filter_fasta(input_seqs, output_f, seqs_to_keep, negate)\",\n \"def filter_ignoring_case(self, pattern):\\n return self.filter(re.compile(pattern, re.I))\",\n \"def ft_filter(fnct, tab):\\n res = []\\n for i in tab:\\n if fnct:\\n if fnct(i):\\n res.append(i)\\n else:\\n if i:\\n res.append(i)\\n return res\",\n \"def filter_on_regexp(strings, pattern):\\n filtered_strings = filter(lambda x: re.search(pattern, x), strings)\\n return filtered_strings\",\n \"def test_filter_fastq(self):\\r\\n input_seqs = [('Seq1 some comment', 'ACCTTGG', 'BBBBBBB'),\\r\\n ('s2 some other comment', 'TTGG', 'BBBB'),\\r\\n ('S3', 'AAGGCCGG', 'BBCtatcc'),\\r\\n ('S5 some comment', 'CGT', 'BBB'),\\r\\n ('seq6 some other comment', 'AA', 'BB'),\\r\\n ('S7', 'T', 's')]\\r\\n seqs_to_keep = {}.fromkeys(['Seq1',\\r\\n 's2 some other comment',\\r\\n 'S3 no comment'])\\r\\n\\r\\n actual = fake_output_f()\\r\\n filter_fastq(input_seqs,\\r\\n actual,\\r\\n seqs_to_keep,\\r\\n negate=False)\\r\\n self.assertEqual(actual.s, self.filter_fastq_expected1)\\r\\n\\r\\n actual = fake_output_f()\\r\\n filter_fastq(input_seqs,\\r\\n actual,\\r\\n seqs_to_keep,\\r\\n negate=True)\\r\\n self.assertEqual(actual.s, self.filter_fastq_expected2)\",\n \"def filterfn(read):\\n return (read.is_proper_pair and read.is_paired and read.tlen > 0 and not read.is_supplementary and not read.is_duplicate and not read.is_unmapped and not read.mate_is_unmapped)\",\n \"def filter(self, func):\\r\\n\\r\\n d = self.data\\r\\n f = []\\r\\n for i in d:\\r\\n if func(i):\\r\\n f.append(i)\\r\\n return Records(f)\",\n \"def apply_ngram_filter(self, fn):\\n self._apply_filter(lambda ng, f: fn(*ng))\",\n \"def filter(self, minLength=None, maxLength=None, removeGaps=False,\\n whitelist=None, blacklist=None,\\n titleRegex=None, negativeTitleRegex=None,\\n truncateTitlesAfter=None, indices=None, head=None,\\n removeDuplicates=False, modifier=None):\\n return Reads(self._filter(\\n minLength=minLength, maxLength=maxLength, removeGaps=removeGaps,\\n whitelist=whitelist, blacklist=blacklist, titleRegex=titleRegex,\\n negativeTitleRegex=negativeTitleRegex,\\n truncateTitlesAfter=truncateTitlesAfter, indices=indices,\\n head=head, removeDuplicates=removeDuplicates, modifier=modifier))\",\n \"def filter_patterns(self,threshold):\\n if threshold is not None:\\n pass #learn threshold\\n return filter(lambda pattern: pattern.score > threshold, self.patterns)\",\n \"def _filterTaxa(self, taxaString):\\n if self.taxRegex is None:\\n if not self.taxFilterType in regexTaxFilters:\\n self.taxFilterType = re.compile(taxFilterType)\\n else:\\n self.taxFilterType = regexTaxFilters[taxFilterType]\\n\\n try:\\n #Parse out genus and species if exists\\n taxInfo = self.taxFilterType.findall(taxaString)[0] \\n if len(taxInfo.split()) == 1: \\n #Error finding taxonomic info\\n taxInfo = taxaString\\n except:\\n taxInfo = taxaString\\n finally:\\n #Only return HSP if the filter is not found within the taxInfo string\\n return self.taxFilter not in taxInfo\",\n \"def test_filtered_scan(self):\\n self.run_scan(self.tempdir, self.root_fcount + self.nest_fcount, ext=\\\".txt\\\")\",\n \"def lst_and_pattern (filer_lst, pattern):\\r\\n new_filter_lst=[]\\r\\n for word in filer_lst:\\r\\n if word_and_pattern(word,pattern):\\r\\n new_filter_lst.append(word)\\r\\n return new_filter_lst\",\n \"def filter_non_running_NFs (self, nffg, log=logging.getLogger(\\\"FILTER\\\")):\\n # TODO implement\\n pass\",\n \"def filter(self, b, a=[1]):\\n return self.from_time(self.fs, lfilter(b, a, self.in_time, axis=-1))\",\n \"def filter_scan(scan, filter_pattern, parent):\\n filter_line = scan.get('filterLine')\\n filter_m = re.search(filter_pattern, filter_line)\\n if filter_m is None:\\n parent.remove(scan)\\n return 0\\n else:\\n return 1\",\n \"def filter(iteratee, seq):\\n return _filter(fnc.iteratee(iteratee), seq)\",\n \"def test_filter_wea_zero_entry():\\n pass\",\n \"def pattern_filter(patterns, name):\\n return [pat for pat in patterns if fnmatch.fnmatchcase(name, pat)]\",\n \"def test_filter_function_any(self):\\n self.es.register_filter(lambda x: True, ftype='any')\\n self.assertTrue(self.es.streamfilter(self.data))\\n self.es.register_filter(lambda x: False, ftype='any')\\n self.assertTrue(self.es.streamfilter(self.data))\",\n \"def filter_chants_with_F_clef(chants, logger=None):\\n contains_F_clef = chants.volpiano.str.contains('2') == True\\n return chants[contains_F_clef == False]\",\n \"def filter_extract(self, x):\\n b, a = self.c_extract\\n return filtfilt(b, a, x)\",\n \"def filter(self, *args, **kwargs):\",\n \"def regex_filter_list(file_list, pattern, output=True):\\n r = re.compile(pattern)\\n matches = filter(r.match, file_list)\\n\\n if (len(matches) > 0 and output is True):\\n #print colors.BLUE + '\\\\033[1m' + \\\"matches:\\\" + '\\\\033[0m'\\n for match in matches:\\n print colors.BLUE + match + colors.ENDC\\n\\n return matches\",\n \"def regex_filter(regex_str, versions):\\n regex = re.compile(regex_str)\\n return [v for v in versions if regex.search(v)]\",\n \"def match(self, *args):\\n return _ida_hexrays.udc_filter_t_match(self, *args)\",\n \"def apply_word_filter(self, fn):\\n self._apply_filter(lambda ng, f: any(fn(w) for w in ng))\",\n \"def filter_it(self, _filter):\\n with open(self.path) as _file:\\n for line in _file:\\n tokens = self._tokenize(line)\\n if tokens:\\n _ip = tokens.group('ip')\\n if _filter.match(_ip):\\n yield line\",\n \"def filter(self, regex_pattern: str) -> None:\\n self._filter_attachment_list(regex_pattern)\\n self._filter_url_list(regex_pattern)\",\n \"def filter_fastq_fp(input_seqs_fp, output_seqs_fp, seqs_to_keep, negate=False):\\r\\n input_seqs = parse_fastq(open(input_seqs_fp, 'U'), strict=False)\\r\\n output_f = open(output_seqs_fp, 'w')\\r\\n return filter_fastq(input_seqs, output_f, seqs_to_keep, negate)\",\n \"def FilterLine(self, a_line):\\n return a_line\",\n \"async def wordfilter(self, ctx):\\n pass\",\n \"def Filter(sourcesarray, match, include=1):\\n if include:\\n return Array(*[item for item in sourcesarray if item.find(match) > -1])\\n else:\\n return Array(*[item for item in sourcesarray if item.find(match) == -1])\",\n \"def test_filter_regex(re_arg, re_src, re_dest):\\n args = parser.parse_args(['-re', *re_arg])\\n filters = renamer.initfilters(args)\\n dest = renamer.get_renames(re_src, filters, args.extension, args.raw)\\n assert dest == re_dest\",\n \"def filter_fasta(input_seqs, output_seqs_f, seqs_to_keep, negate=False):\\r\\n seqs_to_keep_lookup = {}.fromkeys([seq_id.split()[0]\\r\\n for seq_id in seqs_to_keep])\\r\\n # Define a function based on the value of negate\\r\\n if not negate:\\r\\n def keep_seq(seq_id):\\r\\n return seq_id.split()[0] in seqs_to_keep_lookup\\r\\n else:\\r\\n def keep_seq(seq_id):\\r\\n return seq_id.split()[0] not in seqs_to_keep_lookup\\r\\n\\r\\n for seq_id, seq in input_seqs:\\r\\n if keep_seq(seq_id):\\r\\n output_seqs_f.write('>%s\\\\n%s\\\\n' % (seq_id, seq))\\r\\n output_seqs_f.close()\",\n \"def remove(data, pattern):\\n return [''.join(filter(pattern, str)) for str in data]\",\n \"def test_filter_remove(self):\\n words = ['cart', 'fate', 'date', 'daft']\\n filtered = filter_scores(score_words(words), 'fate', -1)\\n self.assertEqual([(8, 'daft'), (7, 'date'), (7, 'cart')], filtered)\",\n \"def filter(self, func=bool):\\n return _(filter(func, self._))\",\n \"def search(self, filter):\\n return [note for note in self.notes if note.match(filter)]\",\n \"def _pass_filter(self, match: str, filter_: Tuple[str, Collection[str]]) -> bool:\\n match_l = match.lower()\\n last_match_idx = match_l.find(filter_[0])\\n\\n while last_match_idx != -1:\\n # Check args\\n end_of_if = match_l.find(\\\"/\\\", last_match_idx)\\n # This should be aug.get (vars are not used e.g. parser.aug_get)\\n expression = self.aug.get(match[:end_of_if] + \\\"/arg\\\")\\n\\n if expression.startswith(\\\"!\\\"):\\n # Strip off \\\"!\\\"\\n if expression[1:] in filter_[1]:\\n return False\\n else:\\n if expression not in filter_[1]:\\n return False\\n\\n last_match_idx = match_l.find(filter_[0], end_of_if)\\n\\n return True\",\n \"def _filterfunc(self,*args,**kwargs):\\n self._filterfunc = self.f\\n return self.f(*args,**kwargs)\",\n \"def filter(args):\\n p = OptionParser(filter.__doc__)\\n p.add_option(\\n \\\"--less\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"filter the sizes < certain cutoff [default: >=]\\\",\\n )\\n p.set_outfile()\\n\\n opts, args = p.parse_args(args)\\n\\n if len(args) != 2:\\n sys.exit(not p.print_help())\\n\\n fastafile, cutoff = args\\n try:\\n cutoff = int(cutoff)\\n except ValueError:\\n sys.exit(not p.print_help())\\n\\n f = Fasta(fastafile, lazy=True)\\n\\n fw = must_open(opts.outfile, \\\"w\\\")\\n for name, rec in f.iteritems_ordered():\\n\\n if opts.less and len(rec) >= cutoff:\\n continue\\n\\n if (not opts.less) and len(rec) < cutoff:\\n continue\\n\\n SeqIO.write([rec], fw, \\\"fasta\\\")\\n fw.flush()\\n\\n return fw.name\",\n \"def filter_files(self, pattern, filter_fn=None):\\n def filter_function(f):\\n return re.search(pattern, f) != None\\n if not filter_fn:\\n filter_fn = filter_function\\n return filter(filter_fn, self.files)\",\n \"def fn_to_reg(self, searchItems):\\n return [re.compile(fnmatch.translate(s)) for s in searchItems]\",\n \"def test():\\n # Separate generator objects.\\n infilename = 'filter2.py'\\n infile = open(infilename, 'r')\\n g1 = filter(infile, skip_if_emptystring)\\n g2 = filter(g1, add_double_mash)\\n g3 = filter(g2, rstrip_line)\\n for line in g3:\\n print line\\n infile.close()\\n # Nested calls to generator functions.\\n print '-' * 50\\n infile = open(infilename, 'r')\\n for line in filter(\\n filter(\\n filter(infile, skip_if_emptystring),\\n add_double_mash),\\n rstrip_line):\\n print line\\n infile.close()\",\n \"def generate_filter(filter_text):\\n if ':' in filter_text:\\n file_path_filter, _, contract_filter = filter_text.partition(':')\\n else:\\n file_path_filter = contract_filter = filter_text\\n\\n return functools.partial(check_if_matches_filter, file_path_filter, contract_filter)\",\n \"def buffer_build_regex(buffer):\\n\\n\\thdata = weechat.hdata_get(\\\"buffer\\\")\\n\\tinput = weechat.hdata_string(hdata, buffer, \\\"input_buffer\\\")\\n\\texact = weechat.hdata_integer(hdata, buffer, \\\"text_search_exact\\\")\\n\\twhere = weechat.hdata_integer(hdata, buffer, \\\"text_search_where\\\")\\n\\tregex = weechat.hdata_integer(hdata, buffer, \\\"text_search_regex\\\")\\n\\n\\tif not regex:\\n\\t\\tinput = re.escape(input)\\n\\n\\tif exact:\\n\\t\\tinput = \\\"(?-i)%s\\\" % input\\n\\n\\tfilter_regex = None\\n\\tif where == 1: # message\\n\\t\\tfilter_regex = input\\n\\telif where == 2: # prefix\\n\\t\\tfilter_regex = \\\"%s\\\\\\\\t\\\" % input\\n\\telse: # prefix | message\\n\\t\\tfilter_regex = input # TODO: impossible with current filter regex\\n\\n\\treturn \\\"!%s\\\" % filter_regex\",\n \"def regex_compiled():\\n return re.compile(SBE19DataParticle.regex())\",\n \"def filter_DNA(c):\\n if c in \\\"ACGTacgt\\\":\\n return True\\n else:\\n return False\",\n \"def filter_ngram(gram, mode='any'):\\n filtered = [filter_word(w) for w in gram]\\n if mode == 'any':\\n return any(filtered)\\n elif mode == 'all':\\n return all(filtered)\\n elif mode == 'ends':\\n return filtered[0] or filtered[-1]\\n else:\\n raise ValueError('Invalid mode: %s' % mode)\",\n \"def filter_all(_):\\n return True\",\n \"def grep(string,list):\\n import re\\n expr = re.compile(string)\\n return filter(expr.search,list)\",\n \"def filter_lines(lines, filter_regex, groups=None):\\n pattern = re.compile(filter_regex)\\n for line in lines:\\n match = pattern.search(line)\\n if match:\\n if groups is None:\\n yield line\\n elif len(groups) == 1:\\n yield match.group(groups[0])\\n else:\\n matched_groups = match.groupdict()\\n yield tuple(matched_groups.get(group) for group in groups)\",\n \"def _apply_filter(self, fn=lambda ngram, freq: False):\\n tmp_ngram = FreqDist()\\n for ngram, freq in self.ngram_fd.items():\\n if not fn(ngram, freq):\\n tmp_ngram[ngram] = freq\\n self.ngram_fd = tmp_ngram\",\n \"def test_can_filter_tags(self):\\n text = '<b><i>Example</i></b><!-- comment -->'\\n filter = Bleach(tags=['b'], strip=True)\\n filtered = filter.filter(text)\\n expected = '<b>Example</b>'\\n self.assertEquals(expected, filtered)\",\n \"def apply(self, *args):\\n return _ida_hexrays.microcode_filter_t_apply(self, *args)\",\n \"def _match_filter(self, meta, field):\\r\\n val = meta[field]\\r\\n if field in self.ignored_values:\\r\\n for pattern in self.ignored_values[field]:\\r\\n val = val.replace(pattern, '')\\r\\n return val\",\n \"def filter_profanities(text,replace_handler=profanity_word_handler):\\n profanities=CensoredWord.objects.get_profanities_wordlist()\\n return word_filter(text,profanities,replace_handler)\",\n \"def test_illumina_data_to_fastq_no_pass_filter_field(self):\\r\\n in1 = (\\r\\n \\\"M10\\\",\\r\\n \\\"68\\\",\\r\\n \\\"1\\\",\\r\\n \\\"1\\\",\\r\\n \\\"28680\\\",\\r\\n \\\"29475\\\",\\r\\n \\\"0\\\",\\r\\n \\\"1\\\",\\r\\n \\\"AACGAAAGGCAGTTTTGGAAGTAGGCGAATTAGGGTAACGCATATAGGATGCTAATACAACGTGAATGAAGTACTGCATCTATGTCACCAGCTTATTACAGCAGCTTGTCATACATGGCCGTACAGGAAACACACATCATAGCATCACACG.\\\",\\r\\n \\\"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\\\")\\r\\n expected = \\\"\\\"\\\"@M10_68:1:1:28680:29475#0/1\\\\nAACGAAAGGCAGTTTTGGAAGTAGGCGAATTAGGGTAACGCATATAGGATGCTAATACAACGTGAATGAAGTACTGCATCTATGTCACCAGCTTATTACAGCAGCTTGTCATACATGGCCGTACAGGAAACACACATCATAGCATCACACGN\\\\n+\\\\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\\\"\\\"\\\", 2\\r\\n\\r\\n self.assertEqual(illumina_data_to_fastq(in1), expected)\",\n \"def array_filter(item, func):\\n return filter(func, item)\",\n \"def filter_detect(self, x):\\n b, a = self.c_detect\\n return filtfilt(b, a, x)\",\n \"def filter_test(self, test_index=-1):\\n if test_index == -1:\\n for data in inputs:\\n self.input(data)\\n self.lexer.lexer.lineno = 1\\n self._print_input(data)\\n\\n for token in self.filtered_stream:\\n self._pretty_print_token(token)\\n print('\\\\n')\\n\\n else:\\n data = inputs[test_index]\\n self.input(data)\\n self.lexer.lexer.lineno = 1\\n self._print_input(data)\\n\\n for token in self.filtered_stream:\\n self._pretty_print_token(token)\\n print('\\\\n')\",\n \"def negative_filtering(patterns: list, file_list):\\n if len(patterns) == 0:\\n return file_list\\n prog = re.compile(patterns.pop())\\n it = (i for i in file_list if not prog.search(i))\\n return negative_filtering(patterns, it)\",\n \"def filter_query(self):\\n with open(self.mash_out_path, \\\"r\\\") as f:\\n for line in f.readlines():\\n line = \\\" \\\".join(line.split())\\n hold = []\\n for x in line.split(' '):\\n hold.append(x)\\n self.mash_all[str(hold[1])] = [\\\"--\\\", hold[2], hold[3]] ## Holds entire mash output\\n if (float(hold[3]) > 0.001 or float(hold[3]) == 0):\\n self.mash_dict[str(hold[1])] = [\\\"--\\\", hold[2], hold[3]] ## key = fasta id = [name, distance, p-val], holds filtered mash output\\n\\n q = SeqIO.parse(open(self.path3), 'fasta')\\n self.filtered_out_path = os.getcwd() + \\\"/filtered_query.fasta\\\" ## Holds sequences for off-target algorithm\\n with open(self.filtered_out_path, 'w') as outfile:\\n for fasta in q:\\n id, description = fasta.id, fasta.description\\n if id in self.mash_dict.keys():\\n line = description.replace(\\\",\\\",\\\"\\\")\\n hold = []\\n name = \\\"\\\"\\n for x in line.split(' '):\\n hold.append(x)\\n for i in range(1,len(hold)-2):\\n name += hold[i] + \\\" \\\"\\n self.mash_dict[id][0] = name\\n SeqIO.write(fasta, outfile, 'fasta')\\n\\n self.progress_val += 100/6\",\n \"def ifilter(self, func: Callable[[T], bool]) -> '_[T]':\\n return _(filter(func, self.array))\",\n \"def filter_re_search(val, pattern: str):\\n if not isinstance(val, str):\\n return val\\n result = re.search(pattern, val, re.IGNORECASE)\\n if result:\\n return result.group(0)\\n return ''\",\n \"def raw_string(seq):\\n\\n def f(s):\\n \\\"\\\"\\\" Filter latex \\\"\\\"\\\"\\n r = s.replace('\\\\\\\\', '\\\\\\\\\\\\\\\\').replace('_', '\\\\_').replace('^', '\\\\^')\\n return r\\n\\n return [ f(k) for k in seq ]\",\n \"def filter(self, record):\\n\\n if self.config[\\\"filter\\\"].get(\\\"whitelist\\\"):\\n return any(name.filter(record) for name in self.parse_list)\\n return not any(name.filter(record) for name in self.parse_list)\",\n \"def filter(self, fn):\\n self.__filter_chain.append(fn)\",\n \"def regexp_predicate(value):\\n return re.compile(value).match\",\n \"def filter(self, func):\\n return AnyPyProcessOutputList(filter(func, self))\",\n \"def filterRawNodes(self, data):\\n def filterFun(str):\\n if ('/' in str):\\n return True\\n else:\\n return False\\n return filter(filterFun, data)\",\n \"def test_filter_sequence_false(self):\\n self.es.register_filter(bar=list('baz'))\\n self.assertFalse(self.es.streamfilter(self.data))\",\n \"def fnmatch_filter(names, pat):\\r\\n import os,posixpath\\r\\n result=[]\\r\\n pat=os.path.normcase(pat)\\r\\n if not pat in _cache:\\r\\n res = translate(pat)\\r\\n if len(_cache) >= _MAXCACHE:\\r\\n _cache.clear()\\r\\n _cache[pat] = re.compile(res)\\r\\n match=_cache[pat].match\\r\\n if os.path is posixpath:\\r\\n # normcase on posix is NOP. Optimize it away from the loop.\\r\\n for name in names:\\r\\n m = match(name)\\r\\n if m:\\r\\n result.append((name, m.groups()))\\r\\n else:\\r\\n for name in names:\\r\\n m = match(os.path.normcase(name))\\r\\n if m:\\r\\n result.append((name, m.groups()))\\r\\n return result\",\n \"def filterFunction(region):\\n inset = abs(region.stopGene.location[1] - region.stopGene.location[0])/2 if region.stopGene else 0\\n return region.stop + inset - region.start > minLength\",\n \"def get_filtered_record(csv_fname):\\n with open(csv_fname, \\\"r\\\") as student_records:\\n for student_record in csv.reader(student_records):\\n converted = [re.sub('[^a-z0-9]+', '', x.lower()) for x in student_record]\\n yield converted\",\n \"def filter(self, filter_strings):\\n if filter_strings is None:\\n filter_strings = []\\n\\n result = RowSet()\\n for row in self.rows:\\n match = True\\n for s in filter_strings:\\n if not row.filter(s):\\n match = False\\n break\\n if match:\\n result.append(row)\\n return result\",\n \"def umem_search(self, regex):\\n regex = utils.re_to_unicode(regex)\\n for _, i in self.mem_search(str(regex), ftype=\\\"re\\\"):\\n yield i\",\n \"def address_regex(self) -> Any:\",\n \"def test_filter_function_all(self):\\n self.es.register_filter(lambda x: True)\\n self.assertTrue(self.es.streamfilter(self.data))\\n self.es.register_filter(lambda x: False)\\n self.assertFalse(self.es.streamfilter(self.data))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65963423","0.6402181","0.6011408","0.600255","0.5881439","0.57979774","0.5762943","0.5755297","0.57551485","0.57547766","0.57397467","0.5717947","0.5692144","0.5634937","0.560354","0.5600734","0.5595965","0.5553075","0.55393845","0.5537095","0.55356854","0.54769564","0.54725975","0.5471375","0.5434106","0.54247475","0.54131675","0.537695","0.53660154","0.5353755","0.5334312","0.53186285","0.53167754","0.5307874","0.53036666","0.52981627","0.52867246","0.5271497","0.5250823","0.52402216","0.5235076","0.52300316","0.52263844","0.52252257","0.5212167","0.5211884","0.5207822","0.51995045","0.519944","0.5198043","0.5196438","0.5181262","0.51707554","0.5165247","0.51620185","0.5142552","0.514113","0.5134605","0.512651","0.5112348","0.5082807","0.5076359","0.5070548","0.50530434","0.50425696","0.50295085","0.50218284","0.502066","0.50183934","0.5008197","0.50080055","0.500644","0.50039065","0.49748644","0.49705362","0.49647304","0.495576","0.49510375","0.4950769","0.49471018","0.4944326","0.49243298","0.49122804","0.49063936","0.4904679","0.48996115","0.48978874","0.48896065","0.48875114","0.48819315","0.4881567","0.4881296","0.48778036","0.48755908","0.48696223","0.4866484","0.48633662","0.48603386","0.48536694","0.4846665"],"string":"[\n \"0.65963423\",\n \"0.6402181\",\n \"0.6011408\",\n \"0.600255\",\n \"0.5881439\",\n \"0.57979774\",\n \"0.5762943\",\n \"0.5755297\",\n \"0.57551485\",\n \"0.57547766\",\n \"0.57397467\",\n \"0.5717947\",\n \"0.5692144\",\n \"0.5634937\",\n \"0.560354\",\n \"0.5600734\",\n \"0.5595965\",\n \"0.5553075\",\n \"0.55393845\",\n \"0.5537095\",\n \"0.55356854\",\n \"0.54769564\",\n \"0.54725975\",\n \"0.5471375\",\n \"0.5434106\",\n \"0.54247475\",\n \"0.54131675\",\n \"0.537695\",\n \"0.53660154\",\n \"0.5353755\",\n \"0.5334312\",\n \"0.53186285\",\n \"0.53167754\",\n \"0.5307874\",\n \"0.53036666\",\n \"0.52981627\",\n \"0.52867246\",\n \"0.5271497\",\n \"0.5250823\",\n \"0.52402216\",\n \"0.5235076\",\n \"0.52300316\",\n \"0.52263844\",\n \"0.52252257\",\n \"0.5212167\",\n \"0.5211884\",\n \"0.5207822\",\n \"0.51995045\",\n \"0.519944\",\n \"0.5198043\",\n \"0.5196438\",\n \"0.5181262\",\n \"0.51707554\",\n \"0.5165247\",\n \"0.51620185\",\n \"0.5142552\",\n \"0.514113\",\n \"0.5134605\",\n \"0.512651\",\n \"0.5112348\",\n \"0.5082807\",\n \"0.5076359\",\n \"0.5070548\",\n \"0.50530434\",\n \"0.50425696\",\n \"0.50295085\",\n \"0.50218284\",\n \"0.502066\",\n \"0.50183934\",\n \"0.5008197\",\n \"0.50080055\",\n \"0.500644\",\n \"0.50039065\",\n \"0.49748644\",\n \"0.49705362\",\n \"0.49647304\",\n \"0.495576\",\n \"0.49510375\",\n \"0.4950769\",\n \"0.49471018\",\n \"0.4944326\",\n \"0.49243298\",\n \"0.49122804\",\n \"0.49063936\",\n \"0.4904679\",\n \"0.48996115\",\n \"0.48978874\",\n \"0.48896065\",\n \"0.48875114\",\n \"0.48819315\",\n \"0.4881567\",\n \"0.4881296\",\n \"0.48778036\",\n \"0.48755908\",\n \"0.48696223\",\n \"0.4866484\",\n \"0.48633662\",\n \"0.48603386\",\n \"0.48536694\",\n \"0.4846665\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.676315"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83193,"cells":{"query":{"kind":"string","value":"Filter fasta file based on regex."},"document":{"kind":"string","value":"def filter_fasta(\n infa: str,\n outfa: str = None,\n regex: str = \".*\",\n invert_match: Optional[bool] = False,\n) -> list:\n pattern = re.compile(regex)\n\n def keep(header):\n return bool(pattern.search(header)) is not invert_match\n\n return _apply_fasta_regex_func(infa, keep, outfa)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _apply_fasta_regex_func(infa, regex_func, outfa=None):\n # move the original file to a tmp folder\n out_dir = os.path.dirname(infa)\n tmp_dir = mkdtemp(dir=out_dir)\n old_fname = os.path.join(tmp_dir, \"original\") if outfa is None else infa\n new_fname = os.path.join(tmp_dir, \"filtered\")\n shutil.move(infa, old_fname)\n\n # perform the filtering\n excluded_contigs = []\n keep_contig = True\n with open(old_fname) as old, open(new_fname, \"w\") as new:\n for line in tqdm(old, desc=\"Filtering Fasta\", unit_scale=1, unit=\" lines\"):\n if line[0] == \">\":\n keep_contig = regex_func(line)\n if keep_contig is False:\n excluded_contigs.append(line[1:].split(\" \")[0].strip())\n if keep_contig:\n new.write(line)\n\n # move the filtered file to the original folder\n shutil.move(new_fname, outfa if outfa else infa)\n rm_rf(tmp_dir)\n\n return excluded_contigs","def filter_nmt_file(filename,filter_fn=None):\r\n \r\n if filter_fn is None:\r\n filter_fn = lambda en : en.lower().startswith('i am') or \\\r\n en.lower().startswith('he is') or \\\r\n en.lower().startswith('she is') or \\\r\n en.lower().startswith('they are') or \\\r\n en.lower().startswith('you are') or \\\r\n en.lower().startswith('we are')\r\n \r\n filtered_lines = []\r\n with open(filename) as file:\r\n lines = file.readlines()\r\n for line in lines:\r\n text = line.split('\\t')\r\n en = text[0]\r\n fra = text[1]\r\n if filter_fn(en):\r\n filtered_lines.append(en.lower() + '\\t' + fra.lower())\r\n\r\n return filtered_lines","def filter_fasta_fp(input_seqs_fp, output_seqs_fp, seqs_to_keep, negate=False):\r\n input_seqs = parse_fasta(open(input_seqs_fp, 'U'))\r\n output_f = open(output_seqs_fp, 'w')\r\n return filter_fasta(input_seqs, output_f, seqs_to_keep, negate)","def test_filter_fasta(self):\r\n input_seqs = [('Seq1 some comment', 'ACCTTGG'),\r\n ('s2 some other comment', 'TTGG'),\r\n ('S3', 'AAGGCCGG'),\r\n ('S5 some comment', 'CGT'),\r\n ('seq6 some other comment', 'AA'),\r\n ('S7', 'T')]\r\n seqs_to_keep = {}.fromkeys(['Seq1',\r\n 's2 some other comment',\r\n 'S3 no comment'])\r\n\r\n actual = fake_output_f()\r\n filter_fasta(input_seqs,\r\n actual,\r\n seqs_to_keep,\r\n negate=False)\r\n self.assertEqual(actual.s, self.filter_fasta_expected1)\r\n\r\n actual = fake_output_f()\r\n filter_fasta(input_seqs,\r\n actual,\r\n seqs_to_keep,\r\n negate=True)\r\n self.assertEqual(actual.s, self.filter_fasta_expected2)","def filter_files(self, pattern, filter_fn=None):\n def filter_function(f):\n return re.search(pattern, f) != None\n if not filter_fn:\n filter_fn = filter_function\n return filter(filter_fn, self.files)","def regex_filter_list(file_list, pattern, output=True):\n r = re.compile(pattern)\n matches = filter(r.match, file_list)\n\n if (len(matches) > 0 and output is True):\n #print colors.BLUE + '\\033[1m' + \"matches:\" + '\\033[0m'\n for match in matches:\n print colors.BLUE + match + colors.ENDC\n\n return matches","def test_filtered_scan(self):\n self.run_scan(self.tempdir, self.root_fcount + self.nest_fcount, ext=\".txt\")","def filter_it(self, _filter):\n with open(self.path) as _file:\n for line in _file:\n tokens = self._tokenize(line)\n if tokens:\n _ip = tokens.group('ip')\n if _filter.match(_ip):\n yield line","def filter(self, regex_pattern: str) -> None:\n self._filter_attachment_list(regex_pattern)\n self._filter_url_list(regex_pattern)","def filter_by_regex(self, dictlist, fidname, regex, outputfidlist=[]):\n result = [item for item in dictlist if re.match(regex, item[fidname]) != None]\n return self.filter_output(result, outputfidlist)","def _filter_patterns(self, filepath, pattern_prefix, exclude_pattern, include_pattern):\n isfilter = False\n if exclude_pattern:\n full_exclude_pattern = os.path.join(pattern_prefix, exclude_pattern)\n if fnmatch.fnmatch(filepath, full_exclude_pattern):\n isfilter = True\n if include_pattern:\n full_include_pattern = os.path.join(pattern_prefix, include_pattern)\n if fnmatch.fnmatch(filepath, full_include_pattern):\n isfilter = False\n return isfilter","def filter_fastq_fp(input_seqs_fp, output_seqs_fp, seqs_to_keep, negate=False):\r\n input_seqs = parse_fastq(open(input_seqs_fp, 'U'), strict=False)\r\n output_f = open(output_seqs_fp, 'w')\r\n return filter_fastq(input_seqs, output_f, seqs_to_keep, negate)","def _filter(self, minLength=None, maxLength=None, removeGaps=False,\n whitelist=None, blacklist=None,\n titleRegex=None, negativeTitleRegex=None,\n truncateTitlesAfter=None, indices=None, head=None,\n removeDuplicates=False, modifier=None):\n if (whitelist or blacklist or titleRegex or negativeTitleRegex or\n truncateTitlesAfter):\n titleFilter = TitleFilter(\n whitelist=whitelist, blacklist=blacklist,\n positiveRegex=titleRegex, negativeRegex=negativeTitleRegex,\n truncateAfter=truncateTitlesAfter)\n else:\n titleFilter = None\n\n if removeDuplicates:\n sequencesSeen = set()\n\n for readIndex, read in enumerate(self):\n\n if head is not None and readIndex == head:\n # We're completely done.\n return\n\n readLen = len(read)\n if ((minLength is not None and readLen < minLength) or\n (maxLength is not None and readLen > maxLength)):\n continue\n\n if removeGaps:\n sequence = read.sequence.replace('-', '')\n read = read.__class__(read.id, sequence, read.quality)\n\n if (titleFilter and\n titleFilter.accept(read.id) == TitleFilter.REJECT):\n continue\n\n if indices is not None and readIndex not in indices:\n continue\n\n if removeDuplicates:\n if read.sequence in sequencesSeen:\n continue\n sequencesSeen.add(read.sequence)\n\n if modifier:\n modified = modifier(read)\n if modified is None:\n continue\n else:\n read = modified\n\n yield read","def filter_ignoring_case(self, pattern):\n return self.filter(re.compile(pattern, re.I))","def parseFasta(fh):\n\n record_seq = []\n record_id = None\n\n for line in fh:\n line = line.strip(\"\\n\")\n\n if line.startswith(\">\"):\n\n if record_seq:\n yield Record(record_id, \"\".join(record_seq))\n\n record_id = line[1:].split()[0]\n record_seq = []\n else:\n record_seq.append(line.replace(\"*\", \"-\"))\n\n if record_seq:\n yield Record(record_id, \"\".join(record_seq))","def pattern_filter(patterns, name):\n return [pat for pat in patterns if fnmatch.fnmatchcase(name, pat)]","def _filter_seqs(fn):\n out_file = op.splitext(fn)[0] + \"_unique.fa\"\n idx = 0\n if not file_exists(out_file):\n with open(out_file, 'w') as out_handle:\n with open(fn) as in_handle:\n line = in_handle.readline()\n while line:\n if line.startswith(\"@\") or line.startswith(\">\"):\n fixed_name = _make_unique(line.strip(), idx)\n seq = in_handle.readline().strip()\n counts = _get_freq(fixed_name)\n if len(seq) < 26 and (counts > 1 or counts == 0):\n idx += 1\n print(fixed_name, file=out_handle, end=\"\\n\")\n print(seq, file=out_handle, end=\"\\n\")\n if line.startswith(\"@\"):\n in_handle.readline()\n in_handle.readline()\n line = in_handle.readline()\n return out_file","def eliminate(file,patternlist,returnfile):\n\tf=open(file,\"r\")\n\tlines=f.readlines()\n\trep=True\n\twith open(returnfile,'w') as file:\n\t\tfor line in lines:\n\t\t\tfor i in patternlist:\n\t\t\t\tp=re.compile(i) \n\t\t\t\tif(p.search(line)):\n\t\t\t\t\trep=False\n\t\t\tif(rep==True):\n\t\t\t\tfile.write(line)\n\t\t\trep=True","def filter_fasta(input_seqs, output_seqs_f, seqs_to_keep, negate=False):\r\n seqs_to_keep_lookup = {}.fromkeys([seq_id.split()[0]\r\n for seq_id in seqs_to_keep])\r\n # Define a function based on the value of negate\r\n if not negate:\r\n def keep_seq(seq_id):\r\n return seq_id.split()[0] in seqs_to_keep_lookup\r\n else:\r\n def keep_seq(seq_id):\r\n return seq_id.split()[0] not in seqs_to_keep_lookup\r\n\r\n for seq_id, seq in input_seqs:\r\n if keep_seq(seq_id):\r\n output_seqs_f.write('>%s\\n%s\\n' % (seq_id, seq))\r\n output_seqs_f.close()","def filter_scan(scan, filter_pattern, parent):\n filter_line = scan.get('filterLine')\n filter_m = re.search(filter_pattern, filter_line)\n if filter_m is None:\n parent.remove(scan)\n return 0\n else:\n return 1","def filter(self, pattern):\n if isinstance(pattern, REGEX_TYPE):\n func = tools.filter_regex\n elif pattern.startswith('/'):\n pattern = re.compile(pattern.strip('/'))\n func = tools.filter_regex\n else:\n func = tools.filter_wildcard\n\n return SeeResult(func(self, pattern))","def transfer_filter(s, reg_exps, verbose=False):\n # Default: no match is found\n match = None\n\n # Reformat string to lowercase without new line characters\n s = s.replace('\\n', ' ').lower()\n\n # See if a match can be found with the unpredictable transfer filter regex\n match = reg_exps['re_trans_filter'].search(s)\n\n return match","def filterRansac():\n pass","def filtered_lines():\n\n with open(filename, 'r') as cds_file:\n for line in cds_file:\n if(\n line[0] not in '#-'\n and\n line[:2] != ' |'\n ):\n yield line","def grep(pattern, filename):\n rx = re.compile(pattern)\n with open(filename, 'r') as file:\n for line in file:\n if rx.search(line):\n yield line","def quality_matcher(fasta, full_fastq, filt_fastq, trunclen):\n with open(fasta, \"r\") as fasta, open(full_fastq, \"r\") as fastq, open(filt_fastq, \"w\") as new_fastq:\n #make lists of the fasta and fastq files, where every successive value is a successive line\n #purpose of -1: to avoid the \"\\n\" newline character at the end of the lines\n fastq_list = [line[:-1] for line in fastq]\n fasta_list = [line[:-1] for line in fasta]\n #iterate through the sequence ids in the fasta file\n for fasta_index, fasta_id in enumerate(fasta_list):\n if fasta_id[0] == \">\":\n #get the list index of the matching sequence id in the metagenomic fastq file\n fastq_index = fastq_list.index(\"@{}\".format(fasta_id[1:]))\n #print and write a new fastq entry with the quality scores string truncated to the same length as the sequence from the fasta file\n print(str(\"@{}\".format(fasta_id[1:])) + \"\\n\" + str(fasta_list[fasta_index+1]) + \"\\n\" + str(\"+{}\".format(fasta_id[1:])) + \"\\n\" + str(fastq_list[fastq_index+3][:int(trunclen)]))\n new_fastq.write(str(\"@{}\".format(fasta_id[1:])) + \"\\n\" + str(fasta_list[fasta_index+1]) + \"\\n\" + str(\"+{}\".format(fasta_id[1:])) + \"\\n\" + str(fastq_list[fastq_index+3][:int(trunclen)]))","def filter_before_parse(file_like):\n return file_like","def negative_filtering(patterns: list, file_list):\n if len(patterns) == 0:\n return file_list\n prog = re.compile(patterns.pop())\n it = (i for i in file_list if not prog.search(i))\n return negative_filtering(patterns, it)","def filter_text(self, text):\n yield from map(self._filter,\n (m.group(0) for m in re.finditer(self.pattern, text)))","def test_filter_regex(re_arg, re_src, re_dest):\n args = parser.parse_args(['-re', *re_arg])\n filters = renamer.initfilters(args)\n dest = renamer.get_renames(re_src, filters, args.extension, args.raw)\n assert dest == re_dest","def __init__(self, file_pattern):\n super(PlainTextFastaSource, self).__init__(\n file_pattern=file_pattern, splittable=False, validate=True)\n self.fasta_records_counter = metrics.Metrics.counter(\n self.__class__, 'label_fasta_records')","def ParseFilterFile(input_lines):\n # Strip comments and whitespace from each line and filter non-empty lines.\n stripped_lines = (l.split('#', 1)[0].strip() for l in input_lines)\n filter_lines = [l for l in stripped_lines if l]\n\n # Split the tests into positive and negative patterns (gtest treats\n # every pattern after the first '-' sign as an exclusion).\n positive_patterns = [l for l in filter_lines if l[0] != '-']\n negative_patterns = [l[1:] for l in filter_lines if l[0] == '-']\n return positive_patterns, negative_patterns","def regexSearch(regexStr, folderPath):\n if not os.path.isdir(folderPath):\n return 'Input a directory path'\n\n userRegex = re.compile(regex)\n\n for filename in os.listdir(folderPath):\n\n if filename.endswith('.txt'):\n\n with open(filename) as file:\n\n for line in file:\n mo = userRegex.search(line)\n \n if mo:\n print(line, end='')","def test_filter_mapping_file_from_mapping_f(self):\r\n actual = filter_mapping_file_from_mapping_f(\r\n self.tutorial_mapping_f, [\"PC.354\", \"PC.355\"])\r\n expected = \"\"\"#SampleID\tBarcodeSequence\tLinkerPrimerSequence\tTreatment\tDOB\tDescription\r\nPC.354\tAGCACGAGCCTA\tYATGCTGCCTCCCGTAGGAGT\tControl\t20061218\tControl_mouse_I.D._354\r\nPC.355\tAACTCGTCGATG\tYATGCTGCCTCCCGTAGGAGT\tControl\t20061218\tControl_mouse_I.D._355\"\"\"\r\n self.assertEqual(actual, expected)","def test_filter_fastq(self):\r\n input_seqs = [('Seq1 some comment', 'ACCTTGG', 'BBBBBBB'),\r\n ('s2 some other comment', 'TTGG', 'BBBB'),\r\n ('S3', 'AAGGCCGG', 'BBCtatcc'),\r\n ('S5 some comment', 'CGT', 'BBB'),\r\n ('seq6 some other comment', 'AA', 'BB'),\r\n ('S7', 'T', 's')]\r\n seqs_to_keep = {}.fromkeys(['Seq1',\r\n 's2 some other comment',\r\n 'S3 no comment'])\r\n\r\n actual = fake_output_f()\r\n filter_fastq(input_seqs,\r\n actual,\r\n seqs_to_keep,\r\n negate=False)\r\n self.assertEqual(actual.s, self.filter_fastq_expected1)\r\n\r\n actual = fake_output_f()\r\n filter_fastq(input_seqs,\r\n actual,\r\n seqs_to_keep,\r\n negate=True)\r\n self.assertEqual(actual.s, self.filter_fastq_expected2)","def filter(args):\n p = OptionParser(filter.__doc__)\n p.add_option(\n \"--less\",\n default=False,\n action=\"store_true\",\n help=\"filter the sizes < certain cutoff [default: >=]\",\n )\n p.set_outfile()\n\n opts, args = p.parse_args(args)\n\n if len(args) != 2:\n sys.exit(not p.print_help())\n\n fastafile, cutoff = args\n try:\n cutoff = int(cutoff)\n except ValueError:\n sys.exit(not p.print_help())\n\n f = Fasta(fastafile, lazy=True)\n\n fw = must_open(opts.outfile, \"w\")\n for name, rec in f.iteritems_ordered():\n\n if opts.less and len(rec) >= cutoff:\n continue\n\n if (not opts.less) and len(rec) < cutoff:\n continue\n\n SeqIO.write([rec], fw, \"fasta\")\n fw.flush()\n\n return fw.name","def test_filter_mapping_file_from_mapping_f_negate(self):\r\n actual = filter_mapping_file_from_mapping_f(self.tutorial_mapping_f,\r\n [\"PC.356\",\r\n \"PC.481\",\r\n \"PC.593\",\r\n \"PC.607\",\r\n \"PC.634\",\r\n \"PC.635\",\r\n \"PC.636\"],\r\n negate=True)\r\n expected = \"\"\"#SampleID\tBarcodeSequence\tLinkerPrimerSequence\tTreatment\tDOB\tDescription\r\nPC.354\tAGCACGAGCCTA\tYATGCTGCCTCCCGTAGGAGT\tControl\t20061218\tControl_mouse_I.D._354\r\nPC.355\tAACTCGTCGATG\tYATGCTGCCTCCCGTAGGAGT\tControl\t20061218\tControl_mouse_I.D._355\"\"\"\r\n self.assertEqual(actual, expected)","def text_file_search_all(cls, file, search_for, encoding='utf-8', search_using_regex=False,\n\t\t\t\t\t\t\t search_from_front_to_back=False, count=0):\n\n\t\tif search_for == '':\n\t\t\treturn None\n\t\ttry:\n\t\t\tresult = []\n\t\t\twith open(file, mode='r', encoding=encoding) as file_reader:\n\t\t\t\tfor line in file_reader if search_from_front_to_back else cls.reverse_file_reader(file_reader,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t save_memory=True):\n\t\t\t\t\tif not search_using_regex:\n\t\t\t\t\t\tif not line.find(search_for) == -1:\n\t\t\t\t\t\t\tresult.append(search_for)\n\n\t\t\t\t\telse:\n\t\t\t\t\t\tsearch_for_re = re.compile(search_for)\n\t\t\t\t\t\tre_result = re.search(search_for_re, line)\n\t\t\t\t\t\tif re_result:\n\t\t\t\t\t\t\tresult.append(re_result.group())\n\t\t\t\t\tif 0 < count == len(result):\n\t\t\t\t\t\tbreak\n\t\t\t\tif not result:\n\t\t\t\t\treturn None\n\t\t\t\telse:\n\t\t\t\t\treturn result\n\t\texcept Exception as e:\n\t\t\tprint(e)\n\t\t\treturn None","def main(pattern, i=stdin, o=stdout, only_matching=False):\n sre = re.compile(pattern)\n with i as i, o as o:\n for line in i:\n match = sre.match(line)\n if match:\n if only_matching:\n o.write(\"%s\\n\" % match.groups()[0])\n else:\n o.write(line)","def _filter_attachment_list(self, regex_pattern: str) -> None:\n matcher = re.compile(regex_pattern)\n filtered_list = []\n if self.attachment_list:\n for attachment in self.attachment_list:\n if matcher.search(attachment.attachment_name):\n filtered_list.append(attachment)\n self.attachment_list = filtered_list","def read_fasta(amplicon_file, minseqlen):\n with gzip.open(amplicon_file) as file:\n sequences = file.readlines()\n seqs = \"\"\n for sequence in sequences:\n #print(\"sequence\")\n seq = sequence.replace(b\"\\n\", b\"\")\n seq = seq.decode('utf8')\n #print(seq)\n for character in seq:\n if character not in \"TGAC\":\n if len(seqs)>=minseqlen:\n yield seqs\n #print(seqs)\n seq = \"\"\n seqs = \"\"\n break\n seqs += seq\n #print(seqs)\n yield seqs","def fsearch(self,pattern,msg=None, killon=None ):\n import re\n current=0\n cpat=re.compile(pattern)\n\n for num,line in enumerate(self.f):\n if killon:\n kill = re.search(killon,line)\n if kill:\n # the kill phrase was found first, so die. \n return False\n current=re.search(cpat,line)\n if current:\n if msg:\n print msg\n break\n if not current:\n# print 'ERROR: Requested pattern ('+pattern+') not found in file: <'+self.f.name+ '>. Check file for correct structure. Exiting...'\n return False\n\n return line","def _filter_subreads(self):\n logging.info(\"Start to filter subreads in fofn.\")\n if op.exists(self.ori_all_reads_fasta) and self.force_redo is not True:\n msg = \"{fa} already exists, skip pls2fasta\".format(fa=self.ori_all_reads_fasta)\n logging.warn(msg)\n else:\n logging.debug(\"{f} does not exist, call pls2fasta\".\n format(f=self.ori_all_reads_fasta))\n filter_summary = op.join(self.filtered_region_dir,\n \"filtered_summary.csv\")\n cmd = \"filter_plsh5.py --debug \" + \\\n \"--filter='MinReadScore=0.80,MinSRL=500,MinRL=100' \" + \\\n \"--trim='True' --outputDir={fr} \".format(\n fr=self.filtered_region_dir) + \\\n \"--outputSummary={sm} \".format(sm=filter_summary) + \\\n \"--outputFofn={rgn} \".format(rgn=self.region_fofn) + \\\n \"{in_fofn}\".format(in_fofn=self.input_fofn)\n logging.info(\"CMD: {cmd}\".format(cmd=cmd))\n _o, _c, _m = backticks(cmd)\n if _c != 0:\n raise RuntimeError(\"CMD failed. \" + str(_o) + ' ' + str(_m))\n\n cmd = \"pls2fasta -trimByRegion \" + \\\n \"-regionTable {rgn} \".format(rgn=self.region_fofn) + \\\n \"{fofn} {fa} \".format(fofn=self.input_fofn,\n fa=self.ori_all_reads_fasta)\n logging.info(\"CMD: {cmd}\".format(cmd=cmd))\n _o, _c, _m = backticks(cmd)\n if _c != 0:\n raise RuntimeError(\"CMD failed. \" + str(_o) + ' ' + str(_m))\n logging.info(\"{f} created.\".format(f=self.ori_all_reads_fasta))\n\n logging.debug(\"Copying {ori_f} to {f}.\".format(\n ori_f=self.ori_all_reads_fasta, f=self.all_reads_fasta))\n shutil.copyfile(self.ori_all_reads_fasta, self.all_reads_fasta)","def test_filter_sff_file(self):\r\n\r\n try:\r\n fh = open(self.tiny_test)\r\n except IOError:\r\n self.fail(\r\n \"Could not open test file %s. Skipping test\" %\r\n self.tiny_test)\r\n\r\n # With no filters all flowgram should be in out file\r\n flowgrams, header = lazy_parse_sff_handle(fh)\r\n filter_list = []\r\n fd, out_file_name = mkstemp(\r\n prefix=\"test_filter_sff_file\",\r\n suffix=\".sff.txt\")\r\n close(fd)\r\n out_fh = open(out_file_name, \"w\")\r\n l = filter_sff_file(flowgrams, header, filter_list, out_fh)\r\n remove(out_file_name)\r\n fh.close()\r\n self.assertEqual(l, 114)\r\n\r\n # With good filters some should survive\r\n fh = open(self.tiny_test)\r\n flowgrams, header = lazy_parse_sff_handle(fh)\r\n filter_list = [lambda f:within_length(f, 100, 300)]\r\n fd, out_file_name = mkstemp(\r\n prefix=\"test_filter_sff_file\",\r\n suffix=\".sff.txt\")\r\n close(fd)\r\n out_fh = open(out_file_name, \"w\")\r\n l = filter_sff_file(flowgrams, header, filter_list, out_fh)\r\n remove(out_file_name)\r\n fh.close()\r\n self.assertEqual(l, 112)\r\n\r\n # With strong filters nothing should be in\r\n fh = open(self.tiny_test)\r\n flowgrams, header = lazy_parse_sff_handle(fh)\r\n filter_list = [lambda f:within_length(f, 0, 0)]\r\n fd, out_file_name = mkstemp(\r\n prefix=\"test_filter_sff_file\",\r\n suffix=\".sff.txt\")\r\n close(fd)\r\n out_fh = open(out_file_name, \"w\")\r\n l = filter_sff_file(flowgrams, header, filter_list, out_fh)\r\n remove(out_file_name)\r\n self.assertEqual(l, 0)","def test_filter_mapping_file_from_mapping_f_negate(self):\n actual = filter_mapping_file_from_mapping_f(self.tutorial_mapping_f,\n [\"PC.356\", \"PC.481\", \"PC.593\", \"PC.607\", \"PC.634\", \"PC.635\", \"PC.636\"],\n negate=True)\n expected = \"\"\"#SampleID\tBarcodeSequence\tLinkerPrimerSequence\tTreatment\tDOB\tDescription\nPC.354\tAGCACGAGCCTA\tYATGCTGCCTCCCGTAGGAGT\tControl\t20061218\tControl_mouse_I.D._354\nPC.355\tAACTCGTCGATG\tYATGCTGCCTCCCGTAGGAGT\tControl\t20061218\tControl_mouse_I.D._355\"\"\"\n self.assertEqual(actual,expected)","def filter_samfile(temp_alignment, filtered_out):\n # Check the quality and status of each aligned fragment.\n # Write the ones with good quality in the final output file.\n # Keep those that do not map unambiguously for the next round.\n\n unaligned = set()\n temp_sam = ps.AlignmentFile(temp_alignment, \"r\")\n outf = ps.AlignmentFile(filtered_out, \"w\", template=temp_sam)\n for r in temp_sam:\n if r.flag in [0, 16] and r.mapping_quality >= 30:\n outf.write(r)\n else:\n unaligned.add(r.query_name)\n\n print(\"{0} reads left to map.\".format(len(unaligned)))\n temp_sam.close()\n outf.close()\n\n return unaligned","def filter_reads(alignment_file, readdb, read_dirs, quality_threshold=7, recursive=False, trim=False):\n assert alignment_file.endswith(\"bam\"), \"Alignment file must be in BAM format: {}\".format(alignment_file)\n # grab aligned segment\n if trim:\n assert isinstance(trim, int), \"Trim needs to be an integer: {}\".format(trim)\n else:\n trim = np.inf\n n_bases = 0\n n_files = 0\n with closing(pysam.AlignmentFile(alignment_file, 'rb')) as bamfile:\n name_indexed = pysam.IndexedReads(bamfile)\n name_indexed.build()\n for name, fast5 in parse_read_name_map_file(readdb, read_dirs, recursive=recursive):\n try:\n if trim < n_bases:\n print(\"Filtered {} files for {} bases\".format(n_files, n_bases))\n break\n iterator = name_indexed.find(name)\n for aligned_segment in iterator:\n if aligned_segment.is_secondary or aligned_segment.is_unmapped \\\n or aligned_segment.is_supplementary or aligned_segment.has_tag(\"SA\"):\n continue\n # get data and sanity check\n if aligned_segment.query_qualities is not None:\n if np.mean(aligned_segment.query_qualities) < quality_threshold:\n continue\n n_files += 1\n n_bases += aligned_segment.query_length\n yield fast5, aligned_segment\n except KeyError:\n print(\"Found no alignments for {}\".format(fast5))","def filename_filter ( self, filename, _fnmatch=fnmatch.fnmatch ):\n return all (\n not _fnmatch ( filename, pat ) for pat in self.FILENAMES_IGNORE\n )","def remove_matching_reads(filename, cont_file):\n if not os.path.exists(cont_file + '.bwt'):\n cml = shlex.split('bwa index %s' % cont_file)\n subprocess.call(cml)\n cml = 'bwa mem -t 2 %s %s 2> /dev/null | samtools view -f 4 -h - | samtools bam2fq - ' % (cont_file, filename)\n cml += '| seqtk seq -A - > clean_reads.fasta'\n\n subprocess.call(cml, shell=True)\n return 'clean_reads.fasta'","def autoSaveFilter(filename):","def readFasta(self, fastaFile):\t\n\t\tname, seq = None, []\n\t\tfor line in fastaFile:\n\t\t\tline = line.rstrip()\n\t\t\tif (line.startswith(\">\")):\n\t\t\t\tif name: yield (name, ''.join(seq))\n\t\t\t\tname, seq = line, []\n\t\t\telse:\n\t\t\t\tseq.append(line)\n\t\tif name: yield (name, ''.join(seq))","def filter_sequences(parent_directory, filename, label = 'Pfam:'):\n uniprot, repeated_seqs = load_uniprot('{}/{}'.format(parent_directory, filename))\n seq_fam = {}\n \n for u in uniprot:\n # Only select those sequences\n # - With the correct label\n # - That do not contain illegal characters\n # - Do not include sequences that are in multiple families\n index = find_index(u.dbxrefs, lambda x: x.startswith(label))\n if index != -1 and len(set(u._seq._data) - set(alphabet)) == 0 and u._seq._data not in repeated_seqs:\n seq_fam[u._seq._data] = u.dbxrefs[index][len(label):]\n \n filtered_fam = filtered_families(seq_fam)\n \n # Write processed output to a separate file\n with open('{}/processed.txt'.format(parent_directory), 'w') as f:\n f.write('\\n'.join(' '.join((fam, seq))\n for seq, fam in seq_fam.items()\n if fam in filtered_fam))","def test_filter_mapping_file_from_mapping_f(self):\n actual = filter_mapping_file_from_mapping_f(self.tutorial_mapping_f,[\"PC.354\",\"PC.355\"])\n expected = \"\"\"#SampleID\tBarcodeSequence\tLinkerPrimerSequence\tTreatment\tDOB\tDescription\nPC.354\tAGCACGAGCCTA\tYATGCTGCCTCCCGTAGGAGT\tControl\t20061218\tControl_mouse_I.D._354\nPC.355\tAACTCGTCGATG\tYATGCTGCCTCCCGTAGGAGT\tControl\t20061218\tControl_mouse_I.D._355\"\"\"\n self.assertEqual(actual,expected)","def filt(seq, lst):\n regex = \"(\" + \")|(\".join(seq) + \")\"\n regex = re.compile(regex)\n slst = list(filter(regex.search, lst))\n return slst\n\n\n # still need a checkUsername function ","def fasta_iter_py3(fasta_name):\n rec = None\n for line in open(fasta_name, \"r\"):\n if line[0] == \">\":\n if rec:\n yield rec\n rec = FastaRecord(line.strip()[1:])\n else:\n rec.sequence += line.strip()\n\n if rec:\n yield rec","def readFastaFile(filename):","def fasta(file_path):\n \n print(f\"Parsing fasta '{file_path}'\")\n data = {\n 'ur_up_': [], 'accession': [],\n 'entry_name': [], 'offset': [],\n 'taxonomy': [], 'sequence': []\n }\n\n with open(file_path, 'r') as f:\n for i, line in enumerate(f):\n line = line.strip()\n \n if line[0] == '>':\n key = line[1:]\n \n if i == 0:\n name, offset = key.split(\"/\")\n ur_up_, acc = None, None\n else:\n ur_up_, acc, name_offset = key.split(\"|\")\n name, offset = name_offset.split('/')\n \n data['ur_up_'].append(ur_up_)\n data['accession'].append(acc)\n data['entry_name'].append(name)\n data['offset'].append(offset)\n data['sequence'].append('')\n data['taxonomy'].append(name.split('_')[1])\n else:\n data['sequence'][-1] += line\n \n if i and (i % 50000 == 0):\n print(f\"Reached: {i}\")\n\n return pd.DataFrame(data=data)","def search_file_all(pattern, filename):\n if not os.path.exists(filename):\n raise Exception(\"Can't open file for reading! \" + filename)\n\n matches = []\n fh = open(filename, \"r\")\n for line in fh:\n allmatch = re.findall(pattern, line)\n if allmatch:\n matches += allmatch\n\n fh.close()\n return matches","def readFastaFile(filename):\n if os.path.exists(filename)==False:return {}\n sequences={}\n fhr=open(filename,\"r\")\n for line in fhr:\n if line[0]==\">\":\n sequences[line.strip()[1:].split()[0]]=fhr.readline().strip()\n fhr.close()\n return sequences","def fasta_reader(fasta):\n # ditch the boolean (x[0]) and just keep the header/seq grouping\n fa_iter = (x[1] for x in itertools.groupby(fasta, lambda line: line[0] == \">\"))\n for header in fa_iter:\n # drop the \">\"\n name = next(header)[1:].strip()\n # join all sequence lines to one by iterating until the next group.\n read = \"\".join(s.strip() for s in next(fa_iter))\n yield name, read","def play_with_regex():\n\n DNA_string = \"ATTTGTATGTTCGGCTAACTTCTACCCATCCCCCGAAGTTTAGCAGGTCGTGAGGTGTCATGGAGGCTCTCGTTCATCCCGTGGGACATCAAGCTTCGCCTTGATAAAGCACCCCGCTCGGGTGTAGCAGAGAAGACGCCTACTGAATTGTGCGATCCCTCCACCTCAGCTAAGGTAGCTACCAATATTTAGTTTTTTAGCCTTGCGACAGACCTCCTACTTAGATTGCCACGCATTGAGCTAGCGAGTCAGCGATAAGCATGACGCGCTTTCAAGCGTCGCGAGTATGTGAACCAAGGCTCCGGACAGGACTATATACTTGGGTTTGATCTCGCCCCGACAACTGCAAACCTCAACATTTATAGATTATAAGGTTAGCCGAAATTGCACGTGGTGGCGCCCGCCGACTGCTCCCCGAGTGTGGCTCTTTGATCTGACAACGCGCGACCTCCATCGCGGCCGATTGTTTCTGCGGACCATGTCGTCCTCATAGTTTGGGCATGTTTCCGTTGTAGGAGTGAAGCCACTTAGCTTTGCGCCGTAGTCCCAATGAAAAACCTATGGACTTTGTTTTGGGTAGCATCAGGAATCTGAACCCTGTGAATGTGGGGGTCGCGCGCATAGACCTTTATCTCCGGTTCAAGTTAGGCATGAGGCTGCATGCTACGTTGTCACACCTACACTGCTCGAAGTAAATATGGGAAGCGCGCGGCCTGGCCCGAGGCGTTCCGCGCCGCCACGTGTTCGTTAACTGTTGATTGGTGGCACATAAGCAATACCGTAGTCCCTCAAATTCAGCTCTGTTATCTCGAGCGTTATGTGTCAAATGGCGTAGAACGGGATTGACTGTTTGACACTAGCTGGTGTTCGGTTCGGTAACGGAGAATCTGTGGGGCTATGTCACTAATACTTTCGAAACGCCCCGTACCGATGCTGAACAAGTCGATGCAGGCTCCCGTCTTTGAATAGGGGTAAACATACAAGTCGATAGAAGATGGGT\"\n \n # 1. check if DNA_string starts with \"ATTTGTATG\" (say with re.search() or re.findall())\n regex = re.compile('ATTTGTATG')\n m = regex.search(DNA_string)\n \n # 2. use re.findall() if there are instances of 5 or more consecutive c's in DNA_string\n m = re.finditer('C{5,}',DNA_string)\n for entry in m:\n print entry.span()\n \n # 3. find instances of the motif GGXY in the DNA sequence \n # where X={A,C,G,T} and Y={C,T}\n m = re.finditer('GG[ACGT][CT]',DNA_string)\n print \"NUMBER 3\"\n for entry in m:\n print entry.span()","def readFiltered(f):\n line = f.readline()\n while line:\n line = line.strip()\n if len(line) != 0:\n if line == \"### NEW EXPERIMENT ###\":\n # print (\"readFiltered: ''\")\n yield \"\"\n elif line[0] != \"#\":\n # print (\"readFiltered: '\",line,\"'\")\n yield line\n line = f.readline()\n # print (\"readFiltered: '\",line,\"'\")\n return line","def read_fasta(fasta_name):\n \n \"\"\"first open the file outside \"\"\"\n file_handler = open(fasta_name)\n\n # ditch the boolean (x[0]) and just keep the header or sequence since\n # we know they alternate.\n fasta_iter = (x[1] for x in groupby(file_handler, lambda line: line[0] == \">\"))\n\n for header in fasta_iter:\n # drop the \">\"\n headerStr = header.__next__()[1:].strip()\n\n # join all sequence lines to one.\n seq = \"\".join(s.strip() for s in fasta_iter.__next__())\n\n # yield (headerStr, seq)\n result_record = {'header':headerStr,'seqRecord':seq}\n return result_record","def search(self):\n apk_files = self.apk.get_files_types()\n search_results = []\n for file_path, file_type in apk_files.iteritems():\n file_ext = os.path.splitext(os.path.basename(file_path))[1]\n\n #if file type filter on, and this file is not that type, then skip\n if self.file_types and not any(interested_type in file_type.lower() or interested_type in file_ext for interested_type in self.file_types):\n continue\n\n search_result = None\n file_data = self.apk.get_file(file_path)\n\n if self.search_strings:\n for pattern in self.patterns:\n match = pattern.search(file_data)\n if match:\n search_result = {'file_path': file_path,\n 'file_type': file_type,\n 'search_string': pattern.pattern}\n search_results.append(search_result)\n else:\n search_result = {'file_path': file_path,\n 'file_type': file_type,\n 'search_string': None}\n search_results.append(search_result)\n\n #write individual files\n if search_result and self.save_matched_files_dir:\n #save original structure to avoid duplicate filename collisions\n save_file_path = os.path.join(self.save_matched_files_dir, file_path)\n if not os.path.exists(os.path.dirname(save_file_path)):\n os.makedirs(os.path.dirname(save_file_path))\n\n with open(save_file_path,'wb') as f:\n f.write(file_data)\n\n if 'Android binary XML' in file_type:\n with open(save_file_path,'r+') as axml_f:\n decoded_axml = AXMLPrinter(axml_f.read()).buff\n axml_f.seek(0)\n axml_f.write(decoded_axml)\n axml_f.truncate()\n\n return search_results","def text_file_search(cls, file: str, search_for: str, encoding: str = 'utf-8', search_using_regex: bool = False,\n\t\t\t\t\t\t search_from_front_to_back: bool = False):\n\n\t\tresult = cls.text_file_search_all(file, search_for, encoding, search_using_regex,\n\t\t\t\t\t\t\t\t\t\t search_from_front_to_back, count=1)\n\n\t\treturn result[0] if result else None","def filterMapNames(regexText, records=getIndex(), excludeRegex=False, closestMatch=True):\n bestScr = 99999 # a big enough number to not be a valid file system path\n regex = re.compile(regexText, flags=re.IGNORECASE)\n ret = []\n if excludeRegex: # match only records that do NOT contain regex\n if regexText and closestMatch: # then maps with fewer characters are better matches\n for m in list(records):\n if re.search(regex, m.name): continue # map must NOT contain specified phrase\n score = len(m.name) # the map with the smallest map name means it has the largets matching character percentage\n if score == bestScr:\n bestScr = score\n ret.append(m)\n elif score < bestScr: # new set of best maps\n bestScr = score\n ret = [m]\n else: # all maps that match regex are included\n for m in list(records):\n if re.search(regex, m.name): continue # map must NOT contain specified phrase\n ret.append(m) # any mapname containing regex matches\n else: # only match records that contain regex\n if regexText and closestMatch: # then maps with fewer characters are better matches\n for m in records:\n if not re.search(regex, m.name): continue # map must contain specified phrase if excludeRegex==True\n score = len(m.name) # the map with the smallest map name means it has the largets matching character percentage\n if score == bestScr:\n bestScr = score\n ret.append(m)\n elif score < bestScr: # new group of best maps\n bestScr = score\n ret = [m]\n else: # all maps that match regex are included\n for m in records:\n if not re.search(regex, m.name): continue # map must contain specified phrase if excludeRegex==True\n ret.append(m) # any mapname containing regex matches\n return ret","def filter_on_regexp(strings, pattern):\n filtered_strings = filter(lambda x: re.search(pattern, x), strings)\n return filtered_strings","def grep_me(pattern, fname):\n for line in stream_reader(fname):\n if re.search(pattern, line, re.I):\n print('{}:{}:{}'.format(filename(), filelineno(), line), end='')","def filter_sff_file(flowgrams, header, filter_list, out_fh):\r\n\r\n write_sff_header(header, out_fh)\r\n\r\n l = 0\r\n for f in flowgrams:\r\n passed = True\r\n for filter in filter_list:\r\n passed = passed and filter(f)\r\n if not passed:\r\n # bail out\r\n break\r\n if (passed):\r\n out_fh.write(f.createFlowHeader() + \"\\n\")\r\n l += 1\r\n return l","def search(self, filtr):\n return [note for note in self.notes if note.match(filtr)]","def filter_fastq(input_seqs, output_seqs_f, seqs_to_keep, negate=False):\r\n seqs_to_keep_lookup = {}.fromkeys([seq_id.split()[0]\r\n for seq_id in seqs_to_keep])\r\n # Define a function based on the value of negate\r\n if not negate:\r\n def keep_seq(seq_id):\r\n return seq_id.split()[0] in seqs_to_keep_lookup\r\n else:\r\n def keep_seq(seq_id):\r\n return seq_id.split()[0] not in seqs_to_keep_lookup\r\n\r\n for seq_id, seq, qual in input_seqs:\r\n if keep_seq(seq_id):\r\n output_seqs_f.write('@%s\\n%s\\n+\\n%s\\n' % (seq_id, seq, qual))\r\n output_seqs_f.close()","def file_name_search():\n directory = \"/Users/andrewpowers/Documents/server/fastq_pass\"\n\n for file in os.listdir(directory):\n output_file = re.sub('fastq', 'fasta', file)\n os.system(bash_command.format(directory+\"/\"+file, output_file))\n print('File {} converted to fasta.'.format(file))\n print('Conversion Done.')","def _filterTaxa(self, taxaString):\n if self.taxRegex is None:\n if not self.taxFilterType in regexTaxFilters:\n self.taxFilterType = re.compile(taxFilterType)\n else:\n self.taxFilterType = regexTaxFilters[taxFilterType]\n\n try:\n #Parse out genus and species if exists\n taxInfo = self.taxFilterType.findall(taxaString)[0] \n if len(taxInfo.split()) == 1: \n #Error finding taxonomic info\n taxInfo = taxaString\n except:\n taxInfo = taxaString\n finally:\n #Only return HSP if the filter is not found within the taxInfo string\n return self.taxFilter not in taxInfo","def parse_text(filehandle: TextIO) -> Iterator[Fasta]:\n\n # Check that the file looks like UniProt text format\n first_line = next(filehandle)\n if not first_line.startswith(\"ID\"):\n raise TextParserError(\n \"Unexpected file format: first line of UniProt text file should start with 'ID'\"\n )\n filehandle.seek(0)\n\n fasta = Fasta(sequence=\"\")\n for line in filehandle:\n key = line[:2] # This is more efficient than using line.startswith\n if key == \"ID\":\n tokens = line.split()\n fasta.entry_name = tokens[1]\n fasta.reviewed = True if tokens[2] == \"Reviewed;\" else False\n elif key == \"AC\":\n if fasta.accession is None:\n accessions = line[5:].rstrip(\";\\n\").split(\"; \")\n fasta.accession = accessions[0]\n elif key == \"DT\":\n if \"sequence version\" in line:\n tokens = line[5:].strip(\".\\n\").split()\n fasta.version = int(tokens[3])\n elif key == \"DE\":\n if \"RecName\" in line:\n fasta.name = _extract_name(line)\n # Get the first SubName if no RecName found\n elif fasta.name is None and line[5:12] == \"SubName\":\n fasta.name = _extract_name(line)\n elif line[5:10] == \"Flags\" and \"Fragment\" in line:\n fasta.fragment = True\n elif key == \"GN\":\n if line[5:10] == \"Name=\":\n tokens = line[10:].split(\";\")\n # Remove evidence tags, if present\n gene_tokens = tokens[0].split(\" {\")\n fasta.gene = gene_tokens[0]\n elif key == \"OS\":\n # TODO: check for multiline species name (excluding brackets)\n if fasta.species is None:\n species_line = line[5:].strip().split(\" (\")\n fasta.species = species_line[0].strip(\".\")\n elif key == \"OX\":\n if \"NCBI_TaxID\" in line:\n tokens = line[5:].strip(\";\\n\").split(\"; \")\n # Remove evidence tag if present\n taxid_tokens = tokens[0][11:].split(\" {\")\n fasta.taxid = taxid_tokens[0]\n elif key == \"PE\":\n fasta.evidence = int(line[5])\n elif key == \" \":\n sequence_line = line.strip().replace(\" \", \"\")\n fasta.sequence += sequence_line\n elif key == \"//\":\n yield fasta\n fasta = Fasta(sequence=\"\")","def fnmatch_filter(names, pat):\r\n import os,posixpath\r\n result=[]\r\n pat=os.path.normcase(pat)\r\n if not pat in _cache:\r\n res = translate(pat)\r\n if len(_cache) >= _MAXCACHE:\r\n _cache.clear()\r\n _cache[pat] = re.compile(res)\r\n match=_cache[pat].match\r\n if os.path is posixpath:\r\n # normcase on posix is NOP. Optimize it away from the loop.\r\n for name in names:\r\n m = match(name)\r\n if m:\r\n result.append((name, m.groups()))\r\n else:\r\n for name in names:\r\n m = match(os.path.normcase(name))\r\n if m:\r\n result.append((name, m.groups()))\r\n return result","def filterfn(read):\n return (read.is_proper_pair and read.is_paired and read.tlen > 0 and not read.is_supplementary and not read.is_duplicate and not read.is_unmapped and not read.mate_is_unmapped)","def gen_grep(pattern, lines):\n pat = re.compile(pattern)\n for line in lines:\n if pat.search(line):\n yield line","def process_fasta(file, type):\n seqs = []\n with open(file) as f:\n seq = f.readline().strip()\n seq = seq + '\\t'\n for line in f:\n line = line.strip()\n if line[0] == \">\":\n s1 = seq.split('\\t')\n bac = s1[0].split(\"|\")[2]\n sequence = to_word_index(s1[1], type)\n seqs.append([bac, sequence])\n seq = line + '\\t'\n else:\n seq = seq + line\n\n s1 = seq.split('\\t')\n bac = s1[0].split(\"|\")[2]\n sequence = to_word_index(s1[1], type)\n seqs.append([bac, sequence])\n\n df = pd.DataFrame(seqs, columns=['bacteria', 'sequence'])\n df = shuffle(df)\n\n return df","def filter(self, *args):\n exps = []\n\n #this ones can be improved. some are not getting extracted\n if \"retweets\" in args:\n exps.append(re.compile(\"^RT ?(?<=^|(?<=[^a-zA-Z0-9-_\\.]))@([A-Za-z]+[A-Za-z0-9-_]+):\"))\n if \"emoticons\" in args:\n exps.append(\"emoticons\")\n if \"flags\" in args:\n exps.append(re.compile(u\"[\\U0001F1E6-\\U0001F1FF]\"))\n if \"handles\" in args:\n # Handles at start of string\n exps.append(re.compile(\"^\\s*((?<=^|(?<=[^\\S]))@([\\S]+)\\s*)*\"))\n # Handles at end of string\n exps.append(re.compile(\"\\s+((?<=^|(?<=[^\\S]))@(\\S+)\\s*)*$\"))\n if \"urls\" in args:\n exps.append(re.compile(\"(https?|ftp)://[^\\s/$.?#].[^\\s]*\"))\n if \"hashtags\" in args:\n # Hastags at start of string\n exps.append(re.compile(\"^\\s*((?<=^|(?<=[^\\S]))#([\\S]+)\\s*)*\"))\n # Hashtags at end of string\n exps.append(re.compile(\"\\s+((?<=^|(?<=[^\\S]))#(\\S+)\\s*)*$\"))\n\n\n # Use all filters\n if \"*\" in args and not exps:\n return self.filter(\"retweets\", \"emoticons\", \"flags\", \"handles\", \"urls\", \"hashtags\")\n\n filtering_text = self.raw_text\n\n for expression in exps:\n if expression == \"emoticons\":\n filtering_text = ''.join(c for c in filtering_text if c not in emoji.UNICODE_EMOJI)\n else:\n filtering_text = re.sub(expression, \"\", filtering_text)\n\n # Remove extra spaces\n self.clean_text = re.sub(r\"\\s\\s+\", ' ', filtering_text.strip())\n return self.clean_text","def filter_by_minimum_length(\n self, min_length: int, output_file: Path = None, point_to_new_file: bool = True\n ) -> None:\n if output_file is None:\n output_file = (\n Path(self._input_file.parent)\n / f\"{self._input_file.stem}_minlength{self._input_file.suffix}\"\n )\n else:\n output_file = Path(output_file)\n fasta = pyfastx.Fasta(\n self.file_path.as_posix(), build_index=False, full_name=True\n )\n with open(output_file, \"w+\", encoding=\"UTF-8\") as outfile:\n for record_name, record_seq in fasta:\n if len(record_seq) >= min_length:\n outfile.write(f\">{record_name}\\n{record_seq}\\n\")\n if point_to_new_file:\n self.file_path = output_file","def readFasta(self, fp):\n\t\t\n\t\tfor head, seq in self.parseFasta(fp):\n\t\t\t#analyzing the sequence\n\t\t\tself.analyzeSequence(seq)\n\t\t\t#saving the header\n\t\t\tif head == '':\n\t\t\t\tcontinue\n\t\t\telse:\t\n\t\t\t\tself.header.append(head)","def filter_matches(filename, e):\n transcription_factors = []\n with open(filename) as f:\n for record in NCBIXML.parse(f):\n best = e\n if record.alignments:\n for alignment in record.alignments:\n for hsp in alignment.hsps:\n if hsp.expect < best:\n best = hsp.expect\n\n if best < e:\n iden = record.query.split(\" \")[0]\n locus = iden.split(\"|\")[1]\n transcription_factors.append(locus)\n\n return transcription_factors","def filter_lines(lines, filter_regex, groups=None):\n pattern = re.compile(filter_regex)\n for line in lines:\n match = pattern.search(line)\n if match:\n if groups is None:\n yield line\n elif len(groups) == 1:\n yield match.group(groups[0])\n else:\n matched_groups = match.groupdict()\n yield tuple(matched_groups.get(group) for group in groups)","def scan(self, pat):\n re_pat = re.compile(pat)\n for infilename in self.file_names:\n infile = open(infilename, 'r')\n for line in infile:\n line = line.rstrip()\n mo = re_pat.search(line)\n if mo is not None:\n print '%s:%s' % (infilename, line, )","def get_filtered_record(csv_fname):\n with open(csv_fname, \"r\") as student_records:\n for student_record in csv.reader(student_records):\n converted = [re.sub('[^a-z0-9]+', '', x.lower()) for x in student_record]\n yield converted","def filter(self, line):\n items = line.strip(\"\\n\").split(\"\\t\")\n read_name = items[0]\n strand = items[1]\n ref_seq = items[2]\n coord = int(items[3])\n attr = {\n 'seq_as_aligned' : items[4],\n 'qualstr' : items[5],\n 'mismatch_str' : items[7],\n 'type' : \"alignment\",\n 'ID' : read_name,\n } # yapf: disable\n\n iv = GenomicSegment(ref_seq, coord, coord + len(attr['seq_as_aligned']), strand)\n feature = SegmentChain(iv, **attr)\n return feature","def filterAudioFilesFromFilelist(filelist):\n audioFileList = []\n for audioFilter in filelist:\n audioRoot, audioExt = os.path.splitext(audioFilter)\n if audioExt in ['.wav', '.aiff', '.aif']:\n audioFileList.append(audioFilter)\n # end for loop\n return audioFileList","def test_write_trunc_fasta(self):\r\n\r\n seq_order = ['seq1', 'seq2', 'seq3']\r\n\r\n seqs = {'seq1': 'ATCG', 'seq3': 'ACCC', 'seq2': 'GGACC'}\r\n\r\n output_dir = '/tmp/truncate_fasta_qual_test/'\r\n\r\n create_dir(output_dir)\r\n\r\n fasta_out_fp = output_dir + 'seqs_filtered.fna'\r\n\r\n write_trunc_fasta(seqs, fasta_out_fp, seq_order)\r\n\r\n expected_seqs = ['>seq1', 'ATCG', '>seq2', 'GGACC', '>seq3', 'ACCC']\r\n\r\n actual_fasta = open(fasta_out_fp, \"U\")\r\n\r\n actual_fasta = [line.strip() for line in actual_fasta]\r\n\r\n self.assertEqual(actual_fasta, expected_seqs)","def fastq_to_fasta(input_file, wanted_set):\n file_name = os.path.splitext(os.path.basename(input_file))[0]\n with open(file_name + \"_filtered.fasta\", \"w\") as out:\n for record in SeqIO.parse(input_file, \"fastq\"):\n ID = str(record.id)\n SEQ = str(record.seq)\n if ID in wanted_set:\n out.write(\">\" + ID + \"\\n\" + SEQ + \"\\n\")","def regex_filter(regex_str, versions):\n regex = re.compile(regex_str)\n return [v for v in versions if regex.search(v)]","def is_fastq_regex(fastq_regex):\n if \"{sample}\" not in fastq_regex:\n raise argparse.ArgumentTypeError(\n \"The regex should contain at least the wildcard '{sample}'.\")\n return fastq_regex","def filterPotentialChimeras(self, min_length=30, flag=0, target=None):\n logger.debug('Filtering {} for potential chimeras'.format(target))\n target = '{}.filter.fasta'.format(target.rpartition(\".\")[0])\n if os.path.exists(target):\n logger.info('Skipping filtering for {}'.format(target))\n else:\n with open(target, 'w') as oH:\n with open(self.fileName) as iH:\n for row in csv.reader(iH, delimiter=\"\\t\"):\n if not row[0].startswith('@') and row[1] == str(flag):\n if len(row[9]) >= 30:\n print(textwrap.fill('>%s' % row[0], width=80), file=oH)\n print(textwrap.fill('%s' % row[9], width=80), file=oH)\n logger.debug('Filtering finished')\n return target","def scan_source(filename, def_re = None, cb = (lambda l,m : None) ) :\n import re\n\n if not def_re :\n storage_class = br\"(static\\s+)?\"\n type_and_name = br\"int\\s+(?P<n>test_[_a-zA-Z0-9]*)\";\n args=br\"\\(.*\\)\";\n def_re = re.compile(b\"\\s*\" + storage_class +\n type_and_name + b\"\\s*\" +\n args );\n\n tests = set()\n with open(filename, \"rb\") as f:\n for line in f:\n m = def_re.match(line)\n if not m : continue\n cb(line, m)\n tests.add( m.group('n').strip().decode('utf-8') )\n return tests","def main():\n # Handel the file opening of the FASTA file to be searched\n file = open(r\"C:\\Users\\doodw\\PycharmProjects\\Zalgorithm\\venv\\input\\testfasta.fasta\", 'r')\n # Create an empty string to hold text sequence\n sequence = \"\"\n # Flag to ensure only one sequence is read from the Fasta\n single_sequence_flag = False\n # Read in and concatenate sequence lines from Fasta file\n for line in file:\n if line.find('>') != -1: # Header ignored\n # Ignores multiple sequences in Fasta file\n if single_sequence_flag:\n break\n continue\n else:\n line = line.strip().lower()\n sequence += line\n\n # Prompt the user for query\n query = input(\"Please enter a DNA sequence to search for: \").strip().lower()\n\n # Call the z-algorithm\n output = z_algorithm(sequence, query)\n\n # Print the output form the z-algorithm\n for index in output:\n print(\"A perfect match found at: \" + str(index))","def match(self, *args):\n return _ida_hexrays.microcode_filter_t_match(self, *args)","def _compile_audience_pattern(self, pattern):\n re_pattern = fnmatch.translate(pattern)\n if \"://\" not in pattern:\n re_pattern = \"[a-z]+://\" + re_pattern\n return re.compile(re_pattern)","def valid_fastq_filename_pattern():\n # 'xxx_R_1.fastq.gz and xxx_R_2.fastq.gz'\n return r\"^.+_R_[1-2]{1}\\.fastq.gz$\"","def file_matches(self, text):\n \n #print 'Completer->file_matches: <%s>' % text # dbg\n\n # chars that require escaping with backslash - i.e. chars\n # that readline treats incorrectly as delimiters, but we\n # don't want to treat as delimiters in filename matching\n # when escaped with backslash\n \n protectables = ' ()[]{}'\n\n def protect_filename(s):\n return \"\".join([(ch in protectables and '\\\\' + ch or ch)\n for ch in s])\n\n lbuf = self.get_line_buffer()[:self.readline.get_endidx()]\n open_quotes = 0 # track strings with open quotes\n try:\n lsplit = shlex_split(lbuf)[-1]\n except ValueError:\n # typically an unmatched \", or backslash without escaped char.\n if lbuf.count('\"')==1:\n open_quotes = 1\n lsplit = lbuf.split('\"')[-1]\n elif lbuf.count(\"'\")==1:\n open_quotes = 1\n lsplit = lbuf.split(\"'\")[-1]\n else:\n return None\n except IndexError:\n # tab pressed on empty line\n lsplit = \"\"\n\n if lsplit != protect_filename(lsplit):\n # if protectables are found, do matching on the whole escaped\n # name\n has_protectables = 1\n text0,text = text,lsplit\n else:\n has_protectables = 0\n text = os.path.expanduser(text)\n \n if text == \"\":\n return [protect_filename(f) for f in self.glob(\"*\")]\n\n m0 = self.clean_glob(text.replace('\\\\',''))\n if has_protectables:\n # If we had protectables, we need to revert our changes to the\n # beginning of filename so that we don't double-write the part\n # of the filename we have so far\n len_lsplit = len(lsplit)\n matches = [text0 + protect_filename(f[len_lsplit:]) for f in m0]\n else:\n if open_quotes:\n # if we have a string with an open quote, we don't need to\n # protect the names at all (and we _shouldn't_, as it\n # would cause bugs when the filesystem call is made).\n matches = m0\n else:\n matches = [protect_filename(f) for f in m0]\n if len(matches) == 1 and os.path.isdir(matches[0]):\n # Takes care of links to directories also. Use '/'\n # explicitly, even under Windows, so that name completions\n # don't end up escaped.\n matches[0] += '/'\n return matches","def parse_filtering_file(file_path):\n\n # Initialize variables\n filtering_options = []\n\n # Read in the default filtering options\n with open(file_path, 'r') as input_fh:\n # Iterate through every line of the file\n for line in input_fh.readlines():\n\n # Check to make sure the line is formatted correctly\n if len(line.strip()) > 2 and line.startswith(('-', '+')):\n # Append the filtering option\n if line[1] == ' ':\n filtering_options.append((line[0], line.strip()[2:]))\n elif not line.startswith('#'):\n logging.warning('\\tInvalid regex filtering line: {}'.format(line.strip()))\n\n return filtering_options","def set_import_filter(self, regex: Union[str, re.Pattern], blacklist: bool = False):\n self._variables['IMPORT_FILTER'] = (\n re.compile(regex) if isinstance(regex, str) else regex,\n bool(blacklist)\n )"],"string":"[\n \"def _apply_fasta_regex_func(infa, regex_func, outfa=None):\\n # move the original file to a tmp folder\\n out_dir = os.path.dirname(infa)\\n tmp_dir = mkdtemp(dir=out_dir)\\n old_fname = os.path.join(tmp_dir, \\\"original\\\") if outfa is None else infa\\n new_fname = os.path.join(tmp_dir, \\\"filtered\\\")\\n shutil.move(infa, old_fname)\\n\\n # perform the filtering\\n excluded_contigs = []\\n keep_contig = True\\n with open(old_fname) as old, open(new_fname, \\\"w\\\") as new:\\n for line in tqdm(old, desc=\\\"Filtering Fasta\\\", unit_scale=1, unit=\\\" lines\\\"):\\n if line[0] == \\\">\\\":\\n keep_contig = regex_func(line)\\n if keep_contig is False:\\n excluded_contigs.append(line[1:].split(\\\" \\\")[0].strip())\\n if keep_contig:\\n new.write(line)\\n\\n # move the filtered file to the original folder\\n shutil.move(new_fname, outfa if outfa else infa)\\n rm_rf(tmp_dir)\\n\\n return excluded_contigs\",\n \"def filter_nmt_file(filename,filter_fn=None):\\r\\n \\r\\n if filter_fn is None:\\r\\n filter_fn = lambda en : en.lower().startswith('i am') or \\\\\\r\\n en.lower().startswith('he is') or \\\\\\r\\n en.lower().startswith('she is') or \\\\\\r\\n en.lower().startswith('they are') or \\\\\\r\\n en.lower().startswith('you are') or \\\\\\r\\n en.lower().startswith('we are')\\r\\n \\r\\n filtered_lines = []\\r\\n with open(filename) as file:\\r\\n lines = file.readlines()\\r\\n for line in lines:\\r\\n text = line.split('\\\\t')\\r\\n en = text[0]\\r\\n fra = text[1]\\r\\n if filter_fn(en):\\r\\n filtered_lines.append(en.lower() + '\\\\t' + fra.lower())\\r\\n\\r\\n return filtered_lines\",\n \"def filter_fasta_fp(input_seqs_fp, output_seqs_fp, seqs_to_keep, negate=False):\\r\\n input_seqs = parse_fasta(open(input_seqs_fp, 'U'))\\r\\n output_f = open(output_seqs_fp, 'w')\\r\\n return filter_fasta(input_seqs, output_f, seqs_to_keep, negate)\",\n \"def test_filter_fasta(self):\\r\\n input_seqs = [('Seq1 some comment', 'ACCTTGG'),\\r\\n ('s2 some other comment', 'TTGG'),\\r\\n ('S3', 'AAGGCCGG'),\\r\\n ('S5 some comment', 'CGT'),\\r\\n ('seq6 some other comment', 'AA'),\\r\\n ('S7', 'T')]\\r\\n seqs_to_keep = {}.fromkeys(['Seq1',\\r\\n 's2 some other comment',\\r\\n 'S3 no comment'])\\r\\n\\r\\n actual = fake_output_f()\\r\\n filter_fasta(input_seqs,\\r\\n actual,\\r\\n seqs_to_keep,\\r\\n negate=False)\\r\\n self.assertEqual(actual.s, self.filter_fasta_expected1)\\r\\n\\r\\n actual = fake_output_f()\\r\\n filter_fasta(input_seqs,\\r\\n actual,\\r\\n seqs_to_keep,\\r\\n negate=True)\\r\\n self.assertEqual(actual.s, self.filter_fasta_expected2)\",\n \"def filter_files(self, pattern, filter_fn=None):\\n def filter_function(f):\\n return re.search(pattern, f) != None\\n if not filter_fn:\\n filter_fn = filter_function\\n return filter(filter_fn, self.files)\",\n \"def regex_filter_list(file_list, pattern, output=True):\\n r = re.compile(pattern)\\n matches = filter(r.match, file_list)\\n\\n if (len(matches) > 0 and output is True):\\n #print colors.BLUE + '\\\\033[1m' + \\\"matches:\\\" + '\\\\033[0m'\\n for match in matches:\\n print colors.BLUE + match + colors.ENDC\\n\\n return matches\",\n \"def test_filtered_scan(self):\\n self.run_scan(self.tempdir, self.root_fcount + self.nest_fcount, ext=\\\".txt\\\")\",\n \"def filter_it(self, _filter):\\n with open(self.path) as _file:\\n for line in _file:\\n tokens = self._tokenize(line)\\n if tokens:\\n _ip = tokens.group('ip')\\n if _filter.match(_ip):\\n yield line\",\n \"def filter(self, regex_pattern: str) -> None:\\n self._filter_attachment_list(regex_pattern)\\n self._filter_url_list(regex_pattern)\",\n \"def filter_by_regex(self, dictlist, fidname, regex, outputfidlist=[]):\\n result = [item for item in dictlist if re.match(regex, item[fidname]) != None]\\n return self.filter_output(result, outputfidlist)\",\n \"def _filter_patterns(self, filepath, pattern_prefix, exclude_pattern, include_pattern):\\n isfilter = False\\n if exclude_pattern:\\n full_exclude_pattern = os.path.join(pattern_prefix, exclude_pattern)\\n if fnmatch.fnmatch(filepath, full_exclude_pattern):\\n isfilter = True\\n if include_pattern:\\n full_include_pattern = os.path.join(pattern_prefix, include_pattern)\\n if fnmatch.fnmatch(filepath, full_include_pattern):\\n isfilter = False\\n return isfilter\",\n \"def filter_fastq_fp(input_seqs_fp, output_seqs_fp, seqs_to_keep, negate=False):\\r\\n input_seqs = parse_fastq(open(input_seqs_fp, 'U'), strict=False)\\r\\n output_f = open(output_seqs_fp, 'w')\\r\\n return filter_fastq(input_seqs, output_f, seqs_to_keep, negate)\",\n \"def _filter(self, minLength=None, maxLength=None, removeGaps=False,\\n whitelist=None, blacklist=None,\\n titleRegex=None, negativeTitleRegex=None,\\n truncateTitlesAfter=None, indices=None, head=None,\\n removeDuplicates=False, modifier=None):\\n if (whitelist or blacklist or titleRegex or negativeTitleRegex or\\n truncateTitlesAfter):\\n titleFilter = TitleFilter(\\n whitelist=whitelist, blacklist=blacklist,\\n positiveRegex=titleRegex, negativeRegex=negativeTitleRegex,\\n truncateAfter=truncateTitlesAfter)\\n else:\\n titleFilter = None\\n\\n if removeDuplicates:\\n sequencesSeen = set()\\n\\n for readIndex, read in enumerate(self):\\n\\n if head is not None and readIndex == head:\\n # We're completely done.\\n return\\n\\n readLen = len(read)\\n if ((minLength is not None and readLen < minLength) or\\n (maxLength is not None and readLen > maxLength)):\\n continue\\n\\n if removeGaps:\\n sequence = read.sequence.replace('-', '')\\n read = read.__class__(read.id, sequence, read.quality)\\n\\n if (titleFilter and\\n titleFilter.accept(read.id) == TitleFilter.REJECT):\\n continue\\n\\n if indices is not None and readIndex not in indices:\\n continue\\n\\n if removeDuplicates:\\n if read.sequence in sequencesSeen:\\n continue\\n sequencesSeen.add(read.sequence)\\n\\n if modifier:\\n modified = modifier(read)\\n if modified is None:\\n continue\\n else:\\n read = modified\\n\\n yield read\",\n \"def filter_ignoring_case(self, pattern):\\n return self.filter(re.compile(pattern, re.I))\",\n \"def parseFasta(fh):\\n\\n record_seq = []\\n record_id = None\\n\\n for line in fh:\\n line = line.strip(\\\"\\\\n\\\")\\n\\n if line.startswith(\\\">\\\"):\\n\\n if record_seq:\\n yield Record(record_id, \\\"\\\".join(record_seq))\\n\\n record_id = line[1:].split()[0]\\n record_seq = []\\n else:\\n record_seq.append(line.replace(\\\"*\\\", \\\"-\\\"))\\n\\n if record_seq:\\n yield Record(record_id, \\\"\\\".join(record_seq))\",\n \"def pattern_filter(patterns, name):\\n return [pat for pat in patterns if fnmatch.fnmatchcase(name, pat)]\",\n \"def _filter_seqs(fn):\\n out_file = op.splitext(fn)[0] + \\\"_unique.fa\\\"\\n idx = 0\\n if not file_exists(out_file):\\n with open(out_file, 'w') as out_handle:\\n with open(fn) as in_handle:\\n line = in_handle.readline()\\n while line:\\n if line.startswith(\\\"@\\\") or line.startswith(\\\">\\\"):\\n fixed_name = _make_unique(line.strip(), idx)\\n seq = in_handle.readline().strip()\\n counts = _get_freq(fixed_name)\\n if len(seq) < 26 and (counts > 1 or counts == 0):\\n idx += 1\\n print(fixed_name, file=out_handle, end=\\\"\\\\n\\\")\\n print(seq, file=out_handle, end=\\\"\\\\n\\\")\\n if line.startswith(\\\"@\\\"):\\n in_handle.readline()\\n in_handle.readline()\\n line = in_handle.readline()\\n return out_file\",\n \"def eliminate(file,patternlist,returnfile):\\n\\tf=open(file,\\\"r\\\")\\n\\tlines=f.readlines()\\n\\trep=True\\n\\twith open(returnfile,'w') as file:\\n\\t\\tfor line in lines:\\n\\t\\t\\tfor i in patternlist:\\n\\t\\t\\t\\tp=re.compile(i) \\n\\t\\t\\t\\tif(p.search(line)):\\n\\t\\t\\t\\t\\trep=False\\n\\t\\t\\tif(rep==True):\\n\\t\\t\\t\\tfile.write(line)\\n\\t\\t\\trep=True\",\n \"def filter_fasta(input_seqs, output_seqs_f, seqs_to_keep, negate=False):\\r\\n seqs_to_keep_lookup = {}.fromkeys([seq_id.split()[0]\\r\\n for seq_id in seqs_to_keep])\\r\\n # Define a function based on the value of negate\\r\\n if not negate:\\r\\n def keep_seq(seq_id):\\r\\n return seq_id.split()[0] in seqs_to_keep_lookup\\r\\n else:\\r\\n def keep_seq(seq_id):\\r\\n return seq_id.split()[0] not in seqs_to_keep_lookup\\r\\n\\r\\n for seq_id, seq in input_seqs:\\r\\n if keep_seq(seq_id):\\r\\n output_seqs_f.write('>%s\\\\n%s\\\\n' % (seq_id, seq))\\r\\n output_seqs_f.close()\",\n \"def filter_scan(scan, filter_pattern, parent):\\n filter_line = scan.get('filterLine')\\n filter_m = re.search(filter_pattern, filter_line)\\n if filter_m is None:\\n parent.remove(scan)\\n return 0\\n else:\\n return 1\",\n \"def filter(self, pattern):\\n if isinstance(pattern, REGEX_TYPE):\\n func = tools.filter_regex\\n elif pattern.startswith('/'):\\n pattern = re.compile(pattern.strip('/'))\\n func = tools.filter_regex\\n else:\\n func = tools.filter_wildcard\\n\\n return SeeResult(func(self, pattern))\",\n \"def transfer_filter(s, reg_exps, verbose=False):\\n # Default: no match is found\\n match = None\\n\\n # Reformat string to lowercase without new line characters\\n s = s.replace('\\\\n', ' ').lower()\\n\\n # See if a match can be found with the unpredictable transfer filter regex\\n match = reg_exps['re_trans_filter'].search(s)\\n\\n return match\",\n \"def filterRansac():\\n pass\",\n \"def filtered_lines():\\n\\n with open(filename, 'r') as cds_file:\\n for line in cds_file:\\n if(\\n line[0] not in '#-'\\n and\\n line[:2] != ' |'\\n ):\\n yield line\",\n \"def grep(pattern, filename):\\n rx = re.compile(pattern)\\n with open(filename, 'r') as file:\\n for line in file:\\n if rx.search(line):\\n yield line\",\n \"def quality_matcher(fasta, full_fastq, filt_fastq, trunclen):\\n with open(fasta, \\\"r\\\") as fasta, open(full_fastq, \\\"r\\\") as fastq, open(filt_fastq, \\\"w\\\") as new_fastq:\\n #make lists of the fasta and fastq files, where every successive value is a successive line\\n #purpose of -1: to avoid the \\\"\\\\n\\\" newline character at the end of the lines\\n fastq_list = [line[:-1] for line in fastq]\\n fasta_list = [line[:-1] for line in fasta]\\n #iterate through the sequence ids in the fasta file\\n for fasta_index, fasta_id in enumerate(fasta_list):\\n if fasta_id[0] == \\\">\\\":\\n #get the list index of the matching sequence id in the metagenomic fastq file\\n fastq_index = fastq_list.index(\\\"@{}\\\".format(fasta_id[1:]))\\n #print and write a new fastq entry with the quality scores string truncated to the same length as the sequence from the fasta file\\n print(str(\\\"@{}\\\".format(fasta_id[1:])) + \\\"\\\\n\\\" + str(fasta_list[fasta_index+1]) + \\\"\\\\n\\\" + str(\\\"+{}\\\".format(fasta_id[1:])) + \\\"\\\\n\\\" + str(fastq_list[fastq_index+3][:int(trunclen)]))\\n new_fastq.write(str(\\\"@{}\\\".format(fasta_id[1:])) + \\\"\\\\n\\\" + str(fasta_list[fasta_index+1]) + \\\"\\\\n\\\" + str(\\\"+{}\\\".format(fasta_id[1:])) + \\\"\\\\n\\\" + str(fastq_list[fastq_index+3][:int(trunclen)]))\",\n \"def filter_before_parse(file_like):\\n return file_like\",\n \"def negative_filtering(patterns: list, file_list):\\n if len(patterns) == 0:\\n return file_list\\n prog = re.compile(patterns.pop())\\n it = (i for i in file_list if not prog.search(i))\\n return negative_filtering(patterns, it)\",\n \"def filter_text(self, text):\\n yield from map(self._filter,\\n (m.group(0) for m in re.finditer(self.pattern, text)))\",\n \"def test_filter_regex(re_arg, re_src, re_dest):\\n args = parser.parse_args(['-re', *re_arg])\\n filters = renamer.initfilters(args)\\n dest = renamer.get_renames(re_src, filters, args.extension, args.raw)\\n assert dest == re_dest\",\n \"def __init__(self, file_pattern):\\n super(PlainTextFastaSource, self).__init__(\\n file_pattern=file_pattern, splittable=False, validate=True)\\n self.fasta_records_counter = metrics.Metrics.counter(\\n self.__class__, 'label_fasta_records')\",\n \"def ParseFilterFile(input_lines):\\n # Strip comments and whitespace from each line and filter non-empty lines.\\n stripped_lines = (l.split('#', 1)[0].strip() for l in input_lines)\\n filter_lines = [l for l in stripped_lines if l]\\n\\n # Split the tests into positive and negative patterns (gtest treats\\n # every pattern after the first '-' sign as an exclusion).\\n positive_patterns = [l for l in filter_lines if l[0] != '-']\\n negative_patterns = [l[1:] for l in filter_lines if l[0] == '-']\\n return positive_patterns, negative_patterns\",\n \"def regexSearch(regexStr, folderPath):\\n if not os.path.isdir(folderPath):\\n return 'Input a directory path'\\n\\n userRegex = re.compile(regex)\\n\\n for filename in os.listdir(folderPath):\\n\\n if filename.endswith('.txt'):\\n\\n with open(filename) as file:\\n\\n for line in file:\\n mo = userRegex.search(line)\\n \\n if mo:\\n print(line, end='')\",\n \"def test_filter_mapping_file_from_mapping_f(self):\\r\\n actual = filter_mapping_file_from_mapping_f(\\r\\n self.tutorial_mapping_f, [\\\"PC.354\\\", \\\"PC.355\\\"])\\r\\n expected = \\\"\\\"\\\"#SampleID\\tBarcodeSequence\\tLinkerPrimerSequence\\tTreatment\\tDOB\\tDescription\\r\\nPC.354\\tAGCACGAGCCTA\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20061218\\tControl_mouse_I.D._354\\r\\nPC.355\\tAACTCGTCGATG\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20061218\\tControl_mouse_I.D._355\\\"\\\"\\\"\\r\\n self.assertEqual(actual, expected)\",\n \"def test_filter_fastq(self):\\r\\n input_seqs = [('Seq1 some comment', 'ACCTTGG', 'BBBBBBB'),\\r\\n ('s2 some other comment', 'TTGG', 'BBBB'),\\r\\n ('S3', 'AAGGCCGG', 'BBCtatcc'),\\r\\n ('S5 some comment', 'CGT', 'BBB'),\\r\\n ('seq6 some other comment', 'AA', 'BB'),\\r\\n ('S7', 'T', 's')]\\r\\n seqs_to_keep = {}.fromkeys(['Seq1',\\r\\n 's2 some other comment',\\r\\n 'S3 no comment'])\\r\\n\\r\\n actual = fake_output_f()\\r\\n filter_fastq(input_seqs,\\r\\n actual,\\r\\n seqs_to_keep,\\r\\n negate=False)\\r\\n self.assertEqual(actual.s, self.filter_fastq_expected1)\\r\\n\\r\\n actual = fake_output_f()\\r\\n filter_fastq(input_seqs,\\r\\n actual,\\r\\n seqs_to_keep,\\r\\n negate=True)\\r\\n self.assertEqual(actual.s, self.filter_fastq_expected2)\",\n \"def filter(args):\\n p = OptionParser(filter.__doc__)\\n p.add_option(\\n \\\"--less\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"filter the sizes < certain cutoff [default: >=]\\\",\\n )\\n p.set_outfile()\\n\\n opts, args = p.parse_args(args)\\n\\n if len(args) != 2:\\n sys.exit(not p.print_help())\\n\\n fastafile, cutoff = args\\n try:\\n cutoff = int(cutoff)\\n except ValueError:\\n sys.exit(not p.print_help())\\n\\n f = Fasta(fastafile, lazy=True)\\n\\n fw = must_open(opts.outfile, \\\"w\\\")\\n for name, rec in f.iteritems_ordered():\\n\\n if opts.less and len(rec) >= cutoff:\\n continue\\n\\n if (not opts.less) and len(rec) < cutoff:\\n continue\\n\\n SeqIO.write([rec], fw, \\\"fasta\\\")\\n fw.flush()\\n\\n return fw.name\",\n \"def test_filter_mapping_file_from_mapping_f_negate(self):\\r\\n actual = filter_mapping_file_from_mapping_f(self.tutorial_mapping_f,\\r\\n [\\\"PC.356\\\",\\r\\n \\\"PC.481\\\",\\r\\n \\\"PC.593\\\",\\r\\n \\\"PC.607\\\",\\r\\n \\\"PC.634\\\",\\r\\n \\\"PC.635\\\",\\r\\n \\\"PC.636\\\"],\\r\\n negate=True)\\r\\n expected = \\\"\\\"\\\"#SampleID\\tBarcodeSequence\\tLinkerPrimerSequence\\tTreatment\\tDOB\\tDescription\\r\\nPC.354\\tAGCACGAGCCTA\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20061218\\tControl_mouse_I.D._354\\r\\nPC.355\\tAACTCGTCGATG\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20061218\\tControl_mouse_I.D._355\\\"\\\"\\\"\\r\\n self.assertEqual(actual, expected)\",\n \"def text_file_search_all(cls, file, search_for, encoding='utf-8', search_using_regex=False,\\n\\t\\t\\t\\t\\t\\t\\t search_from_front_to_back=False, count=0):\\n\\n\\t\\tif search_for == '':\\n\\t\\t\\treturn None\\n\\t\\ttry:\\n\\t\\t\\tresult = []\\n\\t\\t\\twith open(file, mode='r', encoding=encoding) as file_reader:\\n\\t\\t\\t\\tfor line in file_reader if search_from_front_to_back else cls.reverse_file_reader(file_reader,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t save_memory=True):\\n\\t\\t\\t\\t\\tif not search_using_regex:\\n\\t\\t\\t\\t\\t\\tif not line.find(search_for) == -1:\\n\\t\\t\\t\\t\\t\\t\\tresult.append(search_for)\\n\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tsearch_for_re = re.compile(search_for)\\n\\t\\t\\t\\t\\t\\tre_result = re.search(search_for_re, line)\\n\\t\\t\\t\\t\\t\\tif re_result:\\n\\t\\t\\t\\t\\t\\t\\tresult.append(re_result.group())\\n\\t\\t\\t\\t\\tif 0 < count == len(result):\\n\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\tif not result:\\n\\t\\t\\t\\t\\treturn None\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\treturn result\\n\\t\\texcept Exception as e:\\n\\t\\t\\tprint(e)\\n\\t\\t\\treturn None\",\n \"def main(pattern, i=stdin, o=stdout, only_matching=False):\\n sre = re.compile(pattern)\\n with i as i, o as o:\\n for line in i:\\n match = sre.match(line)\\n if match:\\n if only_matching:\\n o.write(\\\"%s\\\\n\\\" % match.groups()[0])\\n else:\\n o.write(line)\",\n \"def _filter_attachment_list(self, regex_pattern: str) -> None:\\n matcher = re.compile(regex_pattern)\\n filtered_list = []\\n if self.attachment_list:\\n for attachment in self.attachment_list:\\n if matcher.search(attachment.attachment_name):\\n filtered_list.append(attachment)\\n self.attachment_list = filtered_list\",\n \"def read_fasta(amplicon_file, minseqlen):\\n with gzip.open(amplicon_file) as file:\\n sequences = file.readlines()\\n seqs = \\\"\\\"\\n for sequence in sequences:\\n #print(\\\"sequence\\\")\\n seq = sequence.replace(b\\\"\\\\n\\\", b\\\"\\\")\\n seq = seq.decode('utf8')\\n #print(seq)\\n for character in seq:\\n if character not in \\\"TGAC\\\":\\n if len(seqs)>=minseqlen:\\n yield seqs\\n #print(seqs)\\n seq = \\\"\\\"\\n seqs = \\\"\\\"\\n break\\n seqs += seq\\n #print(seqs)\\n yield seqs\",\n \"def fsearch(self,pattern,msg=None, killon=None ):\\n import re\\n current=0\\n cpat=re.compile(pattern)\\n\\n for num,line in enumerate(self.f):\\n if killon:\\n kill = re.search(killon,line)\\n if kill:\\n # the kill phrase was found first, so die. \\n return False\\n current=re.search(cpat,line)\\n if current:\\n if msg:\\n print msg\\n break\\n if not current:\\n# print 'ERROR: Requested pattern ('+pattern+') not found in file: <'+self.f.name+ '>. Check file for correct structure. Exiting...'\\n return False\\n\\n return line\",\n \"def _filter_subreads(self):\\n logging.info(\\\"Start to filter subreads in fofn.\\\")\\n if op.exists(self.ori_all_reads_fasta) and self.force_redo is not True:\\n msg = \\\"{fa} already exists, skip pls2fasta\\\".format(fa=self.ori_all_reads_fasta)\\n logging.warn(msg)\\n else:\\n logging.debug(\\\"{f} does not exist, call pls2fasta\\\".\\n format(f=self.ori_all_reads_fasta))\\n filter_summary = op.join(self.filtered_region_dir,\\n \\\"filtered_summary.csv\\\")\\n cmd = \\\"filter_plsh5.py --debug \\\" + \\\\\\n \\\"--filter='MinReadScore=0.80,MinSRL=500,MinRL=100' \\\" + \\\\\\n \\\"--trim='True' --outputDir={fr} \\\".format(\\n fr=self.filtered_region_dir) + \\\\\\n \\\"--outputSummary={sm} \\\".format(sm=filter_summary) + \\\\\\n \\\"--outputFofn={rgn} \\\".format(rgn=self.region_fofn) + \\\\\\n \\\"{in_fofn}\\\".format(in_fofn=self.input_fofn)\\n logging.info(\\\"CMD: {cmd}\\\".format(cmd=cmd))\\n _o, _c, _m = backticks(cmd)\\n if _c != 0:\\n raise RuntimeError(\\\"CMD failed. \\\" + str(_o) + ' ' + str(_m))\\n\\n cmd = \\\"pls2fasta -trimByRegion \\\" + \\\\\\n \\\"-regionTable {rgn} \\\".format(rgn=self.region_fofn) + \\\\\\n \\\"{fofn} {fa} \\\".format(fofn=self.input_fofn,\\n fa=self.ori_all_reads_fasta)\\n logging.info(\\\"CMD: {cmd}\\\".format(cmd=cmd))\\n _o, _c, _m = backticks(cmd)\\n if _c != 0:\\n raise RuntimeError(\\\"CMD failed. \\\" + str(_o) + ' ' + str(_m))\\n logging.info(\\\"{f} created.\\\".format(f=self.ori_all_reads_fasta))\\n\\n logging.debug(\\\"Copying {ori_f} to {f}.\\\".format(\\n ori_f=self.ori_all_reads_fasta, f=self.all_reads_fasta))\\n shutil.copyfile(self.ori_all_reads_fasta, self.all_reads_fasta)\",\n \"def test_filter_sff_file(self):\\r\\n\\r\\n try:\\r\\n fh = open(self.tiny_test)\\r\\n except IOError:\\r\\n self.fail(\\r\\n \\\"Could not open test file %s. Skipping test\\\" %\\r\\n self.tiny_test)\\r\\n\\r\\n # With no filters all flowgram should be in out file\\r\\n flowgrams, header = lazy_parse_sff_handle(fh)\\r\\n filter_list = []\\r\\n fd, out_file_name = mkstemp(\\r\\n prefix=\\\"test_filter_sff_file\\\",\\r\\n suffix=\\\".sff.txt\\\")\\r\\n close(fd)\\r\\n out_fh = open(out_file_name, \\\"w\\\")\\r\\n l = filter_sff_file(flowgrams, header, filter_list, out_fh)\\r\\n remove(out_file_name)\\r\\n fh.close()\\r\\n self.assertEqual(l, 114)\\r\\n\\r\\n # With good filters some should survive\\r\\n fh = open(self.tiny_test)\\r\\n flowgrams, header = lazy_parse_sff_handle(fh)\\r\\n filter_list = [lambda f:within_length(f, 100, 300)]\\r\\n fd, out_file_name = mkstemp(\\r\\n prefix=\\\"test_filter_sff_file\\\",\\r\\n suffix=\\\".sff.txt\\\")\\r\\n close(fd)\\r\\n out_fh = open(out_file_name, \\\"w\\\")\\r\\n l = filter_sff_file(flowgrams, header, filter_list, out_fh)\\r\\n remove(out_file_name)\\r\\n fh.close()\\r\\n self.assertEqual(l, 112)\\r\\n\\r\\n # With strong filters nothing should be in\\r\\n fh = open(self.tiny_test)\\r\\n flowgrams, header = lazy_parse_sff_handle(fh)\\r\\n filter_list = [lambda f:within_length(f, 0, 0)]\\r\\n fd, out_file_name = mkstemp(\\r\\n prefix=\\\"test_filter_sff_file\\\",\\r\\n suffix=\\\".sff.txt\\\")\\r\\n close(fd)\\r\\n out_fh = open(out_file_name, \\\"w\\\")\\r\\n l = filter_sff_file(flowgrams, header, filter_list, out_fh)\\r\\n remove(out_file_name)\\r\\n self.assertEqual(l, 0)\",\n \"def test_filter_mapping_file_from_mapping_f_negate(self):\\n actual = filter_mapping_file_from_mapping_f(self.tutorial_mapping_f,\\n [\\\"PC.356\\\", \\\"PC.481\\\", \\\"PC.593\\\", \\\"PC.607\\\", \\\"PC.634\\\", \\\"PC.635\\\", \\\"PC.636\\\"],\\n negate=True)\\n expected = \\\"\\\"\\\"#SampleID\\tBarcodeSequence\\tLinkerPrimerSequence\\tTreatment\\tDOB\\tDescription\\nPC.354\\tAGCACGAGCCTA\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20061218\\tControl_mouse_I.D._354\\nPC.355\\tAACTCGTCGATG\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20061218\\tControl_mouse_I.D._355\\\"\\\"\\\"\\n self.assertEqual(actual,expected)\",\n \"def filter_samfile(temp_alignment, filtered_out):\\n # Check the quality and status of each aligned fragment.\\n # Write the ones with good quality in the final output file.\\n # Keep those that do not map unambiguously for the next round.\\n\\n unaligned = set()\\n temp_sam = ps.AlignmentFile(temp_alignment, \\\"r\\\")\\n outf = ps.AlignmentFile(filtered_out, \\\"w\\\", template=temp_sam)\\n for r in temp_sam:\\n if r.flag in [0, 16] and r.mapping_quality >= 30:\\n outf.write(r)\\n else:\\n unaligned.add(r.query_name)\\n\\n print(\\\"{0} reads left to map.\\\".format(len(unaligned)))\\n temp_sam.close()\\n outf.close()\\n\\n return unaligned\",\n \"def filter_reads(alignment_file, readdb, read_dirs, quality_threshold=7, recursive=False, trim=False):\\n assert alignment_file.endswith(\\\"bam\\\"), \\\"Alignment file must be in BAM format: {}\\\".format(alignment_file)\\n # grab aligned segment\\n if trim:\\n assert isinstance(trim, int), \\\"Trim needs to be an integer: {}\\\".format(trim)\\n else:\\n trim = np.inf\\n n_bases = 0\\n n_files = 0\\n with closing(pysam.AlignmentFile(alignment_file, 'rb')) as bamfile:\\n name_indexed = pysam.IndexedReads(bamfile)\\n name_indexed.build()\\n for name, fast5 in parse_read_name_map_file(readdb, read_dirs, recursive=recursive):\\n try:\\n if trim < n_bases:\\n print(\\\"Filtered {} files for {} bases\\\".format(n_files, n_bases))\\n break\\n iterator = name_indexed.find(name)\\n for aligned_segment in iterator:\\n if aligned_segment.is_secondary or aligned_segment.is_unmapped \\\\\\n or aligned_segment.is_supplementary or aligned_segment.has_tag(\\\"SA\\\"):\\n continue\\n # get data and sanity check\\n if aligned_segment.query_qualities is not None:\\n if np.mean(aligned_segment.query_qualities) < quality_threshold:\\n continue\\n n_files += 1\\n n_bases += aligned_segment.query_length\\n yield fast5, aligned_segment\\n except KeyError:\\n print(\\\"Found no alignments for {}\\\".format(fast5))\",\n \"def filename_filter ( self, filename, _fnmatch=fnmatch.fnmatch ):\\n return all (\\n not _fnmatch ( filename, pat ) for pat in self.FILENAMES_IGNORE\\n )\",\n \"def remove_matching_reads(filename, cont_file):\\n if not os.path.exists(cont_file + '.bwt'):\\n cml = shlex.split('bwa index %s' % cont_file)\\n subprocess.call(cml)\\n cml = 'bwa mem -t 2 %s %s 2> /dev/null | samtools view -f 4 -h - | samtools bam2fq - ' % (cont_file, filename)\\n cml += '| seqtk seq -A - > clean_reads.fasta'\\n\\n subprocess.call(cml, shell=True)\\n return 'clean_reads.fasta'\",\n \"def autoSaveFilter(filename):\",\n \"def readFasta(self, fastaFile):\\t\\n\\t\\tname, seq = None, []\\n\\t\\tfor line in fastaFile:\\n\\t\\t\\tline = line.rstrip()\\n\\t\\t\\tif (line.startswith(\\\">\\\")):\\n\\t\\t\\t\\tif name: yield (name, ''.join(seq))\\n\\t\\t\\t\\tname, seq = line, []\\n\\t\\t\\telse:\\n\\t\\t\\t\\tseq.append(line)\\n\\t\\tif name: yield (name, ''.join(seq))\",\n \"def filter_sequences(parent_directory, filename, label = 'Pfam:'):\\n uniprot, repeated_seqs = load_uniprot('{}/{}'.format(parent_directory, filename))\\n seq_fam = {}\\n \\n for u in uniprot:\\n # Only select those sequences\\n # - With the correct label\\n # - That do not contain illegal characters\\n # - Do not include sequences that are in multiple families\\n index = find_index(u.dbxrefs, lambda x: x.startswith(label))\\n if index != -1 and len(set(u._seq._data) - set(alphabet)) == 0 and u._seq._data not in repeated_seqs:\\n seq_fam[u._seq._data] = u.dbxrefs[index][len(label):]\\n \\n filtered_fam = filtered_families(seq_fam)\\n \\n # Write processed output to a separate file\\n with open('{}/processed.txt'.format(parent_directory), 'w') as f:\\n f.write('\\\\n'.join(' '.join((fam, seq))\\n for seq, fam in seq_fam.items()\\n if fam in filtered_fam))\",\n \"def test_filter_mapping_file_from_mapping_f(self):\\n actual = filter_mapping_file_from_mapping_f(self.tutorial_mapping_f,[\\\"PC.354\\\",\\\"PC.355\\\"])\\n expected = \\\"\\\"\\\"#SampleID\\tBarcodeSequence\\tLinkerPrimerSequence\\tTreatment\\tDOB\\tDescription\\nPC.354\\tAGCACGAGCCTA\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20061218\\tControl_mouse_I.D._354\\nPC.355\\tAACTCGTCGATG\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20061218\\tControl_mouse_I.D._355\\\"\\\"\\\"\\n self.assertEqual(actual,expected)\",\n \"def filt(seq, lst):\\n regex = \\\"(\\\" + \\\")|(\\\".join(seq) + \\\")\\\"\\n regex = re.compile(regex)\\n slst = list(filter(regex.search, lst))\\n return slst\\n\\n\\n # still need a checkUsername function \",\n \"def fasta_iter_py3(fasta_name):\\n rec = None\\n for line in open(fasta_name, \\\"r\\\"):\\n if line[0] == \\\">\\\":\\n if rec:\\n yield rec\\n rec = FastaRecord(line.strip()[1:])\\n else:\\n rec.sequence += line.strip()\\n\\n if rec:\\n yield rec\",\n \"def readFastaFile(filename):\",\n \"def fasta(file_path):\\n \\n print(f\\\"Parsing fasta '{file_path}'\\\")\\n data = {\\n 'ur_up_': [], 'accession': [],\\n 'entry_name': [], 'offset': [],\\n 'taxonomy': [], 'sequence': []\\n }\\n\\n with open(file_path, 'r') as f:\\n for i, line in enumerate(f):\\n line = line.strip()\\n \\n if line[0] == '>':\\n key = line[1:]\\n \\n if i == 0:\\n name, offset = key.split(\\\"/\\\")\\n ur_up_, acc = None, None\\n else:\\n ur_up_, acc, name_offset = key.split(\\\"|\\\")\\n name, offset = name_offset.split('/')\\n \\n data['ur_up_'].append(ur_up_)\\n data['accession'].append(acc)\\n data['entry_name'].append(name)\\n data['offset'].append(offset)\\n data['sequence'].append('')\\n data['taxonomy'].append(name.split('_')[1])\\n else:\\n data['sequence'][-1] += line\\n \\n if i and (i % 50000 == 0):\\n print(f\\\"Reached: {i}\\\")\\n\\n return pd.DataFrame(data=data)\",\n \"def search_file_all(pattern, filename):\\n if not os.path.exists(filename):\\n raise Exception(\\\"Can't open file for reading! \\\" + filename)\\n\\n matches = []\\n fh = open(filename, \\\"r\\\")\\n for line in fh:\\n allmatch = re.findall(pattern, line)\\n if allmatch:\\n matches += allmatch\\n\\n fh.close()\\n return matches\",\n \"def readFastaFile(filename):\\n if os.path.exists(filename)==False:return {}\\n sequences={}\\n fhr=open(filename,\\\"r\\\")\\n for line in fhr:\\n if line[0]==\\\">\\\":\\n sequences[line.strip()[1:].split()[0]]=fhr.readline().strip()\\n fhr.close()\\n return sequences\",\n \"def fasta_reader(fasta):\\n # ditch the boolean (x[0]) and just keep the header/seq grouping\\n fa_iter = (x[1] for x in itertools.groupby(fasta, lambda line: line[0] == \\\">\\\"))\\n for header in fa_iter:\\n # drop the \\\">\\\"\\n name = next(header)[1:].strip()\\n # join all sequence lines to one by iterating until the next group.\\n read = \\\"\\\".join(s.strip() for s in next(fa_iter))\\n yield name, read\",\n \"def play_with_regex():\\n\\n DNA_string = \\\"ATTTGTATGTTCGGCTAACTTCTACCCATCCCCCGAAGTTTAGCAGGTCGTGAGGTGTCATGGAGGCTCTCGTTCATCCCGTGGGACATCAAGCTTCGCCTTGATAAAGCACCCCGCTCGGGTGTAGCAGAGAAGACGCCTACTGAATTGTGCGATCCCTCCACCTCAGCTAAGGTAGCTACCAATATTTAGTTTTTTAGCCTTGCGACAGACCTCCTACTTAGATTGCCACGCATTGAGCTAGCGAGTCAGCGATAAGCATGACGCGCTTTCAAGCGTCGCGAGTATGTGAACCAAGGCTCCGGACAGGACTATATACTTGGGTTTGATCTCGCCCCGACAACTGCAAACCTCAACATTTATAGATTATAAGGTTAGCCGAAATTGCACGTGGTGGCGCCCGCCGACTGCTCCCCGAGTGTGGCTCTTTGATCTGACAACGCGCGACCTCCATCGCGGCCGATTGTTTCTGCGGACCATGTCGTCCTCATAGTTTGGGCATGTTTCCGTTGTAGGAGTGAAGCCACTTAGCTTTGCGCCGTAGTCCCAATGAAAAACCTATGGACTTTGTTTTGGGTAGCATCAGGAATCTGAACCCTGTGAATGTGGGGGTCGCGCGCATAGACCTTTATCTCCGGTTCAAGTTAGGCATGAGGCTGCATGCTACGTTGTCACACCTACACTGCTCGAAGTAAATATGGGAAGCGCGCGGCCTGGCCCGAGGCGTTCCGCGCCGCCACGTGTTCGTTAACTGTTGATTGGTGGCACATAAGCAATACCGTAGTCCCTCAAATTCAGCTCTGTTATCTCGAGCGTTATGTGTCAAATGGCGTAGAACGGGATTGACTGTTTGACACTAGCTGGTGTTCGGTTCGGTAACGGAGAATCTGTGGGGCTATGTCACTAATACTTTCGAAACGCCCCGTACCGATGCTGAACAAGTCGATGCAGGCTCCCGTCTTTGAATAGGGGTAAACATACAAGTCGATAGAAGATGGGT\\\"\\n \\n # 1. check if DNA_string starts with \\\"ATTTGTATG\\\" (say with re.search() or re.findall())\\n regex = re.compile('ATTTGTATG')\\n m = regex.search(DNA_string)\\n \\n # 2. use re.findall() if there are instances of 5 or more consecutive c's in DNA_string\\n m = re.finditer('C{5,}',DNA_string)\\n for entry in m:\\n print entry.span()\\n \\n # 3. find instances of the motif GGXY in the DNA sequence \\n # where X={A,C,G,T} and Y={C,T}\\n m = re.finditer('GG[ACGT][CT]',DNA_string)\\n print \\\"NUMBER 3\\\"\\n for entry in m:\\n print entry.span()\",\n \"def readFiltered(f):\\n line = f.readline()\\n while line:\\n line = line.strip()\\n if len(line) != 0:\\n if line == \\\"### NEW EXPERIMENT ###\\\":\\n # print (\\\"readFiltered: ''\\\")\\n yield \\\"\\\"\\n elif line[0] != \\\"#\\\":\\n # print (\\\"readFiltered: '\\\",line,\\\"'\\\")\\n yield line\\n line = f.readline()\\n # print (\\\"readFiltered: '\\\",line,\\\"'\\\")\\n return line\",\n \"def read_fasta(fasta_name):\\n \\n \\\"\\\"\\\"first open the file outside \\\"\\\"\\\"\\n file_handler = open(fasta_name)\\n\\n # ditch the boolean (x[0]) and just keep the header or sequence since\\n # we know they alternate.\\n fasta_iter = (x[1] for x in groupby(file_handler, lambda line: line[0] == \\\">\\\"))\\n\\n for header in fasta_iter:\\n # drop the \\\">\\\"\\n headerStr = header.__next__()[1:].strip()\\n\\n # join all sequence lines to one.\\n seq = \\\"\\\".join(s.strip() for s in fasta_iter.__next__())\\n\\n # yield (headerStr, seq)\\n result_record = {'header':headerStr,'seqRecord':seq}\\n return result_record\",\n \"def search(self):\\n apk_files = self.apk.get_files_types()\\n search_results = []\\n for file_path, file_type in apk_files.iteritems():\\n file_ext = os.path.splitext(os.path.basename(file_path))[1]\\n\\n #if file type filter on, and this file is not that type, then skip\\n if self.file_types and not any(interested_type in file_type.lower() or interested_type in file_ext for interested_type in self.file_types):\\n continue\\n\\n search_result = None\\n file_data = self.apk.get_file(file_path)\\n\\n if self.search_strings:\\n for pattern in self.patterns:\\n match = pattern.search(file_data)\\n if match:\\n search_result = {'file_path': file_path,\\n 'file_type': file_type,\\n 'search_string': pattern.pattern}\\n search_results.append(search_result)\\n else:\\n search_result = {'file_path': file_path,\\n 'file_type': file_type,\\n 'search_string': None}\\n search_results.append(search_result)\\n\\n #write individual files\\n if search_result and self.save_matched_files_dir:\\n #save original structure to avoid duplicate filename collisions\\n save_file_path = os.path.join(self.save_matched_files_dir, file_path)\\n if not os.path.exists(os.path.dirname(save_file_path)):\\n os.makedirs(os.path.dirname(save_file_path))\\n\\n with open(save_file_path,'wb') as f:\\n f.write(file_data)\\n\\n if 'Android binary XML' in file_type:\\n with open(save_file_path,'r+') as axml_f:\\n decoded_axml = AXMLPrinter(axml_f.read()).buff\\n axml_f.seek(0)\\n axml_f.write(decoded_axml)\\n axml_f.truncate()\\n\\n return search_results\",\n \"def text_file_search(cls, file: str, search_for: str, encoding: str = 'utf-8', search_using_regex: bool = False,\\n\\t\\t\\t\\t\\t\\t search_from_front_to_back: bool = False):\\n\\n\\t\\tresult = cls.text_file_search_all(file, search_for, encoding, search_using_regex,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t search_from_front_to_back, count=1)\\n\\n\\t\\treturn result[0] if result else None\",\n \"def filterMapNames(regexText, records=getIndex(), excludeRegex=False, closestMatch=True):\\n bestScr = 99999 # a big enough number to not be a valid file system path\\n regex = re.compile(regexText, flags=re.IGNORECASE)\\n ret = []\\n if excludeRegex: # match only records that do NOT contain regex\\n if regexText and closestMatch: # then maps with fewer characters are better matches\\n for m in list(records):\\n if re.search(regex, m.name): continue # map must NOT contain specified phrase\\n score = len(m.name) # the map with the smallest map name means it has the largets matching character percentage\\n if score == bestScr:\\n bestScr = score\\n ret.append(m)\\n elif score < bestScr: # new set of best maps\\n bestScr = score\\n ret = [m]\\n else: # all maps that match regex are included\\n for m in list(records):\\n if re.search(regex, m.name): continue # map must NOT contain specified phrase\\n ret.append(m) # any mapname containing regex matches\\n else: # only match records that contain regex\\n if regexText and closestMatch: # then maps with fewer characters are better matches\\n for m in records:\\n if not re.search(regex, m.name): continue # map must contain specified phrase if excludeRegex==True\\n score = len(m.name) # the map with the smallest map name means it has the largets matching character percentage\\n if score == bestScr:\\n bestScr = score\\n ret.append(m)\\n elif score < bestScr: # new group of best maps\\n bestScr = score\\n ret = [m]\\n else: # all maps that match regex are included\\n for m in records:\\n if not re.search(regex, m.name): continue # map must contain specified phrase if excludeRegex==True\\n ret.append(m) # any mapname containing regex matches\\n return ret\",\n \"def filter_on_regexp(strings, pattern):\\n filtered_strings = filter(lambda x: re.search(pattern, x), strings)\\n return filtered_strings\",\n \"def grep_me(pattern, fname):\\n for line in stream_reader(fname):\\n if re.search(pattern, line, re.I):\\n print('{}:{}:{}'.format(filename(), filelineno(), line), end='')\",\n \"def filter_sff_file(flowgrams, header, filter_list, out_fh):\\r\\n\\r\\n write_sff_header(header, out_fh)\\r\\n\\r\\n l = 0\\r\\n for f in flowgrams:\\r\\n passed = True\\r\\n for filter in filter_list:\\r\\n passed = passed and filter(f)\\r\\n if not passed:\\r\\n # bail out\\r\\n break\\r\\n if (passed):\\r\\n out_fh.write(f.createFlowHeader() + \\\"\\\\n\\\")\\r\\n l += 1\\r\\n return l\",\n \"def search(self, filtr):\\n return [note for note in self.notes if note.match(filtr)]\",\n \"def filter_fastq(input_seqs, output_seqs_f, seqs_to_keep, negate=False):\\r\\n seqs_to_keep_lookup = {}.fromkeys([seq_id.split()[0]\\r\\n for seq_id in seqs_to_keep])\\r\\n # Define a function based on the value of negate\\r\\n if not negate:\\r\\n def keep_seq(seq_id):\\r\\n return seq_id.split()[0] in seqs_to_keep_lookup\\r\\n else:\\r\\n def keep_seq(seq_id):\\r\\n return seq_id.split()[0] not in seqs_to_keep_lookup\\r\\n\\r\\n for seq_id, seq, qual in input_seqs:\\r\\n if keep_seq(seq_id):\\r\\n output_seqs_f.write('@%s\\\\n%s\\\\n+\\\\n%s\\\\n' % (seq_id, seq, qual))\\r\\n output_seqs_f.close()\",\n \"def file_name_search():\\n directory = \\\"/Users/andrewpowers/Documents/server/fastq_pass\\\"\\n\\n for file in os.listdir(directory):\\n output_file = re.sub('fastq', 'fasta', file)\\n os.system(bash_command.format(directory+\\\"/\\\"+file, output_file))\\n print('File {} converted to fasta.'.format(file))\\n print('Conversion Done.')\",\n \"def _filterTaxa(self, taxaString):\\n if self.taxRegex is None:\\n if not self.taxFilterType in regexTaxFilters:\\n self.taxFilterType = re.compile(taxFilterType)\\n else:\\n self.taxFilterType = regexTaxFilters[taxFilterType]\\n\\n try:\\n #Parse out genus and species if exists\\n taxInfo = self.taxFilterType.findall(taxaString)[0] \\n if len(taxInfo.split()) == 1: \\n #Error finding taxonomic info\\n taxInfo = taxaString\\n except:\\n taxInfo = taxaString\\n finally:\\n #Only return HSP if the filter is not found within the taxInfo string\\n return self.taxFilter not in taxInfo\",\n \"def parse_text(filehandle: TextIO) -> Iterator[Fasta]:\\n\\n # Check that the file looks like UniProt text format\\n first_line = next(filehandle)\\n if not first_line.startswith(\\\"ID\\\"):\\n raise TextParserError(\\n \\\"Unexpected file format: first line of UniProt text file should start with 'ID'\\\"\\n )\\n filehandle.seek(0)\\n\\n fasta = Fasta(sequence=\\\"\\\")\\n for line in filehandle:\\n key = line[:2] # This is more efficient than using line.startswith\\n if key == \\\"ID\\\":\\n tokens = line.split()\\n fasta.entry_name = tokens[1]\\n fasta.reviewed = True if tokens[2] == \\\"Reviewed;\\\" else False\\n elif key == \\\"AC\\\":\\n if fasta.accession is None:\\n accessions = line[5:].rstrip(\\\";\\\\n\\\").split(\\\"; \\\")\\n fasta.accession = accessions[0]\\n elif key == \\\"DT\\\":\\n if \\\"sequence version\\\" in line:\\n tokens = line[5:].strip(\\\".\\\\n\\\").split()\\n fasta.version = int(tokens[3])\\n elif key == \\\"DE\\\":\\n if \\\"RecName\\\" in line:\\n fasta.name = _extract_name(line)\\n # Get the first SubName if no RecName found\\n elif fasta.name is None and line[5:12] == \\\"SubName\\\":\\n fasta.name = _extract_name(line)\\n elif line[5:10] == \\\"Flags\\\" and \\\"Fragment\\\" in line:\\n fasta.fragment = True\\n elif key == \\\"GN\\\":\\n if line[5:10] == \\\"Name=\\\":\\n tokens = line[10:].split(\\\";\\\")\\n # Remove evidence tags, if present\\n gene_tokens = tokens[0].split(\\\" {\\\")\\n fasta.gene = gene_tokens[0]\\n elif key == \\\"OS\\\":\\n # TODO: check for multiline species name (excluding brackets)\\n if fasta.species is None:\\n species_line = line[5:].strip().split(\\\" (\\\")\\n fasta.species = species_line[0].strip(\\\".\\\")\\n elif key == \\\"OX\\\":\\n if \\\"NCBI_TaxID\\\" in line:\\n tokens = line[5:].strip(\\\";\\\\n\\\").split(\\\"; \\\")\\n # Remove evidence tag if present\\n taxid_tokens = tokens[0][11:].split(\\\" {\\\")\\n fasta.taxid = taxid_tokens[0]\\n elif key == \\\"PE\\\":\\n fasta.evidence = int(line[5])\\n elif key == \\\" \\\":\\n sequence_line = line.strip().replace(\\\" \\\", \\\"\\\")\\n fasta.sequence += sequence_line\\n elif key == \\\"//\\\":\\n yield fasta\\n fasta = Fasta(sequence=\\\"\\\")\",\n \"def fnmatch_filter(names, pat):\\r\\n import os,posixpath\\r\\n result=[]\\r\\n pat=os.path.normcase(pat)\\r\\n if not pat in _cache:\\r\\n res = translate(pat)\\r\\n if len(_cache) >= _MAXCACHE:\\r\\n _cache.clear()\\r\\n _cache[pat] = re.compile(res)\\r\\n match=_cache[pat].match\\r\\n if os.path is posixpath:\\r\\n # normcase on posix is NOP. Optimize it away from the loop.\\r\\n for name in names:\\r\\n m = match(name)\\r\\n if m:\\r\\n result.append((name, m.groups()))\\r\\n else:\\r\\n for name in names:\\r\\n m = match(os.path.normcase(name))\\r\\n if m:\\r\\n result.append((name, m.groups()))\\r\\n return result\",\n \"def filterfn(read):\\n return (read.is_proper_pair and read.is_paired and read.tlen > 0 and not read.is_supplementary and not read.is_duplicate and not read.is_unmapped and not read.mate_is_unmapped)\",\n \"def gen_grep(pattern, lines):\\n pat = re.compile(pattern)\\n for line in lines:\\n if pat.search(line):\\n yield line\",\n \"def process_fasta(file, type):\\n seqs = []\\n with open(file) as f:\\n seq = f.readline().strip()\\n seq = seq + '\\\\t'\\n for line in f:\\n line = line.strip()\\n if line[0] == \\\">\\\":\\n s1 = seq.split('\\\\t')\\n bac = s1[0].split(\\\"|\\\")[2]\\n sequence = to_word_index(s1[1], type)\\n seqs.append([bac, sequence])\\n seq = line + '\\\\t'\\n else:\\n seq = seq + line\\n\\n s1 = seq.split('\\\\t')\\n bac = s1[0].split(\\\"|\\\")[2]\\n sequence = to_word_index(s1[1], type)\\n seqs.append([bac, sequence])\\n\\n df = pd.DataFrame(seqs, columns=['bacteria', 'sequence'])\\n df = shuffle(df)\\n\\n return df\",\n \"def filter(self, *args):\\n exps = []\\n\\n #this ones can be improved. some are not getting extracted\\n if \\\"retweets\\\" in args:\\n exps.append(re.compile(\\\"^RT ?(?<=^|(?<=[^a-zA-Z0-9-_\\\\.]))@([A-Za-z]+[A-Za-z0-9-_]+):\\\"))\\n if \\\"emoticons\\\" in args:\\n exps.append(\\\"emoticons\\\")\\n if \\\"flags\\\" in args:\\n exps.append(re.compile(u\\\"[\\\\U0001F1E6-\\\\U0001F1FF]\\\"))\\n if \\\"handles\\\" in args:\\n # Handles at start of string\\n exps.append(re.compile(\\\"^\\\\s*((?<=^|(?<=[^\\\\S]))@([\\\\S]+)\\\\s*)*\\\"))\\n # Handles at end of string\\n exps.append(re.compile(\\\"\\\\s+((?<=^|(?<=[^\\\\S]))@(\\\\S+)\\\\s*)*$\\\"))\\n if \\\"urls\\\" in args:\\n exps.append(re.compile(\\\"(https?|ftp)://[^\\\\s/$.?#].[^\\\\s]*\\\"))\\n if \\\"hashtags\\\" in args:\\n # Hastags at start of string\\n exps.append(re.compile(\\\"^\\\\s*((?<=^|(?<=[^\\\\S]))#([\\\\S]+)\\\\s*)*\\\"))\\n # Hashtags at end of string\\n exps.append(re.compile(\\\"\\\\s+((?<=^|(?<=[^\\\\S]))#(\\\\S+)\\\\s*)*$\\\"))\\n\\n\\n # Use all filters\\n if \\\"*\\\" in args and not exps:\\n return self.filter(\\\"retweets\\\", \\\"emoticons\\\", \\\"flags\\\", \\\"handles\\\", \\\"urls\\\", \\\"hashtags\\\")\\n\\n filtering_text = self.raw_text\\n\\n for expression in exps:\\n if expression == \\\"emoticons\\\":\\n filtering_text = ''.join(c for c in filtering_text if c not in emoji.UNICODE_EMOJI)\\n else:\\n filtering_text = re.sub(expression, \\\"\\\", filtering_text)\\n\\n # Remove extra spaces\\n self.clean_text = re.sub(r\\\"\\\\s\\\\s+\\\", ' ', filtering_text.strip())\\n return self.clean_text\",\n \"def filter_by_minimum_length(\\n self, min_length: int, output_file: Path = None, point_to_new_file: bool = True\\n ) -> None:\\n if output_file is None:\\n output_file = (\\n Path(self._input_file.parent)\\n / f\\\"{self._input_file.stem}_minlength{self._input_file.suffix}\\\"\\n )\\n else:\\n output_file = Path(output_file)\\n fasta = pyfastx.Fasta(\\n self.file_path.as_posix(), build_index=False, full_name=True\\n )\\n with open(output_file, \\\"w+\\\", encoding=\\\"UTF-8\\\") as outfile:\\n for record_name, record_seq in fasta:\\n if len(record_seq) >= min_length:\\n outfile.write(f\\\">{record_name}\\\\n{record_seq}\\\\n\\\")\\n if point_to_new_file:\\n self.file_path = output_file\",\n \"def readFasta(self, fp):\\n\\t\\t\\n\\t\\tfor head, seq in self.parseFasta(fp):\\n\\t\\t\\t#analyzing the sequence\\n\\t\\t\\tself.analyzeSequence(seq)\\n\\t\\t\\t#saving the header\\n\\t\\t\\tif head == '':\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\telse:\\t\\n\\t\\t\\t\\tself.header.append(head)\",\n \"def filter_matches(filename, e):\\n transcription_factors = []\\n with open(filename) as f:\\n for record in NCBIXML.parse(f):\\n best = e\\n if record.alignments:\\n for alignment in record.alignments:\\n for hsp in alignment.hsps:\\n if hsp.expect < best:\\n best = hsp.expect\\n\\n if best < e:\\n iden = record.query.split(\\\" \\\")[0]\\n locus = iden.split(\\\"|\\\")[1]\\n transcription_factors.append(locus)\\n\\n return transcription_factors\",\n \"def filter_lines(lines, filter_regex, groups=None):\\n pattern = re.compile(filter_regex)\\n for line in lines:\\n match = pattern.search(line)\\n if match:\\n if groups is None:\\n yield line\\n elif len(groups) == 1:\\n yield match.group(groups[0])\\n else:\\n matched_groups = match.groupdict()\\n yield tuple(matched_groups.get(group) for group in groups)\",\n \"def scan(self, pat):\\n re_pat = re.compile(pat)\\n for infilename in self.file_names:\\n infile = open(infilename, 'r')\\n for line in infile:\\n line = line.rstrip()\\n mo = re_pat.search(line)\\n if mo is not None:\\n print '%s:%s' % (infilename, line, )\",\n \"def get_filtered_record(csv_fname):\\n with open(csv_fname, \\\"r\\\") as student_records:\\n for student_record in csv.reader(student_records):\\n converted = [re.sub('[^a-z0-9]+', '', x.lower()) for x in student_record]\\n yield converted\",\n \"def filter(self, line):\\n items = line.strip(\\\"\\\\n\\\").split(\\\"\\\\t\\\")\\n read_name = items[0]\\n strand = items[1]\\n ref_seq = items[2]\\n coord = int(items[3])\\n attr = {\\n 'seq_as_aligned' : items[4],\\n 'qualstr' : items[5],\\n 'mismatch_str' : items[7],\\n 'type' : \\\"alignment\\\",\\n 'ID' : read_name,\\n } # yapf: disable\\n\\n iv = GenomicSegment(ref_seq, coord, coord + len(attr['seq_as_aligned']), strand)\\n feature = SegmentChain(iv, **attr)\\n return feature\",\n \"def filterAudioFilesFromFilelist(filelist):\\n audioFileList = []\\n for audioFilter in filelist:\\n audioRoot, audioExt = os.path.splitext(audioFilter)\\n if audioExt in ['.wav', '.aiff', '.aif']:\\n audioFileList.append(audioFilter)\\n # end for loop\\n return audioFileList\",\n \"def test_write_trunc_fasta(self):\\r\\n\\r\\n seq_order = ['seq1', 'seq2', 'seq3']\\r\\n\\r\\n seqs = {'seq1': 'ATCG', 'seq3': 'ACCC', 'seq2': 'GGACC'}\\r\\n\\r\\n output_dir = '/tmp/truncate_fasta_qual_test/'\\r\\n\\r\\n create_dir(output_dir)\\r\\n\\r\\n fasta_out_fp = output_dir + 'seqs_filtered.fna'\\r\\n\\r\\n write_trunc_fasta(seqs, fasta_out_fp, seq_order)\\r\\n\\r\\n expected_seqs = ['>seq1', 'ATCG', '>seq2', 'GGACC', '>seq3', 'ACCC']\\r\\n\\r\\n actual_fasta = open(fasta_out_fp, \\\"U\\\")\\r\\n\\r\\n actual_fasta = [line.strip() for line in actual_fasta]\\r\\n\\r\\n self.assertEqual(actual_fasta, expected_seqs)\",\n \"def fastq_to_fasta(input_file, wanted_set):\\n file_name = os.path.splitext(os.path.basename(input_file))[0]\\n with open(file_name + \\\"_filtered.fasta\\\", \\\"w\\\") as out:\\n for record in SeqIO.parse(input_file, \\\"fastq\\\"):\\n ID = str(record.id)\\n SEQ = str(record.seq)\\n if ID in wanted_set:\\n out.write(\\\">\\\" + ID + \\\"\\\\n\\\" + SEQ + \\\"\\\\n\\\")\",\n \"def regex_filter(regex_str, versions):\\n regex = re.compile(regex_str)\\n return [v for v in versions if regex.search(v)]\",\n \"def is_fastq_regex(fastq_regex):\\n if \\\"{sample}\\\" not in fastq_regex:\\n raise argparse.ArgumentTypeError(\\n \\\"The regex should contain at least the wildcard '{sample}'.\\\")\\n return fastq_regex\",\n \"def filterPotentialChimeras(self, min_length=30, flag=0, target=None):\\n logger.debug('Filtering {} for potential chimeras'.format(target))\\n target = '{}.filter.fasta'.format(target.rpartition(\\\".\\\")[0])\\n if os.path.exists(target):\\n logger.info('Skipping filtering for {}'.format(target))\\n else:\\n with open(target, 'w') as oH:\\n with open(self.fileName) as iH:\\n for row in csv.reader(iH, delimiter=\\\"\\\\t\\\"):\\n if not row[0].startswith('@') and row[1] == str(flag):\\n if len(row[9]) >= 30:\\n print(textwrap.fill('>%s' % row[0], width=80), file=oH)\\n print(textwrap.fill('%s' % row[9], width=80), file=oH)\\n logger.debug('Filtering finished')\\n return target\",\n \"def scan_source(filename, def_re = None, cb = (lambda l,m : None) ) :\\n import re\\n\\n if not def_re :\\n storage_class = br\\\"(static\\\\s+)?\\\"\\n type_and_name = br\\\"int\\\\s+(?P<n>test_[_a-zA-Z0-9]*)\\\";\\n args=br\\\"\\\\(.*\\\\)\\\";\\n def_re = re.compile(b\\\"\\\\s*\\\" + storage_class +\\n type_and_name + b\\\"\\\\s*\\\" +\\n args );\\n\\n tests = set()\\n with open(filename, \\\"rb\\\") as f:\\n for line in f:\\n m = def_re.match(line)\\n if not m : continue\\n cb(line, m)\\n tests.add( m.group('n').strip().decode('utf-8') )\\n return tests\",\n \"def main():\\n # Handel the file opening of the FASTA file to be searched\\n file = open(r\\\"C:\\\\Users\\\\doodw\\\\PycharmProjects\\\\Zalgorithm\\\\venv\\\\input\\\\testfasta.fasta\\\", 'r')\\n # Create an empty string to hold text sequence\\n sequence = \\\"\\\"\\n # Flag to ensure only one sequence is read from the Fasta\\n single_sequence_flag = False\\n # Read in and concatenate sequence lines from Fasta file\\n for line in file:\\n if line.find('>') != -1: # Header ignored\\n # Ignores multiple sequences in Fasta file\\n if single_sequence_flag:\\n break\\n continue\\n else:\\n line = line.strip().lower()\\n sequence += line\\n\\n # Prompt the user for query\\n query = input(\\\"Please enter a DNA sequence to search for: \\\").strip().lower()\\n\\n # Call the z-algorithm\\n output = z_algorithm(sequence, query)\\n\\n # Print the output form the z-algorithm\\n for index in output:\\n print(\\\"A perfect match found at: \\\" + str(index))\",\n \"def match(self, *args):\\n return _ida_hexrays.microcode_filter_t_match(self, *args)\",\n \"def _compile_audience_pattern(self, pattern):\\n re_pattern = fnmatch.translate(pattern)\\n if \\\"://\\\" not in pattern:\\n re_pattern = \\\"[a-z]+://\\\" + re_pattern\\n return re.compile(re_pattern)\",\n \"def valid_fastq_filename_pattern():\\n # 'xxx_R_1.fastq.gz and xxx_R_2.fastq.gz'\\n return r\\\"^.+_R_[1-2]{1}\\\\.fastq.gz$\\\"\",\n \"def file_matches(self, text):\\n \\n #print 'Completer->file_matches: <%s>' % text # dbg\\n\\n # chars that require escaping with backslash - i.e. chars\\n # that readline treats incorrectly as delimiters, but we\\n # don't want to treat as delimiters in filename matching\\n # when escaped with backslash\\n \\n protectables = ' ()[]{}'\\n\\n def protect_filename(s):\\n return \\\"\\\".join([(ch in protectables and '\\\\\\\\' + ch or ch)\\n for ch in s])\\n\\n lbuf = self.get_line_buffer()[:self.readline.get_endidx()]\\n open_quotes = 0 # track strings with open quotes\\n try:\\n lsplit = shlex_split(lbuf)[-1]\\n except ValueError:\\n # typically an unmatched \\\", or backslash without escaped char.\\n if lbuf.count('\\\"')==1:\\n open_quotes = 1\\n lsplit = lbuf.split('\\\"')[-1]\\n elif lbuf.count(\\\"'\\\")==1:\\n open_quotes = 1\\n lsplit = lbuf.split(\\\"'\\\")[-1]\\n else:\\n return None\\n except IndexError:\\n # tab pressed on empty line\\n lsplit = \\\"\\\"\\n\\n if lsplit != protect_filename(lsplit):\\n # if protectables are found, do matching on the whole escaped\\n # name\\n has_protectables = 1\\n text0,text = text,lsplit\\n else:\\n has_protectables = 0\\n text = os.path.expanduser(text)\\n \\n if text == \\\"\\\":\\n return [protect_filename(f) for f in self.glob(\\\"*\\\")]\\n\\n m0 = self.clean_glob(text.replace('\\\\\\\\',''))\\n if has_protectables:\\n # If we had protectables, we need to revert our changes to the\\n # beginning of filename so that we don't double-write the part\\n # of the filename we have so far\\n len_lsplit = len(lsplit)\\n matches = [text0 + protect_filename(f[len_lsplit:]) for f in m0]\\n else:\\n if open_quotes:\\n # if we have a string with an open quote, we don't need to\\n # protect the names at all (and we _shouldn't_, as it\\n # would cause bugs when the filesystem call is made).\\n matches = m0\\n else:\\n matches = [protect_filename(f) for f in m0]\\n if len(matches) == 1 and os.path.isdir(matches[0]):\\n # Takes care of links to directories also. Use '/'\\n # explicitly, even under Windows, so that name completions\\n # don't end up escaped.\\n matches[0] += '/'\\n return matches\",\n \"def parse_filtering_file(file_path):\\n\\n # Initialize variables\\n filtering_options = []\\n\\n # Read in the default filtering options\\n with open(file_path, 'r') as input_fh:\\n # Iterate through every line of the file\\n for line in input_fh.readlines():\\n\\n # Check to make sure the line is formatted correctly\\n if len(line.strip()) > 2 and line.startswith(('-', '+')):\\n # Append the filtering option\\n if line[1] == ' ':\\n filtering_options.append((line[0], line.strip()[2:]))\\n elif not line.startswith('#'):\\n logging.warning('\\\\tInvalid regex filtering line: {}'.format(line.strip()))\\n\\n return filtering_options\",\n \"def set_import_filter(self, regex: Union[str, re.Pattern], blacklist: bool = False):\\n self._variables['IMPORT_FILTER'] = (\\n re.compile(regex) if isinstance(regex, str) else regex,\\n bool(blacklist)\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69491684","0.6156863","0.60775024","0.59450454","0.5645844","0.55811054","0.5563482","0.5525892","0.5522686","0.5514822","0.55063164","0.5468016","0.5430675","0.5412103","0.5391324","0.5378578","0.53772795","0.53680974","0.5331787","0.5308409","0.53036493","0.52847487","0.5248258","0.52299935","0.5220231","0.52104557","0.51705825","0.51566166","0.51423025","0.513732","0.511945","0.51013","0.5092486","0.5084411","0.50788665","0.5076931","0.50709504","0.5068663","0.5055492","0.50478905","0.50425506","0.5042076","0.5032369","0.5026573","0.50260335","0.5024215","0.5017361","0.50146425","0.5012087","0.5010963","0.50104225","0.5008903","0.5001552","0.4973374","0.49559376","0.49557042","0.49545115","0.4952763","0.4933522","0.49285197","0.4920527","0.49164602","0.49133232","0.48976758","0.4894022","0.48908278","0.48848912","0.4879733","0.48751733","0.48706794","0.48695362","0.4863659","0.48627862","0.48602","0.48601416","0.48595876","0.48583966","0.48523262","0.48395646","0.48393923","0.48313293","0.48306838","0.48279807","0.48256478","0.48220915","0.4816427","0.4815542","0.48154315","0.48035967","0.4802129","0.480037","0.47962856","0.47943464","0.4790168","0.47888413","0.4782802","0.47823805","0.47748688","0.47674292","0.475986"],"string":"[\n \"0.69491684\",\n \"0.6156863\",\n \"0.60775024\",\n \"0.59450454\",\n \"0.5645844\",\n \"0.55811054\",\n \"0.5563482\",\n \"0.5525892\",\n \"0.5522686\",\n \"0.5514822\",\n \"0.55063164\",\n \"0.5468016\",\n \"0.5430675\",\n \"0.5412103\",\n \"0.5391324\",\n \"0.5378578\",\n \"0.53772795\",\n \"0.53680974\",\n \"0.5331787\",\n \"0.5308409\",\n \"0.53036493\",\n \"0.52847487\",\n \"0.5248258\",\n \"0.52299935\",\n \"0.5220231\",\n \"0.52104557\",\n \"0.51705825\",\n \"0.51566166\",\n \"0.51423025\",\n \"0.513732\",\n \"0.511945\",\n \"0.51013\",\n \"0.5092486\",\n \"0.5084411\",\n \"0.50788665\",\n \"0.5076931\",\n \"0.50709504\",\n \"0.5068663\",\n \"0.5055492\",\n \"0.50478905\",\n \"0.50425506\",\n \"0.5042076\",\n \"0.5032369\",\n \"0.5026573\",\n \"0.50260335\",\n \"0.5024215\",\n \"0.5017361\",\n \"0.50146425\",\n \"0.5012087\",\n \"0.5010963\",\n \"0.50104225\",\n \"0.5008903\",\n \"0.5001552\",\n \"0.4973374\",\n \"0.49559376\",\n \"0.49557042\",\n \"0.49545115\",\n \"0.4952763\",\n \"0.4933522\",\n \"0.49285197\",\n \"0.4920527\",\n \"0.49164602\",\n \"0.49133232\",\n \"0.48976758\",\n \"0.4894022\",\n \"0.48908278\",\n \"0.48848912\",\n \"0.4879733\",\n \"0.48751733\",\n \"0.48706794\",\n \"0.48695362\",\n \"0.4863659\",\n \"0.48627862\",\n \"0.48602\",\n \"0.48601416\",\n \"0.48595876\",\n \"0.48583966\",\n \"0.48523262\",\n \"0.48395646\",\n \"0.48393923\",\n \"0.48313293\",\n \"0.48306838\",\n \"0.48279807\",\n \"0.48256478\",\n \"0.48220915\",\n \"0.4816427\",\n \"0.4815542\",\n \"0.48154315\",\n \"0.48035967\",\n \"0.4802129\",\n \"0.480037\",\n \"0.47962856\",\n \"0.47943464\",\n \"0.4790168\",\n \"0.47888413\",\n \"0.4782802\",\n \"0.47823805\",\n \"0.47748688\",\n \"0.47674292\",\n \"0.475986\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6979984"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83194,"cells":{"query":{"kind":"string","value":"Detects faces in images, returns a list with images that contain faces and saves these face images in the FacePhoto directory."},"document":{"kind":"string","value":"def detectFaces_allFiles(directory):\n files_list = glob.glob(directory)\n for file in files_list:\n print(file)\n img = cv2.imread(file)\n if img is not None:\n height, width, channel = img.shape\n faces = face_cascade.detectMultiScale(img, 1.3, 5)\n age = find_age(file)\n\n if age >= 0:\n if faces != ():\n for (x, y, w, h) in faces:\n # On decale y vers le haut pour mieux centrer le visage\n if y - int(0.1*h) >= 0:\n y -= int(0.1*h)\n h *= 1.2\n else:\n h += y + int(0.1*h)\n y = 0\n if h > width:\n h = width\n # A partir de l'origine du visage (point en haut a gauche), on definit\n # notre carre, de cote le nouveau h\n if x + 0.8*h > width:\n x_right = width\n x_left = width - int(h)\n elif x - 0.2*h < 0:\n x_left = 0\n x_right = int(h)\n else:\n x_right = min(int(x) + int(0.8*h), int(width))\n x_left = int(x_right) - int(h)\n y_top = int(y)\n y_bottom = int(y) + int(h)\n roi_color = img[y_top:y_bottom, x_left:x_right]\n cv2.imwrite(\"./FacePhoto/{}.jpg\".format(extract_filename(file)), resize_image(roi_color, 227))\n else:\n files_list.remove(file)\n else:\n files_list.remove(file)\n cv2.destroyAllWindows()\n return files_list"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def extract_face_detections(self):\n self.detector.setInput(self.image_blob)\n self.detections = self.detector.forward()","def detect_faces(image):\n\n face_locations = face_recognition.face_locations(image)\n return face_locations","def get_check_folder():\r\n filelist = [file for file in os.listdir('temp') if file.endswith('.png')]\r\n image_count = len(filelist)\r\n if image_count == 0:\r\n print\"No faces detected in image.\"\r\n exit()\r\n print \"Detected \"+str(image_count)+\" faces in the image.\"\r\n if filelist:\r\n for image_path in filelist:\r\n target = cv2.imread(\"temp/\" + image_path)\r\n cv2.imshow(\"detected face\", target)\r\n k = cv2.waitKey(1) & 0xFF\r\n img_to_del = Image.open(\"temp/\" + image_path)\r\n for folder in get_immediate_subdirectories():\r\n count = 0\r\n val = 0\r\n folder_filelist = [file for file in os.listdir(\"detected_faces/\" + folder) if\r\n file.endswith('.png')]\r\n for file in folder_filelist:\r\n img_to_compare = Image.open(\"detected_faces/\" + folder + \"/\" + file)\r\n if img_to_del.size > img_to_compare.size:\r\n temp_image_resized = img_to_del.resize(img_to_compare.size, Image.ANTIALIAS)\r\n index = get_ssim(temp_image_resized, img_to_compare)\r\n elif img_to_del.size < img_to_compare.size:\r\n img_to_compare = img_to_compare.resize(img_to_del.size, Image.ANTIALIAS)\r\n index = get_ssim(img_to_del, img_to_compare)\r\n else:\r\n index = get_ssim(img_to_del, img_to_compare)\r\n val += index\r\n count += 1\r\n if count > 0:\r\n index = val/count\r\n if index > min_ssim_index_val:\r\n print \" Detected a face in DB folder \"+ folder\r\n if os.path.isfile(os.path.join(temp_path, image_path)):\r\n os.remove(os.path.join(temp_path, image_path))","def find_all_faces_in_one_img(img_path, detector, img_size, dst_path):\r\n\r\n img_path = img_path.replace('\\\\', '/')\r\n img_name = img_path.split(sep='/')[-1].split(sep='.')[0]\r\n\r\n assert img_path.split(sep='/')[-1].split(sep='.')[1] in [\r\n 'png', 'jpg'], 'files should be images with a \".jpg\" or \".png\" extension !'\r\n\r\n img_extension = '.jpg'\r\n\r\n all_detected_faces, detection_status = faces_detector(\r\n img_path, detector, img_size, threshold_confidence=0.90)\r\n\r\n if detection_status == 'success':\r\n for faces in all_detected_faces:\r\n cv.imwrite(os.path.join(dst_path, img_name + img_extension), faces)\r\n elif detection_status == 'failure':\r\n os.remove(img_path)\r\n\r\n return detection_status","def detect_faces(self, img):\n with tf.Graph().as_default():\n gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=.7)\n sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False))\n with sess.as_default():\n pnet, rnet, onet = detect_face.create_mtcnn(sess, None)\n\n minsize = 20 # minimum size of face\n threshold = [ 0.6, 0.7, 0.7 ] # three steps's threshold\n factor = 0.709 # scale factor\n\n bounding_boxes, _ = detect_face.detect_face(img, minsize, pnet, rnet, onet, threshold, factor)\n\n nrof_faces = bounding_boxes.shape[0]\n img_size = np.asarray(img.shape)[0:2]\n\n faces = []\n faces_rects = []\n\n for i in range(nrof_faces):\n det = bounding_boxes[i,0:4]\n bb = np.zeros(4, dtype=np.int32)\n bb[0] = np.maximum(det[0]-5/2, 0)\n bb[1] = np.maximum(det[1]-5/2, 0)\n bb[2] = np.minimum(det[2]+5/2, img_size[1])\n bb[3] = np.minimum(det[3]+5/2, img_size[0])\n faces.append(img[bb[1]:bb[3], bb[0]:bb[2], :])\n faces_rects.append({'name': 'none', 'x': bb[0], 'y': bb[1], 'w': bb[2]-bb[0], 'h': bb[3]-bb[1]})\n\n return [img, faces, faces_rects]","def detectFaces():\n faceEngine = VLFaceEngine()\n detector = faceEngine.createFaceDetector(DetectorType.FACE_DET_V3)\n\n imageWithOneFace = VLImage.load(filename=EXAMPLE_O)\n pprint.pprint(detector.detectOne(imageWithOneFace, detect5Landmarks=False, detect68Landmarks=False).asDict())\n detection = detector.detectOne(imageWithOneFace, detect5Landmarks=False, detect68Landmarks=False)\n pprint.pprint(detector.redetectOne(image=imageWithOneFace, bBox=detection))\n pprint.pprint(detector.redetectOne(image=imageWithOneFace, bBox=detection.boundingBox.rect))\n\n imageWithSeveralFaces = VLImage.load(filename=EXAMPLE_SEVERAL_FACES)\n severalFaces = detector.detect([imageWithSeveralFaces], detect5Landmarks=False, detect68Landmarks=False)\n\n pprint.pprint(\n detector.redetect(\n images=[\n ImageForRedetection(imageWithSeveralFaces, [face.boundingBox.rect for face in severalFaces[0]]),\n ImageForRedetection(imageWithOneFace, [detection.boundingBox.rect]),\n ImageForRedetection(imageWithOneFace, [Rect(0, 0, 1, 1)]),\n ]\n )\n )","def detect_faces(self, image):\n return self.face_detector(image, 1)","def face_detector(img):\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n\n # faceCascade imports in the previously made classifier\n faceCascade = cv2.CascadeClassifier('src/face_detection/haarcascade_frontalface_default.xml')\n faces = faceCascade.detectMultiScale(\n gray, \n scaleFactor=1.2,\n minNeighbors=1, \n minSize=(100, 100)\n )\n\n return faces","def _open_images(training_filenames, path):\n imagePaths=[os.path.join(path,f) for f in training_filenames]\n faces=[]\n for i, imagePath in enumerate(imagePaths):\n faceImg=Image.open(imagePath).convert('L')\n faceNp=np.array(faceImg,'uint8')\n faces.append(faceNp)\n return faces","def _load_known_faces(self):\n faces_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'faces')\n faces = [\n os.path.join(faces_dir, f) for f in os.listdir(faces_dir) \\\n if f.endswith('.jpeg') or f.endswith('.jpg') or f.endswith('.png')\n ]\n known_images = [face_recognition.load_image_file(i) for i in faces]\n self.known_faces = []\n self.faces_names = [x.split('/')[-1].split('.')[0].replace('_', ' ').title() for x in faces]\n for image in known_images:\n encoding = face_recognition.face_encodings(image)\n if len(encoding) > 0:\n logging.debug('Adding known face')\n self.known_faces.append(encoding[0])","def face_detection(image, xml_path):\n\n face_cascade = cv2.CascadeClassifier(xml_path)\n faces = face_cascade.detectMultiScale(image, 1.3, 5)\n\n images = []\n\n for face in faces:\n x_beginning, y_beginning, face_width, face_height = face\n roi_img = image[y_beginning:y_beginning + face_height, x_beginning:x_beginning + face_width]\n\n images.append(roi_img)\n\n return faces, images","def _load_known_face(self):\n faces_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'faces')\n faces = [os.path.join(faces_dir, f) for f in os.listdir(faces_dir) if f.endswith('.jpeg')]\n known_images = [face_recognition.load_image_file(i) for i in faces]\n self.known_faces = []\n for image in known_images:\n encoding = face_recognition.face_encodings(image)\n if len(encoding) > 0:\n logging.debug('Adding known face')\n self.known_faces.append(encoding[0])","def faces(self, image):\n\n response = self._send_request(\"faces\", files=dict(image=image))\n return response['objectdetection']","def get_faces(image):\n return (image.crop(face) for face in image.faces)","def get_faces(self, img):\n results = self.detect_and_draw(img, False)\n (width, height) = cv.GetSize(img)\n for result in results:\n self.add_property('name', 'face')\n self.add_property('pixel_location', result[0])\n self.add_property('relative_location', (float(result[0][0]) / width, float(result[0][1]) / height))\n self.add_property('angle_and_distance', result[1])\n self.add_property('face_area', result[2])\n self.add_property('width', result[4])\n self.add_property('height', result[5])\n self.add_property('relative_face_area', (float(result[2]) / (width * height)))\n self.add_property('confidence', result[3])\n self.add_property('dimensions', (width, height))\n self.add_property('rotation', self.rotation)\n self.store_observation()","def find_all_faces_in_multiple_img(img_dir_path, detector, img_size, dst_path):\r\n\r\n number_of_faces_already_found = count_files_in_one_directory(dst_path)\r\n print('number_of_faces_already_found', number_of_faces_already_found)\r\n for filename in os.listdir(img_dir_path):\r\n try:\r\n # When the user decides to add new data to existing one, no need to deal again (refind faces) with the old data\r\n if list(map(int, re.findall(r'\\d+', filename)))[0] < number_of_faces_already_found:\r\n continue\r\n img_path = os.path.join(img_dir_path, filename)\r\n print(filename + ': IN PROGRESS')\r\n detection_status = find_all_faces_in_one_img(\r\n img_path, detector, img_size, dst_path)\r\n print(filename + ': {}\\n'.format(detection_status.upper()))\r\n except:\r\n continue","def extract_faces(self, img, list_face_coord):\n #from the img array extract the facees\n list_faces = []\n #Go through each face coordinates and store the array\n #or clip face region in the list\n for i, coord in enumerate(list_face_coord):\n left, top, right, bottom = coord\n list_faces.append(img[top:bottom, left:right])\n return list_faces","def get_faces(self, image):\n\t\t\n\t\t# Convert the image to grayscale and normalise\n\t\tcv.CvtColor(image, self.gray, cv.CV_BGR2GRAY)\n\t\tcv.EqualizeHist(self.gray, self.gray)\n\t\t\n\t\t# Detect faces\n\t\treturn cv.HaarDetectObjects(self.gray, self.cascade, self.storage,\n\t\t scale_factor = 1.3,\n\t\t min_neighbors = 2,\n\t\t flags = cv.CV_HAAR_DO_CANNY_PRUNING,\n\t\t min_size = (40,40))","def faces(self):\n res = []\n if(self.isFacesLoaded() == False):\n return res\n for face in self.getCurrentCacheData()['faces']:\n face = Face().setJSONData(face)\n if(face.confidence > self.faceDetector.confThreshold):\n res.append(face)\n return res","def detect_faces_from_image(self, img, desired_width,\n desired_height, bbox_scaling=1.1):\n \n n_face = 0\n faces_data = []\n\n frame_height = img.shape[0]\n frame_width = img.shape[1]\n blob = cv2.dnn.blobFromImage(img, 1.0, (300, 300), [104, 117, 123], True, False)\n self.face_detector.setInput(blob)\n detections = self.face_detector.forward()\n \n \n for i in range(detections.shape[2]):\n confidence = detections[0, 0, i, 2]\n if confidence > self.threshold:\n n_face += 1\n bbox = _get_bbox_pts(detections, i, frame_width, frame_height)\n x1, y1 = [int(i * abs(bbox_scaling//1 - bbox_scaling%1)) for i in bbox[:2]]\n x2, y2 = [int(i*bbox_scaling) for i in bbox[2:]]\n if x1 < x2 and y1 < y2:\n dets = [dlib.rectangle(x1, y1, x2, y2)]\n else:\n dets = [dlib.rectangle(0, 0, frame_width, frame_height)]\n\n \n face_img, left_eye, right_eye = self.align_and_crop_face(img, dets, desired_width,\n desired_height)\n \n face_data = [dets, face_img, left_eye, right_eye,\n 'face_%d' % n_face, confidence]\n faces_data.append(face_data)\n\n return faces_data","def detect_faces(self, img) -> list:\r\n if img is None or not hasattr(img, \"shape\"):\r\n raise InvalidImage(\"Image not valid.\")\r\n\r\n height, width, _ = img.shape\r\n stage_status = StageStatus(width=width, height=height)\r\n\r\n m = 12 / self._min_face_size\r\n min_layer = np.amin([height, width]) * m\r\n\r\n scales = self.__compute_scale_pyramid(m, min_layer)\r\n\r\n stages = [self.__stage1, self.__stage2, self.__stage3]\r\n result = [scales, stage_status]\r\n\r\n # We pipe here each of the stages\r\n for stage in stages:\r\n result = stage(img, result[0], result[1])\r\n\r\n [total_boxes, points] = result\r\n\r\n bounding_boxes = []\r\n\r\n for bounding_box, keypoints in zip(total_boxes, points.T):\r\n x = max(0, int(bounding_box[0]))\r\n y = max(0, int(bounding_box[1]))\r\n width = int(bounding_box[2] - x)\r\n height = int(bounding_box[3] - y)\r\n bounding_boxes.append({\r\n 'box': [x, y, width, height],\r\n 'confidence': bounding_box[-1],\r\n 'keypoints': {\r\n 'left_eye': (int(keypoints[0]), int(keypoints[5])),\r\n 'right_eye': (int(keypoints[1]), int(keypoints[6])),\r\n 'nose': (int(keypoints[2]), int(keypoints[7])),\r\n 'mouth_left': (int(keypoints[3]), int(keypoints[8])),\r\n 'mouth_right': (int(keypoints[4]), int(keypoints[9])),\r\n }\r\n })\r\n\r\n return bounding_boxes","def get_faceboxes(self, image, threshold):\n rows, cols, _ = image.shape\n\n confidences = []\n faceboxes = []\n\n self.face_net.setInput(cv2.dnn.blobFromImage(image, 1.0, (300, 300), (104.0, 177.0, 123.0), False, False))\n\n detections = self.face_net.forward()\n\n if debug > 2 :\n print(\"number of face found:\", len (detections[0, 0, :, :]))\n\n for result in detections[0, 0, :, :]:\n confidence = result[2]\n if confidence >= threshold:\n x_left_bottom = int(result[3] * cols)\n y_left_bottom = int(result[4] * rows)\n x_right_top = int(result[5] * cols)\n y_right_top = int(result[6] * rows)\n confidences.append(confidence)\n faceboxes.append([x_left_bottom, y_left_bottom, x_right_top, y_right_top])\n\n if debug > 2 :\n print(\"number of detection > threshold\", len(faceboxes))\n\n self.detection_result = [faceboxes, confidences]\n\n return confidences, faceboxes","def face_detection(img, faceCascade=faceCascade):\n\tgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n\tfaces = faceCascade.detectMultiScale(\n\t\tgray,\n\t\tscaleFactor=1.2,\n\t\tminNeighbors=5,\n\t\tminSize=(32, 32))\n\n\t# If no face detected\n\tif len(faces) == 0:\n\t\tw = min(img.shape[0], img.shape[1])\n\t\treturn img[(img.shape[0]-w)//2:(img.shape[0]+w)//2, (img.shape[1]-w)//2:(img.shape[1]+w)//2, :]\n\n\t# If faces detected, choose the face with the max size\n\tmax_h, index = 0, 0\n\tfor i, (x, y, w, h) in enumerate(faces):\n\t\tif max_h < h:\n\t\t\tmax_h, index = h, i\n\n\t(x, y, w, h) = faces[index]\n\n\tif img.shape[0]>img.shape[1]:\n\t\tif x + w/2 < img.shape[0]/2:\n\t\t\treturn img[:img.shape[1],:,:]\n\n\t\telse:\n\t\t\treturn img[-img.shape[1]:,:,:]\n\n\telse:\n\t\tif y + h/2 < img.shape[1]/2:\n\t\t\treturn img[:,:img.shape[0],:]\n\n\t\telse:\n\t\t\treturn img[:,-img.shape[0]:,:]","def detect_face_task(img):\n\n # paramter for detect\n # image_size = 160\n # margin = 44\n minsize = 20 # minimum size of face\n threshold = [0.6, 0.7, 0.7] # three steps's threshold\n factor = 0.709 # scale factor\n\n # caffe model\n pnet = caffe_model.get_pnet()\n rnet = caffe_model.get_rnet()\n onet = caffe_model.get_onet()\n\n bounding_boxes, _ = detect_face.detect_face(img, minsize, pnet, rnet, onet, threshold, factor)\n print('detect bounding: ', bounding_boxes)\n print('Find faces: ', bounding_boxes.shape[0])\n\n # all_faces is faces information list, include face bytes, face position\n all_faces = []\n for face_position in bounding_boxes:\n face_position = face_position.astype(int)\n print('face position: ', face_position)\n\n # each face information, include position, face image\n head_rect = face_position[:4].tolist() # numpy array to python list\n head_img = misc.toimage(img).crop(head_rect)\n head_img_io = StringIO.StringIO()\n head_img.save(head_img_io, format='JPEG')\n head_img_b64 = base64.b64encode(head_img_io.getvalue())\n\n # construct response\n face_info = {}\n face_info['rect'] = head_rect\n face_info['image'] = head_img_b64\n\n all_faces.append(face_info)\n\n return all_faces","def detect_face(self, img, img_file_path=None):\n #use dlib face detector\n #create dlib detector, this is hog with svm\n detector = dlib.get_frontal_face_detector()\n #win = dlib.image_window()\n if img_file_path:\n img = dlib.load_rgb_image(img_file_path)\n #detect number of faces in an image\n dets = detector(img)\n list_face_coord = [] # this will store left, top, right, bottom\n for i, d in enumerate(dets):\n list_face_coord.append((d.left(), d.top(), d.right(), d.bottom()))\n return list_face_coord","def detect_faces(path):\n from google.cloud import vision\n from PIL import Image, ImageDraw\n import io\n\n client = vision.ImageAnnotatorClient()\n with io.open(path, 'rb') as image_file:\n content = image_file.read()\n\n image = vision.Image(content=content)\n response = client.face_detection(image=image)\n faces = response.face_annotations\n face_distance = [10000000] * len(faces)\n face_area = []\n face_vertices = []\n\n counter = 0\n for face in faces:\n face_vertices.append((face.bounding_poly.vertices[0].x, face.bounding_poly.vertices[0].y))\n face_area.append(area((face.bounding_poly.vertices[0].x, face.bounding_poly.vertices[0].y), \n (face.bounding_poly.vertices[1].x, face.bounding_poly.vertices[1].y),\n (face.bounding_poly.vertices[2].x, face.bounding_poly.vertices[2].y)))\n im = Image.open(path)\n cropped = im.crop((face.bounding_poly.vertices[0].x, face.bounding_poly.vertices[0].y, face.bounding_poly.vertices[2].x, face.bounding_poly.vertices[2].y))\n #cropped.show()\n cropped.save(\"./media/images/\" + str(counter) + \".jpg\")\n counter += 1\n \n for i in range(len(faces)):\n min_dist = 0\n for j in range(len(faces)):\n distance = dist(face_vertices[i], face_vertices[j])\n if distance > 0 and (face_area[i] + face_area[j]) / distance < face_distance[i]: \n face_distance[i] = (face_area[i] + face_area[j]) / distance\n \n \n with Image.open(path) as im:\n counter = 0\n \n draw = ImageDraw.Draw(im)\n for face in faces:\n draw.rectangle([face.bounding_poly.vertices[counter].x, face.bounding_poly.vertices[counter].y,\n face.bounding_poly.vertices[counter + 2].x, face.bounding_poly.vertices[counter + 2].y], None, \"#0000ff\", 3)\n for i in range(len(faces)):\n if face_distance[i] < 30 or len(faces) == 1: colour = \"#00ff00\"\n else: colour = \"#ff0000\"\n draw.rectangle([faces[i].bounding_poly.vertices[0].x, faces[i].bounding_poly.vertices[0].y,\n faces[i].bounding_poly.vertices[2].x, faces[i].bounding_poly.vertices[2].y], None, colour, 3)\n draw.text((faces[i].bounding_poly.vertices[0].x - 10, faces[i].bounding_poly.vertices[0].y - 10), str(i+1), \"#ff0000\",font=None, anchor=None, spacing=4, align='left', direction=None, features=None, language=None, stroke_width=1, stroke_fill=None, embedded_color=False)\n\n im.save(\"./media/images/upload.jpg\")\n return len(faces)\n if response.error.message:\n raise Exception('Error')","def detect_face(self, img):\n #convert the test image to gray image as opencv face detector expects gray images\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n\n #let's detect multiscale (some images may be closer to camera than others) images\n #result is a list of faces\n faces = self.face_cascade.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=5);\n\n #if no faces are detected then return None\n if (len(faces) == 0):\n return None, None\n\n #under the assumption that there will be only one face,\n #extract the face area\n (x, y, w, h) = faces[0]\n\n #return only the face part of the image\n return gray[y:y+w, x:x+h], faces[0]","def detect_face(face_file, max_results=4):\n client = vision.ImageAnnotatorClient()\n\n content = face_file.read()\n image = types.Image(content=content)\n\n return client.face_detection(image=image).face_annotations","def recognize_faces(image_file_path):\n image_pil = Image.open(image_file_path)\n draw = ImageDraw.Draw(image_pil)\n\n known_face_encodings_dict = get_known_face_encodings_dict()\n known_names = list(known_face_encodings_dict.keys())\n known_face_encodings = list(known_face_encodings_dict.values())\n\n del known_face_encodings_dict\n\n for face_location in face_detection.get_face_locations(image_file_path):\n face_encoding = get_face_encodings(\n image_file_path, known_face_locations=[face_location]\n )[0]\n\n recognition_flags = face_recognition.compare_faces(\n known_face_encodings, face_encoding\n )\n\n for flag, name in zip(recognition_flags, known_names):\n if not flag:\n continue\n\n top, right, bottom, left = face_location\n draw.rectangle((left, top, right, bottom), outline=\"#FF1493\")\n text_width, text_height = draw.textsize(name)\n draw.rectangle(\n (left, bottom, right, bottom + text_height + 10),\n fill=\"#FF1493\",\n outline=\"#FF1493\",\n )\n draw.text((left + 6, bottom + 5), name, fill=\"white\")\n\n del draw # conserve resources\n image_pil.show()","def read_known_faces():\n known_face_encodings = []\n known_face_names = []\n\n for file_name in glob.glob(DATASET_FOLDER + \"/*.jpg\"):\n face_encoding = read_face_encoding(file_name)\n\n known_face_encodings.append(face_encoding)\n\n name = file_name.split('.jpg')[0].split('/')[-1]\n if len(name.split('_')) != 2:\n raise Exception(\"\\n\\nERROR: file \\'\" + file_name + \"\\' has incorrect name\\n\\n\")\n\n known_face_names.append(name)\n\n return known_face_encodings, known_face_names","def detect_face(face_file, max_results=10):\n client = vision.ImageAnnotatorClient()\n\n content = face_file.read()\n image = types.Image(content=content)\n\n return client.face_detection(image=image).face_annotations","def get_image_with_faces(self, image):\n img = image.copy()\n faces = self.__detect_face(img)\n\n if len(faces) > 0:\n for i, d in enumerate(faces):\n x1, y1, x2, y2, _, _ = d.left(), d.top(), \\\n d.right() + 1, d.bottom() + 1, d.width(), d.height()\n cv2.rectangle(img, (x1, y1), (x2, y2), RECT_COLOR, RECT_THICKNESS)\n return img","def extract_faces(image_path: str, pk: int):\n image = Image.open(image_path)\n image = np.array(image)\n\n if image.shape[0] <= 0 or image.shape[1] <= 0:\n return None\n\n import mtcnn\n\n # detect faces from image\n face_detector = mtcnn.MTCNN()\n detections = face_detector.detect_faces(image)\n\n if len(detections) < 1:\n return None\n\n from deepface.basemodels.Facenet import InceptionResNetV2\n\n # load InceptionResNet model provided by deepface\n facenet_model = InceptionResNetV2()\n facenet_model.load_weights(get_weights(\"facenet\"))\n\n # normalize faces and get embeddings\n faces = [normalize_face(image, face) for face in detections]\n embeddings = facenet_model.predict(np.vstack(faces), batch_size=len(faces))\n\n for i in range(len(faces)):\n person_id = recognize_person(embeddings[i])\n print(person_id, flush=True)\n face_obj = models.Face.objects.create(\n confidence=detections[i]['confidence'],\n left=detections[i]['box'][0],\n top=detections[i]['box'][1],\n width=detections[i]['box'][2],\n height=detections[i]['box'][3],\n photo_id=pk,\n person_id=person_id\n )\n\n save_embeddings(embeddings[i], face_obj.id, person_id)","def __detect_face(self, img):\n gray = cv2.cvtColor(img.copy(), cv2.COLOR_BGR2GRAY)\n return self.detector(gray, 1)","def detect_face(self, img):\n # Fetch face location from the frame with 128 encoding of face landmarks\n curr_face_loc, name_list, info_list = load_encode_loc(img, self.kwn_names,\n self.kwn_encoding,\n self.status_list, self.since_list)\n print('Current value is ', curr_face_loc, name_list)\n face_list = []\n face_area = []\n print('face loc', curr_face_loc)\n if len(curr_face_loc):\n\n for (top, right, bottom, left), name in zip(curr_face_loc, name_list):\n print(top, right, bottom, left)\n cv2.rectangle(img, (top, right), (bottom, left), (0, 255, 2), 2)\n\n w = right - left\n h = bottom - top\n cx = left + w // 2\n cy = top + h // 2\n area = w * h\n\n for idx, info in enumerate(info_list):\n cv2.putText(img, info, (bottom, int(left * idx * 0.2)),\n cv2.FONT_HERSHEY_COMPLEX, 1,\n (0, 0, 255), 1)\n\n face_list.append([cx, cy])\n face_area.append(area)\n\n i = face_area.index(max(face_area))\n\n return img, [face_list[i], face_area[i]]\n\n else:\n return img, [[0, 0], 0]","def extract_faces(input_path, output_path=None, save=False, show=False):\r\n \r\n img = cv2.imread(input_path)\r\n gray = pp.grayscale(img);\r\n \r\n face_cascade = cv2.CascadeClassifier('/Haar_Filters/haarcascade_frontalface_default.xml')\r\n faces = face_cascade.detectMultiScale(gray,1.05,4)\r\n \r\n if save:\r\n for i,(x,y,w,h) in enumerate(faces):\r\n face = img[y:y+h, x:x+w]\r\n if len(face_cascade.detectMultiScale(face,1.05,6)) == 1:\r\n cv2.imwrite(output_path+'/'+str(i)+'.jpeg', face)\r\n \r\n if show:\r\n for i,(x,y,w,h) in enumerate(faces):\r\n face = img[y:y+h, x:x+w]\r\n if len(face_cascade.detectMultiScale(face,1.05,6)) == 1:\r\n cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),3)\r\n else:\r\n cv2.rectangle(img,(x,y),(x+w,y+h),(0,0,255),3)\r\n pp.show_image(pp.resize_image(img, 1000))","def detect_face(gray):\r\n face_cascade = cv2.CascadeClassifier(classifier_file_name)\r\n faces = face_cascade.detectMultiScale(gray, scaleFactor=scale_factor,minNeighbors=min_neighbors,minSize=min_size,flags=flags)\r\n return faces","def ssd_face_detection(image):\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n image_np_expanded = np.expand_dims(image, axis=0)\n\n (boxes, scores, classes) = FaceDetectorModel().sess.run(\n [FaceDetectorModel().boxes, FaceDetectorModel().scores, FaceDetectorModel().classes],feed_dict={FaceDetectorModel().image_tensor: image_np_expanded})\n\n face_list = vis_util.visualize_boxes_and_labels_on_image_array(\n image,\n np.squeeze(boxes),\n np.squeeze(classes).astype(np.int32),\n np.squeeze(scores),\n category_index,\n use_normalized_coordinates=True,\n line_thickness=4)\n\n return face_list","def findFaces(self):\n\t\trects = self.detectAll()\n\t\tif len(rects)==0:\n\t\t\trects = []\n\t\telse:\n\t\t\trects[:, 2:] += rects[:, :2]\n\t\tself.analyzeFrame(rects)","def _box_faces(image):\n for face in image.faces:\n _box_face(image, face)\n return image","def face_detect(sess, net, image_name):\n\n\t# Load the demo image\n\tim_file = os.path.join(cfg.DATA_DIR, 'demo', image_name)\n\tim = cv2.imread(im_file)\n\n\t# Detect all object classes and regress object bounds\n\ttimer = Timer()\n\ttimer.tic()\n\t# scores, boxes = im_detect(sess, net, im)\n\tscores, boxes, eyes, smiles = im_detect_ori(sess, net, im)\n\ttimer.toc()\n\tprint ('Detection took {:.3f}s for '\n\t\t\t'{:d} object proposals').format(timer.total_time, boxes.shape[0])\n\n\t# Visualize detections for each class\n\t# im = im[:, :, (2, 1, 0)]\n\t# fig, ax = plt.subplots(figsize=(8, 8))\n\t# ax.imshow(im, aspect='equal')\n\n\tCONF_THRESH = 0.9\n\tNMS_THRESH = 0.3\n\tfor cls_ind, cls in enumerate(CLASSES[20:]):\n\t\tcls_ind += 20 # because we skipped everything except face\n\t\tcls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\n\t\tcls_scores = scores[:, cls_ind]\n\t\tdets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)\n\t\tkeep = nms(dets, NMS_THRESH)\n\t\tdets = dets[keep, :]\n\t\teye = eyes[keep, :]\n\t\tsmile= smiles[keep, :]\n\n\tinds = np.where(dets[:, -1] >= CONF_THRESH)[0]\n\tface_num = len(inds)\n\tprint '{} faces detected!'.format(face_num)\n\tdets = dets[inds, :]\n\teye = eye[inds, 1]\n\tsmile = smile[inds, 1]\n\n\treturn dets, eye, smile","def detector(videoframe, facedetection, maskdetection):\n (h, w) = videoframe.shape[:2]\n blobimage = cv2.dnn.blobFromImage(videoframe, 1.0, (224, 224), (104.0, 177.0, 123.0))\n\n facedetection.setInput(blobimage)\n ffinding = facedetection.forward()\n\n face_list = []\n locations = []\n predictions = []\n\n for i in range(0, ffinding.shape[2]):\n credence = ffinding[0, 0, i, 2]\n if credence > 0.6:\n case = ffinding[0, 0, i, 3:7] * np.array([w, h, w, h])\n (x_start, y_start, x_end, y_end) = case.astype(\"int\")\n (x_start, y_start) = (max(0, x_start), max(0, y_start))\n (x_end, y_end) = (min(w - 1, x_end), min(h - 1, y_end))\n\n image = videoframe[y_start:y_end, x_start:x_end]\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n image = cv2.resize(image, (224, 224))\n image = img_to_array(image)\n image = preprocess_input(image)\n face_list.append(image)\n locations.append((x_start, y_start, x_end, y_end))\n\n if len(face_list) > 0:\n face_list = np.array(face_list, dtype=\"float32\")\n predictions = maskdetection.predict(face_list, batch_size=32)\n return (locations, predictions)","def classify_face(im):\n faces_death = get_encoded_faces_deaths()\n faces_arrested = get_encoded_faces_arrested()\n faces_wanted = get_encoded_faces_wanted()\n\n faces_encoded_death = list(faces_death.values())\n known_face_names_death = list(faces_death.keys())\n\n faces_encoded_arrested = list(faces_arrested.values())\n known_face_names_arrested = list(faces_arrested.keys())\n\n faces_encoded_wanted = list(faces_wanted.values())\n known_face_names_wanted = list(faces_wanted.keys())\n\n img = cv2.imread(im, 1)\n face_locations = face_recognition.face_locations(img)\n unknown_face_encodings = face_recognition.face_encodings(img,face_locations)\n face_names = []\n find_in_db(im,known_face_names_death,unknown_face_encodings,face_names,faces_encoded_death,\"unnatural_death_images/unnatural_death_images\")\n find_in_db(im,known_face_names_arrested,unknown_face_encodings,face_names,faces_encoded_arrested,\"ArrestPerson_images\")\n find_in_db(im,known_face_names_wanted,unknown_face_encodings,face_names,faces_encoded_wanted,\"wanted\")","def detection():\n faceCascade = cv2.CascadeClassifier(cv2.data.haarcascades + \"haarcascade_frontalface_default.xml\")\n faces = faceCascade.detectMultiScale(\n gray,\n scaleFactor=1.3,\n minNeighbors=3,\n minSize=(30, 30)\n )\t#Haar-cascade: A Face detection algorithm\n\n area = faces[:,2] * faces[:,3]\n faces = np.c_[faces,area]\t#concatenates area values to last column of 'face' array.\n\n print('All detected faces\\n',faces)\n i,j = unravel_index(faces.argmax(), faces.shape)\t# gets the position of maximum value from 'face' array.\n print(i,j)\n print(\"Found %d Face%s!\" %(len(faces),\"s\"[len(faces)==1:]))\n\n X = faces[i,0]\n Y = faces[i,1]\n W = faces[i,2]\n H = faces[i,3]\n \n cv2.rectangle(image, (X, Y), (X + W, Y + H), (0, 255, 0), 2)\n roi_color = image[Y:Y + H, X:X + W] \n print(\"Face(largest) Extracted.\")\n cv2.imwrite('Extracted_face.jpg', roi_color)\t#Image Extraction.\n status = cv2.imwrite('Output.jpg', image)\n print(\"Image Output.jpg written to filesystem: \", status)","def recogniseFace(self, imagefilenames, selectedFileName, selectedDirectory, numOfEigenfaces, thresholdVal):\r\n print 'recogniseFace()::'\r\n self.facet.checkCache(selectedDirectory, imagefilenames, numOfEigenfaces)\r\n mindist, matchfile = self.facet.findMatchingImage(selectedFileName, numOfEigenfaces, thresholdVal)\r\n self.processMatchResult(matchfile, mindist, numOfEigenfaces)","def get_faceboxes(self,img,threshold):\n faces = self.mark_detector.extract_cnn_facebox(img,threshold)\n \n\n\n faceboxes = []\n for face in faces:\n start = (face[0],face[1])\n end = (face[2],face[3])\n box = Box.setStartEnd(start,end)\n\n faceboxes.append(box)\n \n return faceboxes","def box_faces(images):\n return (_box_faces(image) for image in images)","def faceRecognition(image):\r\n faceLandmarks = [[],[],[]]\r\n face_landmarks_list = face_recognition.face_landmarks(image)\r\n if len(face_landmarks_list)>0:\r\n if len(face_landmarks_list[0]['left_eye'])>0:\r\n leftEyePos = [tuple(map(lambda i: int(i/32),i)) for i in face_landmarks_list[0]['left_eye']]\r\n for i in set(leftEyePos):\r\n if leftEyePos.count(i)>=len(leftEyePos)//len(set(leftEyePos)):\r\n faceLandmarks[0] += [i,]\r\n if len(face_landmarks_list[0]['right_eye'])>0:\r\n rightEyePos = [tuple(map(lambda i: int(i/32),i)) for i in face_landmarks_list[0]['right_eye']]\r\n for i in set(rightEyePos):\r\n if rightEyePos.count(i)>=len(rightEyePos)//len(set(rightEyePos)):\r\n faceLandmarks[1] += [i,]\r\n if len(face_landmarks_list[0]['top_lip'])>0:\r\n mouthPos = [tuple(map(lambda i: int(i/32),i)) for i in (face_landmarks_list[0]['top_lip']+face_landmarks_list[0]['bottom_lip'])]\r\n for i in set(mouthPos):\r\n if mouthPos.count(i)>=len(mouthPos)//len(set(mouthPos)):\r\n faceLandmarks[2] += [i,]\r\n return faceLandmarks","def track_faces_in_video(self):\r\n\r\n logger.debug('Executing face tracking')\r\n\r\n track_loaded = False\r\n\r\n # Try to load YAML file with tracking results\r\n if os.path.exists(self.track_file_path):\r\n\r\n print 'Loading YAML file with tracking results'\r\n logger.debug('Loading YAML file with tracking results')\r\n\r\n track_faces = utils.load_YAML_file(self.track_file_path)\r\n\r\n if track_faces:\r\n self.tracked_faces = track_faces\r\n\r\n print 'YAML file with tracking results loaded'\r\n logger.debug('YAML file with tracking results loaded')\r\n\r\n track_loaded = True\r\n\r\n if not track_loaded:\r\n\r\n # Check existence of detection results\r\n\r\n if len(self.detected_faces) == 0:\r\n\r\n # Try to load YAML file\r\n if os.path.exists(self.det_file_path):\r\n\r\n print 'Loading YAML file with detection results'\r\n logger.debug('Loading YAML file with detection results')\r\n\r\n with open(self.det_file_path) as f:\r\n\r\n self.detected_faces = yaml.load(f)\r\n\r\n print 'YAML file with detection results loaded'\r\n logger.debug('YAML file with detection results loaded')\r\n\r\n else:\r\n\r\n print 'Warning! No detection results found!'\r\n logger.warning('No detection results found!')\r\n\r\n return\r\n\r\n # Get shot cuts\r\n self.calc_hist_diff()\r\n\r\n print '\\n\\n### Face tracking ###\\n'\r\n logger.debug('\\n\\n### Face tracking ###\\n')\r\n\r\n # Save processing time\r\n start_time = cv2.getTickCount()\r\n\r\n self.tracked_faces = []\r\n\r\n self.disc_tracked_faces = []\r\n\r\n # Counter for frames with detected faces\r\n frame_counter = 0\r\n\r\n # If a reduced frame rate is used, frames are less\r\n use_or_fps = c.USE_ORIGINAL_FPS\r\n used_fps = c.USED_FPS\r\n min_segment_duration = c.MIN_SEGMENT_DURATION\r\n tracking_min_int_area = c.TRACKING_MIN_INT_AREA\r\n min_size_width = c.FACE_DETECTION_MIN_SIZE_WIDTH\r\n min_size_height = c.FACE_DETECTION_MIN_SIZE_HEIGHT\r\n max_fr_with_miss_det = c.MAX_FR_WITH_MISSED_DET\r\n use_aligned_face = c.USE_ALIGNED_FACE_IN_TRACKING\r\n\r\n if self.params is not None:\r\n if c.USE_ORIGINAL_FPS_KEY in self.params:\r\n use_or_fps = self.params[c.USE_ORIGINAL_FPS_KEY]\r\n if c.USED_FPS_KEY in self.params:\r\n used_fps = self.params[c.USED_FPS_KEY]\r\n if c.MIN_SEGMENT_DURATION_KEY in self.params:\r\n min_segment_duration = self.params[\r\n c.MIN_SEGMENT_DURATION_KEY]\r\n if c.TRACKING_MIN_INT_AREA_KEY in self.params:\r\n tracking_min_int_area = self.params[\r\n c.TRACKING_MIN_INT_AREA_KEY]\r\n if c.MIN_SIZE_WIDTH_KEY in self.params:\r\n min_size_width = self.params[c.MIN_SIZE_WIDTH_KEY]\r\n if c.MIN_SIZE_HEIGHT_KEY in self.params:\r\n min_size_height = self.params[c.MIN_SIZE_HEIGHT_KEY]\r\n if c.MAX_FR_WITH_MISSED_DET_KEY in self.params:\r\n max_fr_with_miss_det = self.params[\r\n c.MAX_FR_WITH_MISSED_DET_KEY]\r\n if c.USE_ALIGNED_FACE_IN_TRACKING_KEY in self.params:\r\n use_aligned_face = self.params[\r\n c.USE_ALIGNED_FACE_IN_TRACKING_KEY]\r\n\r\n # Minimum duration of a segment in frames\r\n min_segment_frames = int(\r\n math.ceil(self.fps * min_segment_duration))\r\n\r\n if not use_or_fps:\r\n min_segment_frames = int(\r\n math.ceil((used_fps + 1) * min_segment_duration))\r\n\r\n # Make copy of detected faces\r\n detection_list = list(self.detected_faces)\r\n\r\n # Iterate through frames in detected_faces\r\n for detection_dict in detection_list:\r\n\r\n self.progress = 100 * (frame_counter / self.saved_frames)\r\n\r\n print('progress: ' + str(self.progress) + ' % \\r'),\r\n\r\n elapsed_s = detection_dict[c.ELAPSED_VIDEO_TIME_KEY]\r\n\r\n frame_name = detection_dict[c.SAVED_FRAME_NAME_KEY]\r\n\r\n faces = detection_dict[c.FACES_KEY]\r\n\r\n face_counter = 0\r\n\r\n # Iterate though faces in frame\r\n for face_dict in faces:\r\n\r\n track_window = face_dict[c.BBOX_KEY]\r\n\r\n left_eye_pos = face_dict[c.LEFT_EYE_POS_KEY]\r\n\r\n right_eye_pos = face_dict[c.RIGHT_EYE_POS_KEY]\r\n\r\n nose_pos = face_dict[c.NOSE_POSITION_KEY]\r\n\r\n file_name = face_dict[c.ALIGNED_FACE_FILE_NAME_KEY]\r\n\r\n # Counter for faces in segment\r\n segment_face_counter = 1\r\n\r\n segment_frame_list = []\r\n\r\n # Start new segment\r\n segment_frame_dict = {c.FRAME_COUNTER_KEY: frame_counter,\r\n c.ELAPSED_VIDEO_TIME_KEY: elapsed_s,\r\n c.DETECTION_BBOX_KEY: track_window,\r\n c.TRACKING_BBOX_KEY: track_window,\r\n c.LEFT_EYE_POS_KEY: left_eye_pos,\r\n c.RIGHT_EYE_POS_KEY: right_eye_pos,\r\n c.NOSE_POSITION_KEY: nose_pos,\r\n c.ALIGNED_FACE_FILE_NAME_KEY: file_name,\r\n c.DETECTED_KEY: True,\r\n c.SAVED_FRAME_NAME_KEY: frame_name}\r\n\r\n segment_frame_list.append(segment_frame_dict)\r\n\r\n aligned_file_path = None\r\n rgb_roi = None\r\n if use_aligned_face:\r\n # Use the aligned face as the\r\n # Region of Interest for tracking\r\n complete_file_name = file_name + '.png'\r\n aligned_file_path = os.path.join(\r\n self.align_path, complete_file_name)\r\n\r\n rgb_roi = cv2.imread(\r\n aligned_file_path, cv2.IMREAD_COLOR)\r\n\r\n else:\r\n # Use detected face as the\r\n # Region of Interest for tracking\r\n x0 = track_window[0]\r\n y0 = track_window[1]\r\n w = track_window[2]\r\n h = track_window[3]\r\n x1 = x0 + w\r\n y1 = y0 + h\r\n\r\n frame_path = os.path.join(\r\n self.frames_path, frame_name)\r\n\r\n # Whole frame\r\n rgb = cv2.imread(frame_path, cv2.IMREAD_COLOR)\r\n\r\n # Face\r\n rgb_roi = rgb[y0:y1, x0:x1]\r\n\r\n if rgb_roi is None:\r\n print('Warning! Face to be tracked is None')\r\n\r\n if use_aligned_face:\r\n logger.warning(\r\n 'Face ' + aligned_file_path + ' is None')\r\n else:\r\n logger.warning(\r\n 'Face from frame ' + frame_name + ' is None')\r\n\r\n face_counter += 1\r\n\r\n continue\r\n\r\n # Convert image to hsv\r\n hsv_roi = cv2.cvtColor(rgb_roi, cv2.COLOR_BGR2HSV)\r\n\r\n mask_roi = cv2.inRange(\r\n hsv_roi, np.array((0., 60., 32.)),\r\n np.array((180., 255., 255.)))\r\n\r\n hist = cv2.calcHist(\r\n [hsv_roi], [0], mask_roi, [16], [0, 180])\r\n\r\n cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX)\r\n hist = hist.reshape(-1)\r\n\r\n # Face should not be considered anymore\r\n del (detection_list[frame_counter]\r\n [c.FACES_KEY][face_counter])\r\n\r\n sub_frame_counter = frame_counter + 1\r\n\r\n missed_det_counter = 0\r\n\r\n # Iterate through subsequent frames\r\n for sub_det_dict in detection_list[sub_frame_counter:]:\r\n\r\n # Check if a new shot begins\r\n if sub_frame_counter in self.cut_idxs:\r\n break\r\n\r\n sub_frame_name = sub_det_dict[c.SAVED_FRAME_NAME_KEY]\r\n\r\n sub_frame_path = os.path.join(\r\n self.frames_path, sub_frame_name)\r\n\r\n # Read image from given path\r\n sub_image = cv2.imread(\r\n sub_frame_path, cv2.IMREAD_COLOR)\r\n\r\n if sub_image is None:\r\n print('Warning! Image is None')\r\n logger.warning(\r\n 'Image ' + sub_frame_path + ' is None')\r\n\r\n continue\r\n\r\n # Convert image to hsv\r\n sub_hsv = cv2.cvtColor(sub_image, cv2.COLOR_BGR2HSV)\r\n\r\n sub_mask = cv2.inRange(sub_hsv,\r\n np.array((0., 60., 32.)),\r\n np.array((180., 255., 255.)))\r\n\r\n # Apply meanshift to get the new location\r\n prob = cv2.calcBackProject(\r\n [sub_hsv], [0], hist, [0, 180], 1)\r\n prob &= sub_mask\r\n term_crit = (cv2.TERM_CRITERIA_EPS\r\n | cv2.TERM_CRITERIA_COUNT, 10, 1)\r\n\r\n track_box, track_window = cv2.CamShift(\r\n prob, track_window, term_crit)\r\n\r\n track_x0 = track_window[0]\r\n track_y0 = track_window[1]\r\n track_w = track_window[2]\r\n track_h = track_window[3]\r\n\r\n # Check size of track window\r\n if ((track_w <= min_size_width)\r\n or (track_h <= min_size_height)):\r\n\r\n break\r\n\r\n segment_frame_dict = {}\r\n\r\n track_list = (\r\n int(track_x0), int(track_y0), int(track_w),\r\n int(track_h))\r\n\r\n segment_frame_dict[c.TRACKING_BBOX_KEY] = track_list\r\n\r\n sub_faces = sub_det_dict[c.FACES_KEY]\r\n\r\n sub_face_counter = 0\r\n\r\n sim = False\r\n\r\n det_bbox = None\r\n\r\n for sub_face_dict in sub_faces:\r\n\r\n det_bbox = sub_face_dict[c.BBOX_KEY]\r\n\r\n # If track window corresponds to\r\n # a detected face,\r\n # delete detection from list\r\n\r\n (sim, int_area, int_area_pct) = utils.is_rect_similar(\r\n track_window, det_bbox, tracking_min_int_area)\r\n\r\n if sim:\r\n # det_face_counter = det_face_counter + 1\r\n\r\n track_window = det_bbox\r\n\r\n break\r\n\r\n sub_face_counter += 1\r\n\r\n t_x0 = track_window[0]\r\n t_y0 = track_window[1]\r\n t_w = track_window[2]\r\n t_h = track_window[3]\r\n\r\n segment_frame_dict[c.DETECTION_BBOX_KEY] = det_bbox\r\n\r\n # If a detected face corresponds to track window\r\n # delete detected face from detection list\r\n\r\n if sim:\r\n\r\n missed_det_counter = 0\r\n\r\n segment_frame_dict[c.DETECTED_KEY] = True\r\n\r\n segment_frame_dict[c.LEFT_EYE_POS_KEY] = (\r\n sub_face_dict[c.LEFT_EYE_POS_KEY])\r\n segment_frame_dict[c.RIGHT_EYE_POS_KEY] = (\r\n sub_face_dict[c.RIGHT_EYE_POS_KEY])\r\n\r\n segment_frame_dict[c.NOSE_POSITION_KEY] = (\r\n sub_face_dict[c.NOSE_POSITION_KEY])\r\n\r\n segment_frame_dict[c.ALIGNED_FACE_FILE_NAME_KEY] = (\r\n sub_face_dict[c.ALIGNED_FACE_FILE_NAME_KEY])\r\n\r\n del (detection_list[sub_frame_counter]\r\n [c.FACES_KEY][sub_face_counter])\r\n\r\n else:\r\n\r\n # Check if distance from last detection\r\n # is too big\r\n missed_det_counter += 1\r\n\r\n if missed_det_counter > max_fr_with_miss_det:\r\n\r\n # Remove last frames and\r\n # interrupt tracking\r\n for i in range(0, max_fr_with_miss_det):\r\n segment_frame_list.pop()\r\n\r\n segment_face_counter = (\r\n segment_face_counter - max_fr_with_miss_det)\r\n\r\n break\r\n\r\n segment_frame_dict[c.DETECTED_KEY] = False\r\n\r\n elapsed_ms = sub_det_dict[c.ELAPSED_VIDEO_TIME_KEY]\r\n\r\n # Update list of frames for segment\r\n segment_frame_dict[\r\n c.FRAME_COUNTER_KEY] = sub_frame_counter\r\n segment_frame_dict[\r\n c.ELAPSED_VIDEO_TIME_KEY] = elapsed_ms\r\n\r\n track_list = (\r\n int(t_x0), int(t_y0), int(t_w), int(t_h))\r\n\r\n segment_frame_dict[c.TRACKING_BBOX_KEY] = track_list\r\n segment_frame_dict[\r\n c.SAVED_FRAME_NAME_KEY] = sub_frame_name\r\n\r\n segment_frame_list.append(segment_frame_dict)\r\n\r\n del sub_image\r\n\r\n sub_frame_counter += 1\r\n\r\n segment_face_counter += 1\r\n\r\n # Segment must be considered only if its number\r\n # of frames is greater or equals than a minimum\r\n if segment_face_counter >= min_segment_frames:\r\n\r\n segments = self.divide_segment_by_face(\r\n segment_frame_list)\r\n\r\n if len(segments) > 0:\r\n self.tracked_faces.extend(segments)\r\n\r\n else:\r\n\r\n segment_dict = {c.FRAMES_KEY: segment_frame_list}\r\n\r\n self.disc_tracked_faces.append(segment_dict)\r\n\r\n # Check histograms of detected faces and\r\n # divide segment accordingly\r\n\r\n face_counter += 1\r\n\r\n frame_counter += 1\r\n\r\n # Create directory for this video\r\n\r\n if not (os.path.exists(self.track_path)):\r\n os.makedirs(self.track_path)\r\n\r\n # Save tracking result in YAML file\r\n utils.save_YAML_file(self.track_file_path, self.tracked_faces)\r\n\r\n # Save processing time\r\n time_in_clocks = cv2.getTickCount() - start_time\r\n time_in_seconds = time_in_clocks / cv2.getTickFrequency()\r\n\r\n print 'Time for face tracking:', time_in_seconds, 's\\n'\r\n logger.debug('Time for face tracking:', time_in_seconds, 's\\n')\r\n\r\n self.anal_times[c.FACE_TRACKING_TIME_KEY] = time_in_seconds\r\n\r\n utils.save_YAML_file(self.analysis_file_path, self.anal_times)","def crop_faces(cv_imgs, only_one=True, using_bundled_library=False):\n faces_coords = []\n\n if using_bundled_library:\n for image in cv_imgs:\n coords = face_recognition.face_locations(image)\n coords = [(y2, x1, y1 - y2, x2 - x1) for x1, y1, x2, y2 in coords]\n faces_coords.append(coords)\n return faces_coords\n\n img_with_several_faces = 0\n img_with_no_face = 0\n img_with_one_face = 0\n for index, image in enumerate(cv_imgs):\n faceCascade = cv2.CascadeClassifier(cv2.data.haarcascades + \"haarcascade_frontalface_default.xml\")\n faces = faceCascade.detectMultiScale(\n image,\n scaleFactor=1.01,\n minNeighbors=5,\n minSize=(200, 200)\n )\n\n if only_one:\n if len(faces) == 1:\n img_with_one_face += 1\n (x, y, w, h) = faces[0]\n faces_coords.append((x, y, w, h))\n else:\n faces_coords.append(None)\n if len(faces) == 0:\n img_with_no_face += 1\n else:\n img_with_several_faces += 1\n else:\n faces_coords.append(faces)\n\n return faces_coords","def faces(self):\r\n return self._faces","def face_detector( img_path, face_cascade):\n img = cv2.imread( img_path )\n gray = cv2.cvtColor( img, cv2.COLOR_BGR2GRAY )\n faces = face_cascade.detectMultiScale( gray )\n if len( faces ) > 0:\n return True\n else:\n return False","def parse(self):\n imset = []\n imdir = remkdir(os.path.join(self._datadir, 'images'))\n csv_actors = readcsv(os.path.join(self._datadir, 'facescrub_actors.txt'), separator='\\t')\n for (subjectname, imageid, faceid, url, bbox, sha256) in csv_actors[1:]:\n categoryname = subjectname.replace(' ', '_')\n (xmin,ymin,xmax,ymax) = bbox.split(',')\n imset.append(ImageDetection(url=url, filename=os.path.join(imdir, '%s_%s.jpg' % (categoryname, imageid)), category=categoryname, xmin=xmin, ymin=ymin, xmax=xmax, ymax=ymax, attributes={'GENDER':'male'}))\n\n csv_actresses = readcsv(os.path.join(self._datadir, 'facescrub_actresses.txt'), separator='\\t')\n for (subjectname, imageid, faceid, url, bbox, sha256) in csv_actresses[1:]:\n categoryname = subjectname.replace(' ', '_')\n (xmin,ymin,xmax,ymax) = bbox.split(',')\n imset.append(ImageDetection(url=url, filename=os.path.join(imdir, '%s_%s.jpg' % (categoryname, imageid)), category=categoryname, xmin=xmin, ymin=ymin, xmax=xmax, ymax=ymax, attributes={'GENDER':'female'}))\n\n return imset","def add_image_face():\n\n try:\n img = decode_image(request.files[\"image\"].read())\n except Exception as e:\n log.error(e)\n data = {\"error\": \"Error while loading image\"}\n return jsonify(data), 500\n save_picture = False\n if request.args.get(\"save\") == \"true\":\n save_picture = True\n \n face_img, _ = processor.extract_faces()\n #TODO\n #1. get several images if possible\n #2. save face_img array as picture if save_picture == True\n #3. pipe face_img array to embedder --> embedder needs to be modified to not from a folder, but from array of face_img\n #4. get the embedder result, insert to a pickle object --> can be section ID, or whatever","def face_detector(img_path: str):\r\n img = cv2.imread(img_path)\r\n\r\n # if no image at that path, return False\r\n if img is None:\r\n return False\r\n\r\n # convert to grey\r\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\r\n\r\n # detect faces. If no face detected, it's empty and len(faces) will be 0\r\n faces = face_cascade.detectMultiScale(gray)\r\n return len(faces) > 0","def get_encoded_faces():\r\n encoded = {}\r\n\r\n for dirpath, dnames, fnames in os.walk(\"./faces\"):\r\n for f in fnames:\r\n if f.endswith(\".jpg\") or f.endswith(\".png\"):\r\n face = fr.load_image_file(\"faces/\" + f)\r\n encoding = fr.face_encodings(face)[0]\r\n encoded[f.split(\".\")[0]] = encoding\r\n\r\n return encoded","def get_faces():\n detected_faces = request()\n\n if not detected_faces:\n raise FaceNotDetectedError()\n return detected_faces","def get_faceboxes(self, image, threshold=0.5):\r\n rows, cols, _ = image.shape\r\n\r\n confidences = []\r\n faceboxes = []\r\n\r\n self.face_net.setInput(cv2.dnn.blobFromImage(\r\n image, 1.0, (300, 300), (104.0, 177.0, 123.0), False, False))\r\n detections = self.face_net.forward()\r\n\r\n for result in detections[0, 0, :, :]:\r\n confidence = result[2]\r\n if confidence > threshold:\r\n x_left_bottom = int(result[3] * cols)\r\n y_left_bottom = int(result[4] * rows)\r\n x_right_top = int(result[5] * cols)\r\n y_right_top = int(result[6] * rows)\r\n confidences.append(confidence)\r\n faceboxes.append(\r\n [x_left_bottom, y_left_bottom, x_right_top, y_right_top])\r\n\r\n self.detection_result = [faceboxes, confidences]\r\n\r\n return confidences, faceboxes","def read_images(path, sz=None, cr=None):\n c = 0\n X,y = [], []\n for dirname, dirnames, filenames in os.walk(path):\n for subdirname in dirnames:\n subject_path = os.path.join(dirname, subdirname)\n for filename in os.listdir(subject_path):\n\n if filename.endswith('.jpg'):\n try:\n im = cv2.imread(os.path.join(subject_path, filename), cv2.IMREAD_GRAYSCALE)\n #print os.path.join(subject_path, filename)\n # crop the image on the face\n if (cr is not None):\n rect, img = detect(im)\n if len(rect) == 0:\n return [None,None]\n im = img[rect[0][1]:rect[0][3], rect[0][0]:rect[0][2]]\n \n #im = Image.fromarray(img)\n # resize to given size (if given)\n if (sz is not None):\n #print im, sz\n im = cv2.resize(im, sz)\n cv2.imwrite('../data_pictures/prova'+str(c)+'.jpg',im)\n X.append(np.asarray(im, dtype=np.uint8))\n y.append(c)\n except IOError, (errno, strerror):\n print \"I/O error({0}): {1}\".format(errno, strerror)\n except:\n print \"Unexpected error:\", sys.exc_info()[0]\n raise\n\n\n c = c+1\n return [X,y]","def detect_face_api(self, img):\n\n curr_face_loc, name_list, info_list = load_encode_loc(img, self.kwn_names,\n self.kwn_encoding,\n self.status_list, self.since_list)\n print('Current value is ', curr_face_loc, name_list)\n face_list = []\n face_area = []\n print('face loc', curr_face_loc)\n if len(curr_face_loc):\n\n for (top, right, bottom, left), name in zip(curr_face_loc, name_list):\n print(top, right, bottom, left)\n cv2.rectangle(img, (top, right), (bottom, left), (0, 255, 2), 2)\n\n w = right - left\n h = bottom - top\n cx = left + w // 2\n cy = top + h // 2\n area = w * h\n\n for idx, info in enumerate(info_list):\n cv2.putText(img, info, (bottom, int(left * idx * 0.2)),\n cv2.FONT_HERSHEY_COMPLEX, 1,\n (0, 0, 255), 1)\n\n face_list.append([cx, cy])\n face_area.append(area)\n\n i = face_area.index(max(face_area))\n\n return img, [face_list[i], face_area[i]]\n\n else:\n return img, [[0, 0], 0]","def detectObjects(image):\n\tgrayscale = cvCreateImage(cvSize(image.width, image.height), 8, 1)\n\tcvCvtColor(image, grayscale, CV_BGR2GRAY)\n\n\tstorage = cvCreateMemStorage(0)\n\tcvClearMemStorage(storage)\n\tcvEqualizeHist(grayscale, grayscale)\n\tcascade = cvLoadHaarClassifierCascade(\n\t\t'/usr/share/opencv/haarcascades/haarcascade_frontalface_default.xml',\n\t\tcvSize(1,1))\n\n\tscalefactor = 1.1 # How much to increase window size each pass\n\tminsize = 50 # Smallest face to detect. Up this if you have small falsepositives\n\tfaces = cvHaarDetectObjects(grayscale, cascade, storage, scalefactor, 50,\n\t\t\t\tCV_HAAR_DO_CANNY_PRUNING, cvSize(minsize, minsize))\n\n\treturn [(f.x, f.y, f.x + f.width, f.y + f.height) for f in faces]","def face_detection_image(self, image_path):\n body = {'file': (image_path, open(image_path, 'rb'), \"multipart/form-data\")}\n url = self.base_url + '/vision-service/phoenix-vision/face-detection/image'\n headers = {\"ApiKey\": self.api_key}\n response = requests.post(url=url, files=body, headers=headers).text\n return response","def find_candidate_images(images_path):\n images = []\n for root, dirs, files in os.walk(images_path):\n for name in files:\n file_path = os.path.abspath(os.path.join(root, name))\n if (os.path.splitext(name)[1]).lower() in [\".jpg\", \".png\", \".jpeg\"]:\n images.append(file_path)\n return images","def detect(img, cascade, settings):\n # Parameters taken verbatim from OpenCV 2.4 example:\n # https://github.com/opencv/opencv/blob/2.4/samples/python2/facedetect.py\n rects = cascade.detectMultiScale(img, \n **settings)\n\n if len(rects) == 0:\n return []\n\n print(rects)\n\n # Turn width and height of box\n # into plot-ready image coordinates.\n # rects contains (x,y),(w,h), return (x,y),(x+w,x+h)\n\n rects[:,2:] += rects[:,:2]\n return rects","def find_faces(self, img: Array3D, det_prob_threshold: float = None) -> List[BoundingBoxDTO]:\n raise NotImplementedError","def imageFileProcessor(path):\n # Show all files in RawCapturedPicture\n # ..., and get the completed path files\n img_paths = []\n for ea in o_tl.showAllFiles(path):\n img_paths.append(os.path.join(path, ea))\n\n # Empty face list\n faces = []\n # Empty ID list\n IDs = []\n\n # Looping through all the image paths and loading the IDs and the faces\n for each_path in img_paths:\n # Loading the image and converting it to gray scale\n pil_img = Image.open(each_path).convert('L')\n # Converting the PIL image into numpy array\n image_numpy = np.array(pil_img, 'uint8')\n # Getting the Id from the image\n Id = int(os.path.split(each_path)[-1].split(\"_\")[1])\n # Extract the face from the training image sample\n faces.append(image_numpy)\n IDs.append(Id)\n return faces, IDs","def make_face_recognition(update: Update, _: CallbackContext) -> None:\n # message.photo is a list of PhotoSize objects,\n # which represent different sizes of the same photo\n\n # print(\"Enter to make_face_recognition\")\n img_from_user = update.message.photo[-1].get_file()\n img_file = io.BytesIO()\n img_from_user.download(out=img_file)\n img_array = face_recognition.load_image_file(img_file)\n # Find all the faces in the image\n face_locations = face_recognition.face_locations(img_array)\n # print(face_locations)\n img_with_rects = _make_rects(img_array, face_locations)\n out_file = 'tmp.jpg'\n Image.fromarray(img_with_rects, 'RGB').save(out_file, format=\"JPEG\")\n update.message.bot.send_photo(\n update.message.chat_id,\n photo=open(out_file, 'rb'))","def recognize_faces(x_img,\n knn_clf=None,\n model_path=None,\n distance_threshold=0.3):\n print(\"Start recognize\")\n # Making a check\n if knn_clf is None and model_path is None:\n raise Exception(\"Must supply knn classifier either thought knn_clf or model_path\")\n\n # Load a trained KNN model (if one was passed in)\n if knn_clf is None:\n with open(model_path, 'rb') as f:\n knn_clf = pickle.load(f)\n\n # Load image file and find face locations\n x_face_locations = face_recognition.face_locations(x_img)\n # Set variable for changes on camera (if connected) check\n # x_face_locations_len = 0\n\n # If no faces are found in the image, return an empty result\n if len(x_face_locations) == 0:\n return []\n \n\n # Checking for changes on camera (if connected)\n # if len(x_face_locations) != x_face_locations_len:\n # Find encodings for faces in the test iamge\n faces_encodings = face_recognition.face_encodings(x_img, known_face_locations=x_face_locations)\n # Use the KNN model to find the best matches for the test face\n closest_distances = knn_clf.kneighbors(faces_encodings, n_neighbors=1)\n are_matches = [closest_distances[0][i][0] <= distance_threshold for i in range(len(x_face_locations))]\n accur_list = [1-closest_distances[0][i][0] for i in range(len(x_face_locations))]\n x_face_locations_len = len(x_face_locations)\n # Predict classes and remove classifications that aren't within the threshold\n return [(pred, loc, accur, rec) if rec else (\"unknown\", loc, 0,0) for pred, loc, accur, rec in\n zip(knn_clf.predict(faces_encodings),\n x_face_locations,\n accur_list,\n are_matches)]","async def detect_face(face_file, max_results=4):\n image_content = face_file.read()\n batch_request = [{\n 'image': {\n 'content': base64.b64encode(image_content).decode('utf-8')\n },\n 'features': [{\n 'type': 'FACE_DETECTION',\n 'maxResults': max_results,\n }]\n }]\n\n service = get_vision_service()\n request = service.images().annotate(body={\n 'requests': batch_request,\n })\n loop = asyncio.get_event_loop()\n response = await loop.run_in_executor(None, request.execute)\n\n return response['responses'][0]['faceAnnotations'] if 'faceAnnotations' in response['responses'][0] else None","def get_filtered_faces(self, faces):\n filtered_faces = []\n for face in faces:\n i, j, k = face\n thresh = 100.0\n if self.get_distance_between_points(i, j) > thresh:\n continue\n elif self.get_distance_between_points(j, k) > thresh:\n continue\n elif self.get_distance_between_points(i, k) > thresh:\n continue\n filtered_faces.append(face)\n return filtered_faces","def save_faces(img, faces, width, height):\n\n for i, (x, y, w, h) in enumerate(faces):\n # TODO: Change output string\n save_image(resize_img(img[y:y+h, x:x+w], width, height), 'out' + str(i) + '.jpg')","def detectFacesWithRectangle(img, faces):\n\n for (x, y, w, h) in faces:\n cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 3)","def get_data(self):\n global CAM\n count = 0\n while CAM.isOpened():\n count += 1\n print('COUNT' + str(count))\n _, frame = CAM.read()\n\n # cropped face\n cropped_face, bbox_coordinate, anchor_coordinate = detect_faces(frame)\n if cropped_face is None:\n print(\"NONE FACE DETECTED\")\n sleep(1)\n continue\n\n # get fake face\n fake_face, profile_feature_vector = generate_frontal_face(cropped_face)\n\n cropped_face = cv2.cvtColor(cropped_face, cv2.COLOR_BGR2RGB)\n fake_face = cv2.cvtColor(fake_face, cv2.COLOR_BGR2RGB)\n\n # face matching\n face_matcher = FaceMatcher()\n matched_face, matched_name, matched_front_fake_face, matched_diff = \\\n face_matcher.match(cropped_face, fake_face, profile_feature_vector)\n\n matched_face = cv2.cvtColor(matched_face, cv2.COLOR_BGR2RGB)\n matched_front_fake_face = cv2.cvtColor(matched_front_fake_face, cv2.COLOR_BGR2RGB)\n\n _, cropped_face_jpeg = cv2.imencode('.jpg', cropped_face)\n _, fake_face_jpeg = cv2.imencode('.jpg', fake_face)\n _, matched_face_jpeg = cv2.imencode('.jpg', matched_face)\n _, matched_front_fake_face_jpeg = cv2.imencode('.jpg', matched_front_fake_face)\n\n encoded_cropped_face = \"data:image/jpg;base64,\" + str(\n base64.b64encode(cropped_face_jpeg.tobytes()).decode())\n encoded_fake_face = \"data:image/jpg;base64,\" + str(\n base64.b64encode(fake_face_jpeg.tobytes()).decode())\n\n encoded_matched_face = \"data:image/jpg;base64,\" + str(\n base64.b64encode(matched_face_jpeg.tobytes()).decode())\n encoded_matched_front_fake_face = \"data:image/jpg;base64,\" + str(\n base64.b64encode(matched_front_fake_face_jpeg.tobytes()).decode())\n\n # get detection model return here and send to face frontalization model\n SIO.emit('detection', {'cropped_face': encoded_cropped_face,\n 'fake_face': encoded_fake_face,\n 'matched_face': encoded_matched_face,\n 'matched_name': matched_name,\n 'matched_front_fake_face': encoded_matched_front_fake_face,\n 'id': uuid.uuid4().hex},\n namespace='/detections')\n sleep(self.delay)","def _detect_face_ResNet10_SSD(self, img):\n\n detector = self.detector\n (h, w) = img.shape[:2]\n # construct a blob from the image\n img_blob = cv2.dnn.blobFromImage(\n cv2.resize(img, (300, 300)),\n 1.0,\n (300, 300),\n (104.0, 177.0, 123.0),\n swapRB=False,\n crop=False,\n )\n\n detector.setInput(img_blob)\n detections = detector.forward()\n\n (start_x, start_y, end_x, end_y) = (0, 0, 0, 0)\n faces_bb = []\n if len(detections) > 0:\n # we're making the assumption that each image has only ONE\n # face, so find the bounding box with the largest probability\n for i in range(0, detections.shape[2]):\n\n score = detections[0, 0, i, 2]\n\n # ensure that the detection greater than our threshold is\n # selected\n if score > self.confidence:\n # compute the (x, y)-coordinates of the bounding box for\n # the face\n box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])\n box = box.astype(\"int\")\n (start_x, start_y, end_x, end_y) = box\n\n # print(\"start x : {}\".format(start_x))\n # print(\"start y : {}\".format(start_y))\n # print(\"end x : {}\".format(end_x))\n # print(\"end y : {}\".format(end_y))\n\n # extract the face ROI and grab the ROI dimensions\n face = img[start_y:end_y, start_x:end_x]\n\n (fh, fw) = face.shape[:2]\n # ensure the face width and height are sufficiently large\n if fw < 20 or fh < 20:\n pass\n else:\n faces_bb.append(box)\n\n if len(faces_bb) > 0:\n faces_bb = np.array(faces_bb)\n\n return faces_bb","def process_image(file_path):\n img_array = io.imread(file_path)\n detections, shapes, descriptors = detect_faces(person_database,img_array)\n\n names = []\n\n for desc in descriptors:\n name = find_match(person_database, desc)\n names.append(name)\n\n return pic_array, names, detections, shapes, descriptors","def classify_face(im):\r\n faces = get_encoded_faces()\r\n faces_encoded = list(faces.values())\r\n known_face_names = list(faces.keys())\r\n\r\n img = cv2.imread(im, 1)\r\n \"\"\"\r\n Resize optinal \r\n \"\"\"\r\n #img = cv2.resize(img, (0, 0), fx=0.5, fy=0.5)\r\n #img = img[:,:,::-1]\r\n face_locations = face_recognition.face_locations(img)\r\n unknown_face_encodings = face_recognition.face_encodings(img, face_locations)\r\n\r\n face_names = []\r\n for face_encoding in unknown_face_encodings:\r\n # See if the face is a match for the known face(s)\r\n matches = face_recognition.compare_faces(faces_encoded, face_encoding)\r\n name = \"Unknown\"\r\n\r\n # use the known face with the smallest distance to the new face\r\n face_distances = face_recognition.face_distance(faces_encoded, face_encoding)\r\n best_match_index = np.argmin(face_distances)\r\n if matches[best_match_index]:\r\n name = known_face_names[best_match_index]\r\n\r\n face_names.append(name)\r\n\r\n \"\"\"\r\n All the photo lables in the faces foler end with (number) so a simiple .find(\"(\") command takes the () away from\r\n the label leaving us with the full name of the person\r\n\r\n \"\"\"\r\n\r\n result = name.find('(') \r\n fullname = (name[:result])\r\n \"\"\"\r\n If face_recogntion module recognizes a face but that face is not in the faces module then \r\n it will print unknown and we print 12345678 to use it on the start attednace program \r\n\r\n \"\"\"\r\n if (name == \"Unknown\"):\r\n print(\"12345678\")\r\n else:\r\n \"\"\"\r\n f'{len(face_locayion)}-people - will return the number of people in photo taken by Nao'\r\n \"\"\"\r\n print (f'{len(face_locations)}-people')\r\n print (fullname)\r\n print(courseid)\r\n print (lateornot)\r\n c34 = fullname.find(' ')\r\n firstname = (fullname[:c34])\r\n lastname = (fullname[c34:])\r\n \"\"\"\r\n We get all the data courseid , fristname , lastname, datetime1,and late or not and submited on the website \r\n \r\n\r\n \"\"\"\r\n login_data = {\r\n\t 'Course': courseid,\r\n\t 'FirstName': firstname,\r\n\t 'LastName': lastname,\r\n\t 'Date': datetime2,\r\n\t 'Attendance': 'on',\r\n\t 'Late': latev,\r\n\t 'submitbutton': 'Submit'\r\n }\r\n if(fullname == \"Unknow\"):\r\n \tprint(\"I-dont-know-you\")\r\n else:\r\n \r\n with requests.Session() as s:\r\n \turl = \"https://rbattendance.000webhostapp.com/update.php\"\r\n \tr = s.get(url)\r\n \tsoup = BeautifulSoup(r.content, 'html5lib')\r\n \tr = s.post(url, data = login_data)\r\n \t#print(r.content)\r\n \r\n \r\n\r\n\r\n\r\n\r\n \"\"\"\r\n This for loop is reponsible for drawing on the image \r\n \"\"\"\r\n\r\n for (top, right, bottom, left), name in zip(face_locations, face_names):\r\n # Draw a box around the face\r\n cv2.rectangle(img, (left-20, top-20), (right+20, bottom+20), (255, 0, 0), 2)\r\n\r\n # Draw a label with a name below the face\r\n cv2.rectangle(img, (left-20, bottom -15), (right+20, bottom+20), (255, 0, 0), cv2.FILLED)\r\n font = cv2.FONT_HERSHEY_DUPLEX\r\n cv2.putText(img, name, (left -20, bottom + 15), font, 1.0, (255, 255, 255), 2)\r\n\r\n\r\n # Display the resulting image\r\n \r\n \r\n while True:\r\n #cv2.imshow('Video', img)\r\n #if cv2.waitKey(1) & 0xFF == ord('q'):\r\n return face_names","def scan_images(images, clf, first_index, vstep=15, hstep=15, dnum=5):\n detections = []\n for i in tqdm(range(len(images))):\n labels = find_faces(util.img_as_float(rgb2gray(images[i])), clf, first_index + i,\n vstep, hstep, dnum)\n for label in labels:\n detections.append(label)\n return np.array(detections)","def _get_images_and_labels(self, path: str, user_id: int):\n\n image_paths = [os.path.join(path, f) for f in os.listdir(path)]\n face_samples = []\n ids = []\n\n for imagePath in image_paths:\n\n pil_image = Image.open(imagePath).convert('L') # convert it to grayscale\n img_numpy = np.array(pil_image, 'uint8')\n\n faces = self.detector.detectMultiScale(img_numpy)\n\n for (x, y, w, h) in faces:\n face_samples.append(img_numpy[y:y + h, x:x + w])\n ids.append(user_id)\n\n return face_samples, ids","def detect_faces_in_video(self):\r\n logger.debug('Executing face detection')\r\n\r\n use_eyes_position = c.USE_EYES_POSITION\r\n\r\n if ((self.params is not None) and\r\n (c.USE_EYES_POSITION_KEY in self.params)):\r\n use_eyes_position = self.params[c.USE_EYES_POSITION_KEY]\r\n\r\n det_loaded = False\r\n\r\n # Try to load YAML file with detection results\r\n if os.path.exists(self.det_file_path):\r\n\r\n print 'Loading YAML file with detection results'\r\n logger.debug('Loading YAML file with detection results')\r\n\r\n det_faces = utils.load_YAML_file(self.det_file_path)\r\n\r\n if det_faces:\r\n self.detected_faces = det_faces\r\n\r\n print 'YAML file with detection results loaded'\r\n logger.debug('YAML file with detection results loaded')\r\n\r\n det_loaded = True\r\n\r\n if not det_loaded:\r\n\r\n # Check existence of frame list\r\n if len(self.frame_list) == 0:\r\n\r\n # Try to load YAML file with frame list\r\n if os.path.exists(self.frames_file_path):\r\n\r\n print 'Loading YAML file with frame list'\r\n logger.debug('Loading YAML file with frame list')\r\n\r\n f_list = utils.load_YAML_file(self.frames_file_path)\r\n\r\n if f_list:\r\n\r\n self.frame_list = f_list\r\n\r\n print 'YAML file with frame list loaded'\r\n logger.debug('YAML file with frame list loaded')\r\n\r\n else:\r\n\r\n print 'Warning! Error in loading file!'\r\n logger.warning('Error in loading file!')\r\n\r\n else:\r\n\r\n print 'Warning! No frame list found!'\r\n logger.warning('No frame list found!')\r\n\r\n return\r\n\r\n print '\\n\\n### Face detection ###\\n'\r\n logger.debug('\\n\\n### Face detection ###\\n')\r\n\r\n # Save processing time\r\n start_time = cv2.getTickCount()\r\n\r\n if not (os.path.exists(self.det_path)):\r\n # Create directory for this video\r\n\r\n os.makedirs(self.det_path)\r\n\r\n if not (os.path.exists(self.align_path)):\r\n # Create directory with aligned faces\r\n\r\n os.makedirs(self.align_path)\r\n\r\n frame_counter = 0\r\n self.detected_faces = []\r\n\r\n detection_results = []\r\n\r\n # Build list of frame names, frame paths and elapsed time\r\n frame_name_list = []\r\n\r\n frame_path_list = []\r\n\r\n elapsed_s_list = []\r\n\r\n for frame_dict in self.frame_list:\r\n frame_name = frame_dict[c.SAVED_FRAME_NAME_KEY]\r\n\r\n frame_name_list.append(frame_name)\r\n\r\n frame_path = os.path.join(self.frames_path, frame_name)\r\n\r\n frame_path_list.append(frame_path)\r\n\r\n elapsed_s = frame_dict[c.ELAPSED_VIDEO_TIME_KEY]\r\n\r\n elapsed_s_list.append(elapsed_s)\r\n\r\n # Iterate through frame paths in list\r\n for frame_path in frame_path_list:\r\n self.progress = 100 * (frame_counter / self.saved_frames)\r\n\r\n print('progress: ' + str(self.progress) + ' % \\r'),\r\n\r\n detection_result = fd.detect_faces_in_image(\r\n frame_path, self.align_path, self.params, False)\r\n\r\n detection_results.append(detection_result)\r\n\r\n frame_counter += 1\r\n\r\n frame_counter = 0\r\n\r\n # Iterate through detection results\r\n for detection_result in detection_results:\r\n\r\n detection_error = detection_result[c.ERROR_KEY]\r\n\r\n detection_dict = {\r\n c.SAVED_FRAME_NAME_KEY: frame_name_list[frame_counter],\r\n c.FRAME_COUNTER_KEY: frame_counter}\r\n\r\n elapsed_s = elapsed_s_list[frame_counter]\r\n\r\n detection_dict[c.ELAPSED_VIDEO_TIME_KEY] = elapsed_s\r\n\r\n faces = []\r\n if not detection_error:\r\n\r\n det_faces = detection_result[c.FACES_KEY]\r\n\r\n for det_face in det_faces:\r\n\r\n face_dict = {c.BBOX_KEY: det_face[c.BBOX_KEY]}\r\n\r\n if use_eyes_position:\r\n face_dict[c.LEFT_EYE_POS_KEY] = (\r\n det_face[c.LEFT_EYE_POS_KEY])\r\n\r\n face_dict[c.RIGHT_EYE_POS_KEY] = (\r\n det_face[c.RIGHT_EYE_POS_KEY])\r\n\r\n face_dict[c.NOSE_POSITION_KEY] = (\r\n det_face[c.NOSE_POSITION_KEY])\r\n\r\n face_dict[c.ALIGNED_FACE_FILE_NAME_KEY] = (\r\n det_face[c.ALIGNED_FACE_FILE_NAME_KEY])\r\n\r\n faces.append(face_dict)\r\n\r\n detection_dict[c.FACES_KEY] = faces\r\n\r\n self.detected_faces.append(detection_dict)\r\n\r\n frame_counter += 1\r\n\r\n # Save detection results in YAML file\r\n\r\n utils.save_YAML_file(self.det_file_path, self.detected_faces)\r\n\r\n time_in_clocks = cv2.getTickCount() - start_time\r\n time_in_seconds = time_in_clocks / cv2.getTickFrequency()\r\n\r\n print 'Time for face detection: ', time_in_seconds, 's\\n'\r\n logger.debug('Time for face detection: ', time_in_seconds, 's\\n')\r\n\r\n self.anal_times[c.FACE_DETECTION_TIME_KEY] = time_in_seconds\r\n\r\n utils.save_YAML_file(self.analysis_file_path, self.anal_times)","def train():\n face_recognizer = cv2.face.LBPHFaceRecognizer_create()\n \n # Load all saved people\n people = PersonModel.select()\n\n # List of face images\n photos = []\n # List of person IDs corresponding to images in photos[]\n labels = []\n\n for person in people:\n person_dataset_path = os.path.join(Constants.PATH_DATASET, \"person_{}\".format(person.id))\n\n if not os.path.exists(person_dataset_path):\n continue\n\n # List of all images for current person\n photo_files = [os.path.join(person_dataset_path, item) for item in os.listdir(person_dataset_path)]\n person.update(photos_count=len(photo_files)).execute()\n\n # Load all photos\n for photo_file in photo_files:\n photos.append(\n np.array(Image.open(photo_file).convert(\"L\"))\n )\n \n labels.append(person.id)\n\n face_recognizer.train(photos, np.array(labels))\n\n if not face_recognizer.write(Constants.FILE_MODEL):\n return False\n\n return True","def _raw_face_locations(img, number_of_times_to_upsample=1, model=\"hog\"):\n if model == \"cnn\":\n cnn_face_detector = dlib.cnn_face_detection_model_v1('mmod_human_face_detector.dat')\n return cnn_face_detector(img, number_of_times_to_upsample)\n else:\n # face_detector = dlib.get_frontal_face_detector()\n return face_detector(img, number_of_times_to_upsample)","def compare_faces(file1, file2):\n # Load the jpg files into numpy arrays\n image1 = fr.load_image_file(file1)\n image2 = fr.load_image_file(file2)\n\n # Get the face encodings for each face in each image file\n # Assume there is only 1 face in each image, so get 1st face of an image.\n image1_encoding = fr.face_encodings(image1)[0]\n image2_encoding = fr.face_encodings(image2)[0]\n\n # results is an array of True/False telling if the unknown face matched anyone in the known_faces array\n results = fr.compare_faces([image1_encoding], image2_encoding, tolerance=0.5)\n return results[0]","def read_image():\n images = []\n for hand in os.listdir('images'):\n img = cv2.imread(os.path.join('images', hand))\n if img is not None:\n images.append(img)\n return images","def detect_face(image):\n cascadePath = \"haarcascade_frontalface_default.xml\"\n faceCascade = cv2.CascadeClassifier(cascadePath)\n faces = faceCascade.detectMultiScale(image)\n if len(faces)>=1:#Should be == , not >=\n return True\n return False","def update(self,image):\r\n \r\n self._faces=[]\r\n \r\n if util.isgray(image):\r\n image=cv2.equalizeHist(image)\r\n \r\n else:\r\n \r\n image=cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)\r\n cv2.equalizeHist(image,image)\r\n \r\n minsize=util.widthheightdividedby(image,8)\r\n\r\n \r\n\r\n \r\n facerect=self._faceclassifier.detectMultiScale(image,\r\n self.scalefactor,\r\n self.minneighbors,\r\n self.flags,\r\n minsize)\r\n \r\n \"\"\"if facerects is not None:\r\n \r\n for facerect in facerects:\r\n face=face()\r\n \r\n face.facerect=facerect\r\n \r\n \r\n x,y,w,h=facerect\r\n \r\n # Seek an eye in the upper-left part of the face. \r\n searchRect = (x+w/7, y, w*2/7, h/2) \r\n face.leftEyeRect = self._detectOneObject( \r\n self._eyeClassifier, image, searchRect, 64) \r\n \r\n \r\n \r\n # Seek an eye in the upper-right part of the face. \r\n searchRect = (x+w*4/7, y, w*2/7, h/2) \r\n face.rightEyeRect = self._detectOneObject( \r\n self._eyeClassifier, image, searchRect, 64) \r\n \r\n \r\n \r\n # Seek a nose in the middle part of the face. \r\n searchRect = (x+w/4, y+h/4, w/2, h/2) \r\n face.noseRect = self._detectOneObject( \r\n self._noseClassifier, image, searchRect, 32) \r\n \r\n # Seek a mouth in the lower-middle part of the face. \r\n searchRect = (x+w/6, y+h*2/3, w*2/3, h/3) \r\n face.mouthRect = self._detectOneObject( \r\n self._mouthClassifier, image, searchRect, 16) \r\n \r\n \r\n \r\n self._faces.append(face)\r\n\r\n \r\n \r\n def _detectoneobject(self,\r\n classifier,\r\n image,\r\n rect,\r\n imagesizetominsizeratio):\r\n \r\n x ,y ,w ,h=rect\r\n \r\n minsize=util.widthheightdividedby(image,\r\n imagesizetominsizeratio)\r\n \r\n subimage=image[y:y+h,x:x+w]\r\n \r\n subrect=classifier.dectectMultiScale(subimage,\r\n self.scalefactor,\r\n self.minneighbors,\r\n self.flags,\r\n minsize)\r\n \r\n if len(subrect)==0:\r\n return None\r\n \r\n subx,suby,subw,subh=subrects[0]\r\n \r\n return (x+subx,y+suby,w+subw,h+subh)\r\n \r\n \"\"\"","def _raw_face_locations(img, number_of_times_to_upsample=1, model=\"hog\"):\n\tif model == \"cnn\":\n\t\treturn cnn_face_detector(img, number_of_times_to_upsample)\n\telse:\n\t\treturn face_detector(img, number_of_times_to_upsample)","def read_images_from_single_face_profile(face_profile, face_profile_name_index, dim = (120, 120)):\n index = 0\n \n print(face_profile)\n for the_file in os.listdir(face_profile):\n file_path = os.path.join(face_profile, the_file)\n \n print(file_path)\n if file_path.endswith(\".png\") or file_path.endswith(\".jpg\") or file_path.endswith(\".jpeg\") or file_path.endswith(\".pgm\"):\n \n img = cv2.imread(file_path, 0)\n # print(img.shape)\n # cv2.waitKey(0)\n img = cv2.resize(img, (120, 160))\n cv2.imwrite(file_path, img)\n \n index += 1\n\n if index == 0 : \n shutil.rmtree(face_profile)\n logging.error(\"\\nThere exists face profiles without images\")","def loading_faces(source_image_set_path, dest_image_set_path, source_image_set):\n dimensions_of_img = find_dimensions_not_attentive_imgs\n if 'attentive' in dest_image_set_path:\n dimensions_of_img = find_dimensions_attentive_imgs\n for image_name in source_image_set:\n\n # loading gray image\n gray_image = cv2.imread(source_image_set_path + \"/\" + image_name, 0)\n\n # find co-ordinates of faces in images\n y1, x2, y2, x1 = dimensions_of_img(*face_recognition.face_locations(gray_image)[0], np.shape(gray_image))\n\n # crop image and resize to particular dimension\n crop_img = gray_image[y1:y2, x1:x2]\n resize_crop_img = cv2.resize(crop_img, (int(dimension[0:3]), int(dimension[0:3])))\n\n # load images from source to destination directory\n cv2.imwrite(dest_image_set_path + \"/\" + image_name, resize_crop_img)","def face_detection_json(self, image_path):\n body = {'file': (image_path, open(image_path, 'rb'), \"multipart/form-data\")}\n url = self.base_url + '/vision-service/phoenix-vision/face-detection/json'\n headers = {\"ApiKey\": self.api_key}\n response = requests.post(url=url, files=body, headers=headers).json()\n return response","def _raw_face_locations(img, number_of_times_to_upsample=1):\n return face_detector(img, number_of_times_to_upsample)","def detectFaceAndClassify(faceNet, faceMaskClassifier, testImagePath, threshold):\n # load the input test image from disk\n image = cv2.imread(testImagePath)\n # making a copy of image and finding the image spatial dimensions\n orig = image.copy()\n (h, w) = image.shape[:2]\n\n # construct a blob from the image to pass to the network\n # using standard weights for the face detection model for image preprocessing\n blob = cv2.dnn.blobFromImage(image, 1.0, (300, 300), (104.0, 177.0, 123.0))\n\n # obtain the face detections by passing the blob through the network\n print(\"computing face detections...\")\n faceNet.setInput(blob)\n faceDetections = faceNet.forward()\n\n # loop over the detections to classify them and form bounding boxes and labels\n for i in range(0, faceDetections.shape[2]):\n # extract only confident detections using the confidence/probability\n # associated with the detection\n confidence = faceDetections[0, 0, i, 2]\n\n # filter out weak detections by ensuring the confidence is\n # greater than the minimum confidence 0.5 or input variable\n if confidence > threshold:\n # extract bounding box dimensions and face Region of intrest for classification\n faceROI, startX, startY, endX, endY = extractBoxAndFaceROI(image, faceDetections, itemNum=i,\n height=h, width=w)\n\n faceROI = np.expand_dims(faceROI, axis=0)\n\n # Passing the pre-processed image with classification model to check if there is a mask or not\n (mask, withoutMask) = faceMaskClassifier.predict(faceROI)[0]\n # (mask, withoutMask) = faceMaskClassifier.predict(faceROI)\n\n # find the class and associated colour to use for the bounding box and text\n label = \"Mask\" if mask > withoutMask else \"No Mask\"\n color = (0, 255, 0) if label == \"Mask\" else (0, 0, 255)\n\n # include the probability of prediction in the label of the bounding box\n label = \"{}: {:.2f}%\".format(label, max(mask, withoutMask) * 100)\n\n # forming bounding box rectangle and display the label the output image frame\n cv2.putText(image, label, (startX, startY - 10),\n cv2.FONT_HERSHEY_COMPLEX, 0.45, color, 2)\n cv2.rectangle(image, (startX, startY), (endX, endY), color, 2)\n\n # show the output image\n cv2.imshow(\"Output\", image)\n # display the image still a key is pressed, when key is pressed program is terminated\n cv2.waitKey(0)","def test_measurement_on_images(file_list):\n test_details_list = []\n for idx, file in enumerate(file_list):\n dict_results = {}\n image = cv2.imread(file)\n FaceDetector().run(image, dict_results)\n file_name = ntpath.basename(file)\n is_there_face = \"True\" in file_name\n test_details_list.append([file_name, is_there_face, dict_results[\"FaceDetector\"],\n is_there_face == dict_results[\"FaceDetector\"]])\n\n # print test results in a readable table format\n headers = ['File Name', 'Face Exist', 'Measurement Result', 'Test Result']\n print(tabulate(test_details_list, headers))","def extract_faces(frame_path, out_path, face_path, processes=1):\n if os.path.exists(out_path):\n msg = '[extract_faces] Skipping extraction since faces already exist at {}'\n print(msg.format(out_path))\n return\n\n from faceoff.faceswap_api import FaceSwapInterface\n\n os.makedirs(out_path)\n print('[extract_faces] Starting on {}'.format(frame_path))\n start_time = time.time()\n\n api = FaceSwapInterface()\n api.extract(frame_path, out_path, face_path, processes)","def face_scraper():\n base_directory = pathlib.Path(__file__).parent.absolute()\n test_or_train, is_target_face = ask_for_directory()\n folders = ['test', 'train']\n test_or_train = folders[test_or_train]\n source_directory = os.path.join(base_directory, 'rawimages', test_or_train, str(is_target_face))\n target_directory = os.path.join(base_directory, 'datasets', test_or_train, str(is_target_face))\n print('The source folder is ' + source_directory)\n print('The target folder is ' + target_directory)\n print('Files before saving images:')\n print(os.listdir(target_directory))\n crop_and_save_images(source_directory, target_directory)\n print('Files after saving images:')\n print(os.listdir(target_directory))","def collect_image_files():\n negs = [] # Non image files found\n for filename in os.listdir('.'):\n if filename.lower().endswith('.jpg') or filename.lower().\\\n endswith('.jpeg'):\n jpg_files.append(filename)\n elif filename.lower().endswith('.gif'):\n gif_files.append(filename)\n elif filename.lower().endswith('.png'):\n png_files.append(filename)\n else:\n negs.append(filename)\n return negs","def validate(model: str = \"hog\"):\n for filepath in Path(\"validation\").rglob(\"*\"):\n if filepath.is_file():\n recognize_faces(\n image_location=str(filepath.absolute()), model=model\n )","def _getface_cascade(self,img,mode):\n gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n faces = self.model.detectMultiScale(gray, 1.3, 5)\n if len(faces)==0:\n return None\n x,y,w,h = faces[0]\n top, right, bottom, left = self._change_shape(x,y,w,h)\n\n if mode == 1 :\n out = [x,y,w,h]\n elif mode == 2 :\n out = [top, right, bottom, left]\n return out","def detect_faces(self, img, return_best=False):\n if numpy.all(img != None):\n\n try:\n if not self.is_cuda_enable:\n caffe.set_mode_cpu()\n else:\n caffe.set_mode_gpu()\n caffe.set_device(cfg.GPU_ID)\n\n scores, boxes = im_detect(self.net, img)\n\n cls_ind = 1\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\n cls_scores = scores[:, cls_ind]\n dets = numpy.hstack((cls_boxes,\n cls_scores[:, numpy.newaxis])).astype(numpy.float32)\n keep = nms(dets, NMS_THRESH)\n dets = dets[keep, :]\n\n keep = numpy.where(dets[:, 4] > CONF_THRESH)\n dets = dets[keep]\n\n if len(dets) > 0:\n if return_best:\n # dets is ordered by confidence dets[:, 4], so the first one is the best\n det = [int(dets[0, 0]), int(dets[0, 1]), int(dets[0, 2]), int(dets[0, 3]), dets[0, 4]]\n # extend detection\n extend_factor = self.face_rect_expand_factor\n width = round(det[2]-det[0])\n height = round(det[3]-det[1])\n length = (width + height)/2.0\n centrepoint = [round(det[0]) + width/2.0, round(det[1]) + height/2.0]\n det[0] = centrepoint[0] - round((1+extend_factor)*length/2.0)\n det[1] = centrepoint[1] - round((1+extend_factor)*length/2.0)\n det[2] = centrepoint[0] + round((1+extend_factor)*length/2.0)\n det[3] = centrepoint[1] + round((1+extend_factor)*length/2.0)\n ## prevent going off image\n det[0] = int(max(det[0], 0))\n det[1] = int(max(det[1], 0))\n det[2] = int(min(det[2], img.shape[1]))\n det[3] = int(min(det[3], img.shape[0]))\n return [det]\n else:\n det_list = []\n for j in range(dets.shape[0]):\n det = [int(dets[j, 0]), int(dets[j, 1]), int(dets[j, 2]), int(dets[j, 3]), dets[0, 4]]\n # extend detection\n extend_factor = self.face_rect_expand_factor\n width = round(det[2]-det[0])\n height = round(det[3]-det[1])\n length = (width + height)/2.0\n centrepoint = [round(det[0]) + width/2.0, round(det[1]) + height/2.0]\n det[0] = centrepoint[0] - round((1+extend_factor)*length/2.0)\n det[1] = centrepoint[1] - round((1+extend_factor)*length/2.0)\n det[2] = centrepoint[0] + round((1+extend_factor)*length/2.0)\n det[3] = centrepoint[1] + round((1+extend_factor)*length/2.0)\n ## prevent going off image\n det[0] = int(max(det[0], 0))\n det[1] = int(max(det[1], 0))\n det[2] = int(min(det[2], img.shape[1]))\n det[3] = int(min(det[3], img.shape[0]))\n det_list.append(det)\n return det_list\n else:\n return None\n\n except Exception as e:\n print ('Exception in FaceDetectorFasterRCNN: ' + str(e))\n pass\n\n return None","async def asyncRedetectFaces():\n faceEngine = VLFaceEngine()\n detector = faceEngine.createFaceDetector(DetectorType.FACE_DET_V3)\n\n imageWithSeveralFaces = VLImage.load(filename=EXAMPLE_SEVERAL_FACES)\n severalFaces = detector.detect([imageWithSeveralFaces], detect5Landmarks=False, detect68Landmarks=False)\n\n detections = await detector.redetect(\n images=[\n ImageForRedetection(imageWithSeveralFaces, [face.boundingBox.rect for face in severalFaces[0]]),\n ],\n asyncEstimate=True,\n )\n pprint.pprint(detections)\n task1 = detector.redetect(\n images=[\n ImageForRedetection(imageWithSeveralFaces, [severalFaces[0][0].boundingBox.rect]),\n ],\n asyncEstimate=True,\n )\n task2 = detector.redetect(\n images=[\n ImageForRedetection(imageWithSeveralFaces, [severalFaces[0][1].boundingBox.rect]),\n ],\n asyncEstimate=True,\n )\n for task in (task1, task2):\n pprint.pprint(task.get())","def addPhoto(fileName, personName):\n\n #Check if image is a jpg\n if (fileName[-4:] != \".jpg\"):\n print(\"\\n[!] File extenstion must be .jpg!\\n\")\n return\n\n #Check image exists\n if (not os.path.isfile(fileName)):\n print(\"\\n[!] File does not exist!\\n\")\n return\n\n #Check no illegal characters in file name\n for c in ILLEGAL_FILE_NAMES:\n if (c in personName):\n print(\"\\n[!] Provided name contains an illegal argument\\n\")\n return\n\n #Load image\n image = face_recognition.load_image_file(fileName)\n\n #Use the name in the filename as the identity key\n identity = os.path.splitext(os.path.basename(fileName))[0]\n\n #Get the face location\n locationsHog = hogDetectFaceLocations(image)\n\n locationsHaar = haarDetectFaceLocations(image)\n\n #Get the face encoding\n encodingsHaar = face_recognition.face_encodings(image, locationsHaar)\n encodingsHog = face_recognition.face_encodings(image, locationsHog)\n\n #check if exactly one face is in the photo\n if ((len(encodingsHaar) == 0) or (len(encodingsHog) == 0)):\n print(\"\\n[!] No face detected in the provided photo\\n\")\n return\n\n elif ((len(encodingsHaar) > 1) or (len(encodingsHog) > 1)):\n print(\"\\n[!] More than one face detected in the provided photo\\n\")\n return\n\n #Set path to respective dataset\n directoryToAddTo = DATABASE_PATH + personName\n\n #Look for directory\n exists = False\n for subdir, dirs, files in os.walk(DATABASE_PATH):\n if (subdir == directoryToAddTo):\n exists = True\n\n #If directory doesnt exist, make it\n if (not exists):\n os.mkdir(directoryToAddTo)\n\n #Save data to file\n np.savetxt((directoryToAddTo + \"/\" + identity + \"Haar.txt\"),\n encodingsHaar[0])\n np.savetxt((directoryToAddTo + \"/\" + identity + \"Hog.txt\"),\n encodingsHog[0])\n\n print(\"\\n[*] Face successfully added!\\n\")"],"string":"[\n \"def extract_face_detections(self):\\n self.detector.setInput(self.image_blob)\\n self.detections = self.detector.forward()\",\n \"def detect_faces(image):\\n\\n face_locations = face_recognition.face_locations(image)\\n return face_locations\",\n \"def get_check_folder():\\r\\n filelist = [file for file in os.listdir('temp') if file.endswith('.png')]\\r\\n image_count = len(filelist)\\r\\n if image_count == 0:\\r\\n print\\\"No faces detected in image.\\\"\\r\\n exit()\\r\\n print \\\"Detected \\\"+str(image_count)+\\\" faces in the image.\\\"\\r\\n if filelist:\\r\\n for image_path in filelist:\\r\\n target = cv2.imread(\\\"temp/\\\" + image_path)\\r\\n cv2.imshow(\\\"detected face\\\", target)\\r\\n k = cv2.waitKey(1) & 0xFF\\r\\n img_to_del = Image.open(\\\"temp/\\\" + image_path)\\r\\n for folder in get_immediate_subdirectories():\\r\\n count = 0\\r\\n val = 0\\r\\n folder_filelist = [file for file in os.listdir(\\\"detected_faces/\\\" + folder) if\\r\\n file.endswith('.png')]\\r\\n for file in folder_filelist:\\r\\n img_to_compare = Image.open(\\\"detected_faces/\\\" + folder + \\\"/\\\" + file)\\r\\n if img_to_del.size > img_to_compare.size:\\r\\n temp_image_resized = img_to_del.resize(img_to_compare.size, Image.ANTIALIAS)\\r\\n index = get_ssim(temp_image_resized, img_to_compare)\\r\\n elif img_to_del.size < img_to_compare.size:\\r\\n img_to_compare = img_to_compare.resize(img_to_del.size, Image.ANTIALIAS)\\r\\n index = get_ssim(img_to_del, img_to_compare)\\r\\n else:\\r\\n index = get_ssim(img_to_del, img_to_compare)\\r\\n val += index\\r\\n count += 1\\r\\n if count > 0:\\r\\n index = val/count\\r\\n if index > min_ssim_index_val:\\r\\n print \\\" Detected a face in DB folder \\\"+ folder\\r\\n if os.path.isfile(os.path.join(temp_path, image_path)):\\r\\n os.remove(os.path.join(temp_path, image_path))\",\n \"def find_all_faces_in_one_img(img_path, detector, img_size, dst_path):\\r\\n\\r\\n img_path = img_path.replace('\\\\\\\\', '/')\\r\\n img_name = img_path.split(sep='/')[-1].split(sep='.')[0]\\r\\n\\r\\n assert img_path.split(sep='/')[-1].split(sep='.')[1] in [\\r\\n 'png', 'jpg'], 'files should be images with a \\\".jpg\\\" or \\\".png\\\" extension !'\\r\\n\\r\\n img_extension = '.jpg'\\r\\n\\r\\n all_detected_faces, detection_status = faces_detector(\\r\\n img_path, detector, img_size, threshold_confidence=0.90)\\r\\n\\r\\n if detection_status == 'success':\\r\\n for faces in all_detected_faces:\\r\\n cv.imwrite(os.path.join(dst_path, img_name + img_extension), faces)\\r\\n elif detection_status == 'failure':\\r\\n os.remove(img_path)\\r\\n\\r\\n return detection_status\",\n \"def detect_faces(self, img):\\n with tf.Graph().as_default():\\n gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=.7)\\n sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False))\\n with sess.as_default():\\n pnet, rnet, onet = detect_face.create_mtcnn(sess, None)\\n\\n minsize = 20 # minimum size of face\\n threshold = [ 0.6, 0.7, 0.7 ] # three steps's threshold\\n factor = 0.709 # scale factor\\n\\n bounding_boxes, _ = detect_face.detect_face(img, minsize, pnet, rnet, onet, threshold, factor)\\n\\n nrof_faces = bounding_boxes.shape[0]\\n img_size = np.asarray(img.shape)[0:2]\\n\\n faces = []\\n faces_rects = []\\n\\n for i in range(nrof_faces):\\n det = bounding_boxes[i,0:4]\\n bb = np.zeros(4, dtype=np.int32)\\n bb[0] = np.maximum(det[0]-5/2, 0)\\n bb[1] = np.maximum(det[1]-5/2, 0)\\n bb[2] = np.minimum(det[2]+5/2, img_size[1])\\n bb[3] = np.minimum(det[3]+5/2, img_size[0])\\n faces.append(img[bb[1]:bb[3], bb[0]:bb[2], :])\\n faces_rects.append({'name': 'none', 'x': bb[0], 'y': bb[1], 'w': bb[2]-bb[0], 'h': bb[3]-bb[1]})\\n\\n return [img, faces, faces_rects]\",\n \"def detectFaces():\\n faceEngine = VLFaceEngine()\\n detector = faceEngine.createFaceDetector(DetectorType.FACE_DET_V3)\\n\\n imageWithOneFace = VLImage.load(filename=EXAMPLE_O)\\n pprint.pprint(detector.detectOne(imageWithOneFace, detect5Landmarks=False, detect68Landmarks=False).asDict())\\n detection = detector.detectOne(imageWithOneFace, detect5Landmarks=False, detect68Landmarks=False)\\n pprint.pprint(detector.redetectOne(image=imageWithOneFace, bBox=detection))\\n pprint.pprint(detector.redetectOne(image=imageWithOneFace, bBox=detection.boundingBox.rect))\\n\\n imageWithSeveralFaces = VLImage.load(filename=EXAMPLE_SEVERAL_FACES)\\n severalFaces = detector.detect([imageWithSeveralFaces], detect5Landmarks=False, detect68Landmarks=False)\\n\\n pprint.pprint(\\n detector.redetect(\\n images=[\\n ImageForRedetection(imageWithSeveralFaces, [face.boundingBox.rect for face in severalFaces[0]]),\\n ImageForRedetection(imageWithOneFace, [detection.boundingBox.rect]),\\n ImageForRedetection(imageWithOneFace, [Rect(0, 0, 1, 1)]),\\n ]\\n )\\n )\",\n \"def detect_faces(self, image):\\n return self.face_detector(image, 1)\",\n \"def face_detector(img):\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n\\n # faceCascade imports in the previously made classifier\\n faceCascade = cv2.CascadeClassifier('src/face_detection/haarcascade_frontalface_default.xml')\\n faces = faceCascade.detectMultiScale(\\n gray, \\n scaleFactor=1.2,\\n minNeighbors=1, \\n minSize=(100, 100)\\n )\\n\\n return faces\",\n \"def _open_images(training_filenames, path):\\n imagePaths=[os.path.join(path,f) for f in training_filenames]\\n faces=[]\\n for i, imagePath in enumerate(imagePaths):\\n faceImg=Image.open(imagePath).convert('L')\\n faceNp=np.array(faceImg,'uint8')\\n faces.append(faceNp)\\n return faces\",\n \"def _load_known_faces(self):\\n faces_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'faces')\\n faces = [\\n os.path.join(faces_dir, f) for f in os.listdir(faces_dir) \\\\\\n if f.endswith('.jpeg') or f.endswith('.jpg') or f.endswith('.png')\\n ]\\n known_images = [face_recognition.load_image_file(i) for i in faces]\\n self.known_faces = []\\n self.faces_names = [x.split('/')[-1].split('.')[0].replace('_', ' ').title() for x in faces]\\n for image in known_images:\\n encoding = face_recognition.face_encodings(image)\\n if len(encoding) > 0:\\n logging.debug('Adding known face')\\n self.known_faces.append(encoding[0])\",\n \"def face_detection(image, xml_path):\\n\\n face_cascade = cv2.CascadeClassifier(xml_path)\\n faces = face_cascade.detectMultiScale(image, 1.3, 5)\\n\\n images = []\\n\\n for face in faces:\\n x_beginning, y_beginning, face_width, face_height = face\\n roi_img = image[y_beginning:y_beginning + face_height, x_beginning:x_beginning + face_width]\\n\\n images.append(roi_img)\\n\\n return faces, images\",\n \"def _load_known_face(self):\\n faces_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'faces')\\n faces = [os.path.join(faces_dir, f) for f in os.listdir(faces_dir) if f.endswith('.jpeg')]\\n known_images = [face_recognition.load_image_file(i) for i in faces]\\n self.known_faces = []\\n for image in known_images:\\n encoding = face_recognition.face_encodings(image)\\n if len(encoding) > 0:\\n logging.debug('Adding known face')\\n self.known_faces.append(encoding[0])\",\n \"def faces(self, image):\\n\\n response = self._send_request(\\\"faces\\\", files=dict(image=image))\\n return response['objectdetection']\",\n \"def get_faces(image):\\n return (image.crop(face) for face in image.faces)\",\n \"def get_faces(self, img):\\n results = self.detect_and_draw(img, False)\\n (width, height) = cv.GetSize(img)\\n for result in results:\\n self.add_property('name', 'face')\\n self.add_property('pixel_location', result[0])\\n self.add_property('relative_location', (float(result[0][0]) / width, float(result[0][1]) / height))\\n self.add_property('angle_and_distance', result[1])\\n self.add_property('face_area', result[2])\\n self.add_property('width', result[4])\\n self.add_property('height', result[5])\\n self.add_property('relative_face_area', (float(result[2]) / (width * height)))\\n self.add_property('confidence', result[3])\\n self.add_property('dimensions', (width, height))\\n self.add_property('rotation', self.rotation)\\n self.store_observation()\",\n \"def find_all_faces_in_multiple_img(img_dir_path, detector, img_size, dst_path):\\r\\n\\r\\n number_of_faces_already_found = count_files_in_one_directory(dst_path)\\r\\n print('number_of_faces_already_found', number_of_faces_already_found)\\r\\n for filename in os.listdir(img_dir_path):\\r\\n try:\\r\\n # When the user decides to add new data to existing one, no need to deal again (refind faces) with the old data\\r\\n if list(map(int, re.findall(r'\\\\d+', filename)))[0] < number_of_faces_already_found:\\r\\n continue\\r\\n img_path = os.path.join(img_dir_path, filename)\\r\\n print(filename + ': IN PROGRESS')\\r\\n detection_status = find_all_faces_in_one_img(\\r\\n img_path, detector, img_size, dst_path)\\r\\n print(filename + ': {}\\\\n'.format(detection_status.upper()))\\r\\n except:\\r\\n continue\",\n \"def extract_faces(self, img, list_face_coord):\\n #from the img array extract the facees\\n list_faces = []\\n #Go through each face coordinates and store the array\\n #or clip face region in the list\\n for i, coord in enumerate(list_face_coord):\\n left, top, right, bottom = coord\\n list_faces.append(img[top:bottom, left:right])\\n return list_faces\",\n \"def get_faces(self, image):\\n\\t\\t\\n\\t\\t# Convert the image to grayscale and normalise\\n\\t\\tcv.CvtColor(image, self.gray, cv.CV_BGR2GRAY)\\n\\t\\tcv.EqualizeHist(self.gray, self.gray)\\n\\t\\t\\n\\t\\t# Detect faces\\n\\t\\treturn cv.HaarDetectObjects(self.gray, self.cascade, self.storage,\\n\\t\\t scale_factor = 1.3,\\n\\t\\t min_neighbors = 2,\\n\\t\\t flags = cv.CV_HAAR_DO_CANNY_PRUNING,\\n\\t\\t min_size = (40,40))\",\n \"def faces(self):\\n res = []\\n if(self.isFacesLoaded() == False):\\n return res\\n for face in self.getCurrentCacheData()['faces']:\\n face = Face().setJSONData(face)\\n if(face.confidence > self.faceDetector.confThreshold):\\n res.append(face)\\n return res\",\n \"def detect_faces_from_image(self, img, desired_width,\\n desired_height, bbox_scaling=1.1):\\n \\n n_face = 0\\n faces_data = []\\n\\n frame_height = img.shape[0]\\n frame_width = img.shape[1]\\n blob = cv2.dnn.blobFromImage(img, 1.0, (300, 300), [104, 117, 123], True, False)\\n self.face_detector.setInput(blob)\\n detections = self.face_detector.forward()\\n \\n \\n for i in range(detections.shape[2]):\\n confidence = detections[0, 0, i, 2]\\n if confidence > self.threshold:\\n n_face += 1\\n bbox = _get_bbox_pts(detections, i, frame_width, frame_height)\\n x1, y1 = [int(i * abs(bbox_scaling//1 - bbox_scaling%1)) for i in bbox[:2]]\\n x2, y2 = [int(i*bbox_scaling) for i in bbox[2:]]\\n if x1 < x2 and y1 < y2:\\n dets = [dlib.rectangle(x1, y1, x2, y2)]\\n else:\\n dets = [dlib.rectangle(0, 0, frame_width, frame_height)]\\n\\n \\n face_img, left_eye, right_eye = self.align_and_crop_face(img, dets, desired_width,\\n desired_height)\\n \\n face_data = [dets, face_img, left_eye, right_eye,\\n 'face_%d' % n_face, confidence]\\n faces_data.append(face_data)\\n\\n return faces_data\",\n \"def detect_faces(self, img) -> list:\\r\\n if img is None or not hasattr(img, \\\"shape\\\"):\\r\\n raise InvalidImage(\\\"Image not valid.\\\")\\r\\n\\r\\n height, width, _ = img.shape\\r\\n stage_status = StageStatus(width=width, height=height)\\r\\n\\r\\n m = 12 / self._min_face_size\\r\\n min_layer = np.amin([height, width]) * m\\r\\n\\r\\n scales = self.__compute_scale_pyramid(m, min_layer)\\r\\n\\r\\n stages = [self.__stage1, self.__stage2, self.__stage3]\\r\\n result = [scales, stage_status]\\r\\n\\r\\n # We pipe here each of the stages\\r\\n for stage in stages:\\r\\n result = stage(img, result[0], result[1])\\r\\n\\r\\n [total_boxes, points] = result\\r\\n\\r\\n bounding_boxes = []\\r\\n\\r\\n for bounding_box, keypoints in zip(total_boxes, points.T):\\r\\n x = max(0, int(bounding_box[0]))\\r\\n y = max(0, int(bounding_box[1]))\\r\\n width = int(bounding_box[2] - x)\\r\\n height = int(bounding_box[3] - y)\\r\\n bounding_boxes.append({\\r\\n 'box': [x, y, width, height],\\r\\n 'confidence': bounding_box[-1],\\r\\n 'keypoints': {\\r\\n 'left_eye': (int(keypoints[0]), int(keypoints[5])),\\r\\n 'right_eye': (int(keypoints[1]), int(keypoints[6])),\\r\\n 'nose': (int(keypoints[2]), int(keypoints[7])),\\r\\n 'mouth_left': (int(keypoints[3]), int(keypoints[8])),\\r\\n 'mouth_right': (int(keypoints[4]), int(keypoints[9])),\\r\\n }\\r\\n })\\r\\n\\r\\n return bounding_boxes\",\n \"def get_faceboxes(self, image, threshold):\\n rows, cols, _ = image.shape\\n\\n confidences = []\\n faceboxes = []\\n\\n self.face_net.setInput(cv2.dnn.blobFromImage(image, 1.0, (300, 300), (104.0, 177.0, 123.0), False, False))\\n\\n detections = self.face_net.forward()\\n\\n if debug > 2 :\\n print(\\\"number of face found:\\\", len (detections[0, 0, :, :]))\\n\\n for result in detections[0, 0, :, :]:\\n confidence = result[2]\\n if confidence >= threshold:\\n x_left_bottom = int(result[3] * cols)\\n y_left_bottom = int(result[4] * rows)\\n x_right_top = int(result[5] * cols)\\n y_right_top = int(result[6] * rows)\\n confidences.append(confidence)\\n faceboxes.append([x_left_bottom, y_left_bottom, x_right_top, y_right_top])\\n\\n if debug > 2 :\\n print(\\\"number of detection > threshold\\\", len(faceboxes))\\n\\n self.detection_result = [faceboxes, confidences]\\n\\n return confidences, faceboxes\",\n \"def face_detection(img, faceCascade=faceCascade):\\n\\tgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n\\tfaces = faceCascade.detectMultiScale(\\n\\t\\tgray,\\n\\t\\tscaleFactor=1.2,\\n\\t\\tminNeighbors=5,\\n\\t\\tminSize=(32, 32))\\n\\n\\t# If no face detected\\n\\tif len(faces) == 0:\\n\\t\\tw = min(img.shape[0], img.shape[1])\\n\\t\\treturn img[(img.shape[0]-w)//2:(img.shape[0]+w)//2, (img.shape[1]-w)//2:(img.shape[1]+w)//2, :]\\n\\n\\t# If faces detected, choose the face with the max size\\n\\tmax_h, index = 0, 0\\n\\tfor i, (x, y, w, h) in enumerate(faces):\\n\\t\\tif max_h < h:\\n\\t\\t\\tmax_h, index = h, i\\n\\n\\t(x, y, w, h) = faces[index]\\n\\n\\tif img.shape[0]>img.shape[1]:\\n\\t\\tif x + w/2 < img.shape[0]/2:\\n\\t\\t\\treturn img[:img.shape[1],:,:]\\n\\n\\t\\telse:\\n\\t\\t\\treturn img[-img.shape[1]:,:,:]\\n\\n\\telse:\\n\\t\\tif y + h/2 < img.shape[1]/2:\\n\\t\\t\\treturn img[:,:img.shape[0],:]\\n\\n\\t\\telse:\\n\\t\\t\\treturn img[:,-img.shape[0]:,:]\",\n \"def detect_face_task(img):\\n\\n # paramter for detect\\n # image_size = 160\\n # margin = 44\\n minsize = 20 # minimum size of face\\n threshold = [0.6, 0.7, 0.7] # three steps's threshold\\n factor = 0.709 # scale factor\\n\\n # caffe model\\n pnet = caffe_model.get_pnet()\\n rnet = caffe_model.get_rnet()\\n onet = caffe_model.get_onet()\\n\\n bounding_boxes, _ = detect_face.detect_face(img, minsize, pnet, rnet, onet, threshold, factor)\\n print('detect bounding: ', bounding_boxes)\\n print('Find faces: ', bounding_boxes.shape[0])\\n\\n # all_faces is faces information list, include face bytes, face position\\n all_faces = []\\n for face_position in bounding_boxes:\\n face_position = face_position.astype(int)\\n print('face position: ', face_position)\\n\\n # each face information, include position, face image\\n head_rect = face_position[:4].tolist() # numpy array to python list\\n head_img = misc.toimage(img).crop(head_rect)\\n head_img_io = StringIO.StringIO()\\n head_img.save(head_img_io, format='JPEG')\\n head_img_b64 = base64.b64encode(head_img_io.getvalue())\\n\\n # construct response\\n face_info = {}\\n face_info['rect'] = head_rect\\n face_info['image'] = head_img_b64\\n\\n all_faces.append(face_info)\\n\\n return all_faces\",\n \"def detect_face(self, img, img_file_path=None):\\n #use dlib face detector\\n #create dlib detector, this is hog with svm\\n detector = dlib.get_frontal_face_detector()\\n #win = dlib.image_window()\\n if img_file_path:\\n img = dlib.load_rgb_image(img_file_path)\\n #detect number of faces in an image\\n dets = detector(img)\\n list_face_coord = [] # this will store left, top, right, bottom\\n for i, d in enumerate(dets):\\n list_face_coord.append((d.left(), d.top(), d.right(), d.bottom()))\\n return list_face_coord\",\n \"def detect_faces(path):\\n from google.cloud import vision\\n from PIL import Image, ImageDraw\\n import io\\n\\n client = vision.ImageAnnotatorClient()\\n with io.open(path, 'rb') as image_file:\\n content = image_file.read()\\n\\n image = vision.Image(content=content)\\n response = client.face_detection(image=image)\\n faces = response.face_annotations\\n face_distance = [10000000] * len(faces)\\n face_area = []\\n face_vertices = []\\n\\n counter = 0\\n for face in faces:\\n face_vertices.append((face.bounding_poly.vertices[0].x, face.bounding_poly.vertices[0].y))\\n face_area.append(area((face.bounding_poly.vertices[0].x, face.bounding_poly.vertices[0].y), \\n (face.bounding_poly.vertices[1].x, face.bounding_poly.vertices[1].y),\\n (face.bounding_poly.vertices[2].x, face.bounding_poly.vertices[2].y)))\\n im = Image.open(path)\\n cropped = im.crop((face.bounding_poly.vertices[0].x, face.bounding_poly.vertices[0].y, face.bounding_poly.vertices[2].x, face.bounding_poly.vertices[2].y))\\n #cropped.show()\\n cropped.save(\\\"./media/images/\\\" + str(counter) + \\\".jpg\\\")\\n counter += 1\\n \\n for i in range(len(faces)):\\n min_dist = 0\\n for j in range(len(faces)):\\n distance = dist(face_vertices[i], face_vertices[j])\\n if distance > 0 and (face_area[i] + face_area[j]) / distance < face_distance[i]: \\n face_distance[i] = (face_area[i] + face_area[j]) / distance\\n \\n \\n with Image.open(path) as im:\\n counter = 0\\n \\n draw = ImageDraw.Draw(im)\\n for face in faces:\\n draw.rectangle([face.bounding_poly.vertices[counter].x, face.bounding_poly.vertices[counter].y,\\n face.bounding_poly.vertices[counter + 2].x, face.bounding_poly.vertices[counter + 2].y], None, \\\"#0000ff\\\", 3)\\n for i in range(len(faces)):\\n if face_distance[i] < 30 or len(faces) == 1: colour = \\\"#00ff00\\\"\\n else: colour = \\\"#ff0000\\\"\\n draw.rectangle([faces[i].bounding_poly.vertices[0].x, faces[i].bounding_poly.vertices[0].y,\\n faces[i].bounding_poly.vertices[2].x, faces[i].bounding_poly.vertices[2].y], None, colour, 3)\\n draw.text((faces[i].bounding_poly.vertices[0].x - 10, faces[i].bounding_poly.vertices[0].y - 10), str(i+1), \\\"#ff0000\\\",font=None, anchor=None, spacing=4, align='left', direction=None, features=None, language=None, stroke_width=1, stroke_fill=None, embedded_color=False)\\n\\n im.save(\\\"./media/images/upload.jpg\\\")\\n return len(faces)\\n if response.error.message:\\n raise Exception('Error')\",\n \"def detect_face(self, img):\\n #convert the test image to gray image as opencv face detector expects gray images\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n\\n #let's detect multiscale (some images may be closer to camera than others) images\\n #result is a list of faces\\n faces = self.face_cascade.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=5);\\n\\n #if no faces are detected then return None\\n if (len(faces) == 0):\\n return None, None\\n\\n #under the assumption that there will be only one face,\\n #extract the face area\\n (x, y, w, h) = faces[0]\\n\\n #return only the face part of the image\\n return gray[y:y+w, x:x+h], faces[0]\",\n \"def detect_face(face_file, max_results=4):\\n client = vision.ImageAnnotatorClient()\\n\\n content = face_file.read()\\n image = types.Image(content=content)\\n\\n return client.face_detection(image=image).face_annotations\",\n \"def recognize_faces(image_file_path):\\n image_pil = Image.open(image_file_path)\\n draw = ImageDraw.Draw(image_pil)\\n\\n known_face_encodings_dict = get_known_face_encodings_dict()\\n known_names = list(known_face_encodings_dict.keys())\\n known_face_encodings = list(known_face_encodings_dict.values())\\n\\n del known_face_encodings_dict\\n\\n for face_location in face_detection.get_face_locations(image_file_path):\\n face_encoding = get_face_encodings(\\n image_file_path, known_face_locations=[face_location]\\n )[0]\\n\\n recognition_flags = face_recognition.compare_faces(\\n known_face_encodings, face_encoding\\n )\\n\\n for flag, name in zip(recognition_flags, known_names):\\n if not flag:\\n continue\\n\\n top, right, bottom, left = face_location\\n draw.rectangle((left, top, right, bottom), outline=\\\"#FF1493\\\")\\n text_width, text_height = draw.textsize(name)\\n draw.rectangle(\\n (left, bottom, right, bottom + text_height + 10),\\n fill=\\\"#FF1493\\\",\\n outline=\\\"#FF1493\\\",\\n )\\n draw.text((left + 6, bottom + 5), name, fill=\\\"white\\\")\\n\\n del draw # conserve resources\\n image_pil.show()\",\n \"def read_known_faces():\\n known_face_encodings = []\\n known_face_names = []\\n\\n for file_name in glob.glob(DATASET_FOLDER + \\\"/*.jpg\\\"):\\n face_encoding = read_face_encoding(file_name)\\n\\n known_face_encodings.append(face_encoding)\\n\\n name = file_name.split('.jpg')[0].split('/')[-1]\\n if len(name.split('_')) != 2:\\n raise Exception(\\\"\\\\n\\\\nERROR: file \\\\'\\\" + file_name + \\\"\\\\' has incorrect name\\\\n\\\\n\\\")\\n\\n known_face_names.append(name)\\n\\n return known_face_encodings, known_face_names\",\n \"def detect_face(face_file, max_results=10):\\n client = vision.ImageAnnotatorClient()\\n\\n content = face_file.read()\\n image = types.Image(content=content)\\n\\n return client.face_detection(image=image).face_annotations\",\n \"def get_image_with_faces(self, image):\\n img = image.copy()\\n faces = self.__detect_face(img)\\n\\n if len(faces) > 0:\\n for i, d in enumerate(faces):\\n x1, y1, x2, y2, _, _ = d.left(), d.top(), \\\\\\n d.right() + 1, d.bottom() + 1, d.width(), d.height()\\n cv2.rectangle(img, (x1, y1), (x2, y2), RECT_COLOR, RECT_THICKNESS)\\n return img\",\n \"def extract_faces(image_path: str, pk: int):\\n image = Image.open(image_path)\\n image = np.array(image)\\n\\n if image.shape[0] <= 0 or image.shape[1] <= 0:\\n return None\\n\\n import mtcnn\\n\\n # detect faces from image\\n face_detector = mtcnn.MTCNN()\\n detections = face_detector.detect_faces(image)\\n\\n if len(detections) < 1:\\n return None\\n\\n from deepface.basemodels.Facenet import InceptionResNetV2\\n\\n # load InceptionResNet model provided by deepface\\n facenet_model = InceptionResNetV2()\\n facenet_model.load_weights(get_weights(\\\"facenet\\\"))\\n\\n # normalize faces and get embeddings\\n faces = [normalize_face(image, face) for face in detections]\\n embeddings = facenet_model.predict(np.vstack(faces), batch_size=len(faces))\\n\\n for i in range(len(faces)):\\n person_id = recognize_person(embeddings[i])\\n print(person_id, flush=True)\\n face_obj = models.Face.objects.create(\\n confidence=detections[i]['confidence'],\\n left=detections[i]['box'][0],\\n top=detections[i]['box'][1],\\n width=detections[i]['box'][2],\\n height=detections[i]['box'][3],\\n photo_id=pk,\\n person_id=person_id\\n )\\n\\n save_embeddings(embeddings[i], face_obj.id, person_id)\",\n \"def __detect_face(self, img):\\n gray = cv2.cvtColor(img.copy(), cv2.COLOR_BGR2GRAY)\\n return self.detector(gray, 1)\",\n \"def detect_face(self, img):\\n # Fetch face location from the frame with 128 encoding of face landmarks\\n curr_face_loc, name_list, info_list = load_encode_loc(img, self.kwn_names,\\n self.kwn_encoding,\\n self.status_list, self.since_list)\\n print('Current value is ', curr_face_loc, name_list)\\n face_list = []\\n face_area = []\\n print('face loc', curr_face_loc)\\n if len(curr_face_loc):\\n\\n for (top, right, bottom, left), name in zip(curr_face_loc, name_list):\\n print(top, right, bottom, left)\\n cv2.rectangle(img, (top, right), (bottom, left), (0, 255, 2), 2)\\n\\n w = right - left\\n h = bottom - top\\n cx = left + w // 2\\n cy = top + h // 2\\n area = w * h\\n\\n for idx, info in enumerate(info_list):\\n cv2.putText(img, info, (bottom, int(left * idx * 0.2)),\\n cv2.FONT_HERSHEY_COMPLEX, 1,\\n (0, 0, 255), 1)\\n\\n face_list.append([cx, cy])\\n face_area.append(area)\\n\\n i = face_area.index(max(face_area))\\n\\n return img, [face_list[i], face_area[i]]\\n\\n else:\\n return img, [[0, 0], 0]\",\n \"def extract_faces(input_path, output_path=None, save=False, show=False):\\r\\n \\r\\n img = cv2.imread(input_path)\\r\\n gray = pp.grayscale(img);\\r\\n \\r\\n face_cascade = cv2.CascadeClassifier('/Haar_Filters/haarcascade_frontalface_default.xml')\\r\\n faces = face_cascade.detectMultiScale(gray,1.05,4)\\r\\n \\r\\n if save:\\r\\n for i,(x,y,w,h) in enumerate(faces):\\r\\n face = img[y:y+h, x:x+w]\\r\\n if len(face_cascade.detectMultiScale(face,1.05,6)) == 1:\\r\\n cv2.imwrite(output_path+'/'+str(i)+'.jpeg', face)\\r\\n \\r\\n if show:\\r\\n for i,(x,y,w,h) in enumerate(faces):\\r\\n face = img[y:y+h, x:x+w]\\r\\n if len(face_cascade.detectMultiScale(face,1.05,6)) == 1:\\r\\n cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),3)\\r\\n else:\\r\\n cv2.rectangle(img,(x,y),(x+w,y+h),(0,0,255),3)\\r\\n pp.show_image(pp.resize_image(img, 1000))\",\n \"def detect_face(gray):\\r\\n face_cascade = cv2.CascadeClassifier(classifier_file_name)\\r\\n faces = face_cascade.detectMultiScale(gray, scaleFactor=scale_factor,minNeighbors=min_neighbors,minSize=min_size,flags=flags)\\r\\n return faces\",\n \"def ssd_face_detection(image):\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n image_np_expanded = np.expand_dims(image, axis=0)\\n\\n (boxes, scores, classes) = FaceDetectorModel().sess.run(\\n [FaceDetectorModel().boxes, FaceDetectorModel().scores, FaceDetectorModel().classes],feed_dict={FaceDetectorModel().image_tensor: image_np_expanded})\\n\\n face_list = vis_util.visualize_boxes_and_labels_on_image_array(\\n image,\\n np.squeeze(boxes),\\n np.squeeze(classes).astype(np.int32),\\n np.squeeze(scores),\\n category_index,\\n use_normalized_coordinates=True,\\n line_thickness=4)\\n\\n return face_list\",\n \"def findFaces(self):\\n\\t\\trects = self.detectAll()\\n\\t\\tif len(rects)==0:\\n\\t\\t\\trects = []\\n\\t\\telse:\\n\\t\\t\\trects[:, 2:] += rects[:, :2]\\n\\t\\tself.analyzeFrame(rects)\",\n \"def _box_faces(image):\\n for face in image.faces:\\n _box_face(image, face)\\n return image\",\n \"def face_detect(sess, net, image_name):\\n\\n\\t# Load the demo image\\n\\tim_file = os.path.join(cfg.DATA_DIR, 'demo', image_name)\\n\\tim = cv2.imread(im_file)\\n\\n\\t# Detect all object classes and regress object bounds\\n\\ttimer = Timer()\\n\\ttimer.tic()\\n\\t# scores, boxes = im_detect(sess, net, im)\\n\\tscores, boxes, eyes, smiles = im_detect_ori(sess, net, im)\\n\\ttimer.toc()\\n\\tprint ('Detection took {:.3f}s for '\\n\\t\\t\\t'{:d} object proposals').format(timer.total_time, boxes.shape[0])\\n\\n\\t# Visualize detections for each class\\n\\t# im = im[:, :, (2, 1, 0)]\\n\\t# fig, ax = plt.subplots(figsize=(8, 8))\\n\\t# ax.imshow(im, aspect='equal')\\n\\n\\tCONF_THRESH = 0.9\\n\\tNMS_THRESH = 0.3\\n\\tfor cls_ind, cls in enumerate(CLASSES[20:]):\\n\\t\\tcls_ind += 20 # because we skipped everything except face\\n\\t\\tcls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n\\t\\tcls_scores = scores[:, cls_ind]\\n\\t\\tdets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)\\n\\t\\tkeep = nms(dets, NMS_THRESH)\\n\\t\\tdets = dets[keep, :]\\n\\t\\teye = eyes[keep, :]\\n\\t\\tsmile= smiles[keep, :]\\n\\n\\tinds = np.where(dets[:, -1] >= CONF_THRESH)[0]\\n\\tface_num = len(inds)\\n\\tprint '{} faces detected!'.format(face_num)\\n\\tdets = dets[inds, :]\\n\\teye = eye[inds, 1]\\n\\tsmile = smile[inds, 1]\\n\\n\\treturn dets, eye, smile\",\n \"def detector(videoframe, facedetection, maskdetection):\\n (h, w) = videoframe.shape[:2]\\n blobimage = cv2.dnn.blobFromImage(videoframe, 1.0, (224, 224), (104.0, 177.0, 123.0))\\n\\n facedetection.setInput(blobimage)\\n ffinding = facedetection.forward()\\n\\n face_list = []\\n locations = []\\n predictions = []\\n\\n for i in range(0, ffinding.shape[2]):\\n credence = ffinding[0, 0, i, 2]\\n if credence > 0.6:\\n case = ffinding[0, 0, i, 3:7] * np.array([w, h, w, h])\\n (x_start, y_start, x_end, y_end) = case.astype(\\\"int\\\")\\n (x_start, y_start) = (max(0, x_start), max(0, y_start))\\n (x_end, y_end) = (min(w - 1, x_end), min(h - 1, y_end))\\n\\n image = videoframe[y_start:y_end, x_start:x_end]\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n image = cv2.resize(image, (224, 224))\\n image = img_to_array(image)\\n image = preprocess_input(image)\\n face_list.append(image)\\n locations.append((x_start, y_start, x_end, y_end))\\n\\n if len(face_list) > 0:\\n face_list = np.array(face_list, dtype=\\\"float32\\\")\\n predictions = maskdetection.predict(face_list, batch_size=32)\\n return (locations, predictions)\",\n \"def classify_face(im):\\n faces_death = get_encoded_faces_deaths()\\n faces_arrested = get_encoded_faces_arrested()\\n faces_wanted = get_encoded_faces_wanted()\\n\\n faces_encoded_death = list(faces_death.values())\\n known_face_names_death = list(faces_death.keys())\\n\\n faces_encoded_arrested = list(faces_arrested.values())\\n known_face_names_arrested = list(faces_arrested.keys())\\n\\n faces_encoded_wanted = list(faces_wanted.values())\\n known_face_names_wanted = list(faces_wanted.keys())\\n\\n img = cv2.imread(im, 1)\\n face_locations = face_recognition.face_locations(img)\\n unknown_face_encodings = face_recognition.face_encodings(img,face_locations)\\n face_names = []\\n find_in_db(im,known_face_names_death,unknown_face_encodings,face_names,faces_encoded_death,\\\"unnatural_death_images/unnatural_death_images\\\")\\n find_in_db(im,known_face_names_arrested,unknown_face_encodings,face_names,faces_encoded_arrested,\\\"ArrestPerson_images\\\")\\n find_in_db(im,known_face_names_wanted,unknown_face_encodings,face_names,faces_encoded_wanted,\\\"wanted\\\")\",\n \"def detection():\\n faceCascade = cv2.CascadeClassifier(cv2.data.haarcascades + \\\"haarcascade_frontalface_default.xml\\\")\\n faces = faceCascade.detectMultiScale(\\n gray,\\n scaleFactor=1.3,\\n minNeighbors=3,\\n minSize=(30, 30)\\n )\\t#Haar-cascade: A Face detection algorithm\\n\\n area = faces[:,2] * faces[:,3]\\n faces = np.c_[faces,area]\\t#concatenates area values to last column of 'face' array.\\n\\n print('All detected faces\\\\n',faces)\\n i,j = unravel_index(faces.argmax(), faces.shape)\\t# gets the position of maximum value from 'face' array.\\n print(i,j)\\n print(\\\"Found %d Face%s!\\\" %(len(faces),\\\"s\\\"[len(faces)==1:]))\\n\\n X = faces[i,0]\\n Y = faces[i,1]\\n W = faces[i,2]\\n H = faces[i,3]\\n \\n cv2.rectangle(image, (X, Y), (X + W, Y + H), (0, 255, 0), 2)\\n roi_color = image[Y:Y + H, X:X + W] \\n print(\\\"Face(largest) Extracted.\\\")\\n cv2.imwrite('Extracted_face.jpg', roi_color)\\t#Image Extraction.\\n status = cv2.imwrite('Output.jpg', image)\\n print(\\\"Image Output.jpg written to filesystem: \\\", status)\",\n \"def recogniseFace(self, imagefilenames, selectedFileName, selectedDirectory, numOfEigenfaces, thresholdVal):\\r\\n print 'recogniseFace()::'\\r\\n self.facet.checkCache(selectedDirectory, imagefilenames, numOfEigenfaces)\\r\\n mindist, matchfile = self.facet.findMatchingImage(selectedFileName, numOfEigenfaces, thresholdVal)\\r\\n self.processMatchResult(matchfile, mindist, numOfEigenfaces)\",\n \"def get_faceboxes(self,img,threshold):\\n faces = self.mark_detector.extract_cnn_facebox(img,threshold)\\n \\n\\n\\n faceboxes = []\\n for face in faces:\\n start = (face[0],face[1])\\n end = (face[2],face[3])\\n box = Box.setStartEnd(start,end)\\n\\n faceboxes.append(box)\\n \\n return faceboxes\",\n \"def box_faces(images):\\n return (_box_faces(image) for image in images)\",\n \"def faceRecognition(image):\\r\\n faceLandmarks = [[],[],[]]\\r\\n face_landmarks_list = face_recognition.face_landmarks(image)\\r\\n if len(face_landmarks_list)>0:\\r\\n if len(face_landmarks_list[0]['left_eye'])>0:\\r\\n leftEyePos = [tuple(map(lambda i: int(i/32),i)) for i in face_landmarks_list[0]['left_eye']]\\r\\n for i in set(leftEyePos):\\r\\n if leftEyePos.count(i)>=len(leftEyePos)//len(set(leftEyePos)):\\r\\n faceLandmarks[0] += [i,]\\r\\n if len(face_landmarks_list[0]['right_eye'])>0:\\r\\n rightEyePos = [tuple(map(lambda i: int(i/32),i)) for i in face_landmarks_list[0]['right_eye']]\\r\\n for i in set(rightEyePos):\\r\\n if rightEyePos.count(i)>=len(rightEyePos)//len(set(rightEyePos)):\\r\\n faceLandmarks[1] += [i,]\\r\\n if len(face_landmarks_list[0]['top_lip'])>0:\\r\\n mouthPos = [tuple(map(lambda i: int(i/32),i)) for i in (face_landmarks_list[0]['top_lip']+face_landmarks_list[0]['bottom_lip'])]\\r\\n for i in set(mouthPos):\\r\\n if mouthPos.count(i)>=len(mouthPos)//len(set(mouthPos)):\\r\\n faceLandmarks[2] += [i,]\\r\\n return faceLandmarks\",\n \"def track_faces_in_video(self):\\r\\n\\r\\n logger.debug('Executing face tracking')\\r\\n\\r\\n track_loaded = False\\r\\n\\r\\n # Try to load YAML file with tracking results\\r\\n if os.path.exists(self.track_file_path):\\r\\n\\r\\n print 'Loading YAML file with tracking results'\\r\\n logger.debug('Loading YAML file with tracking results')\\r\\n\\r\\n track_faces = utils.load_YAML_file(self.track_file_path)\\r\\n\\r\\n if track_faces:\\r\\n self.tracked_faces = track_faces\\r\\n\\r\\n print 'YAML file with tracking results loaded'\\r\\n logger.debug('YAML file with tracking results loaded')\\r\\n\\r\\n track_loaded = True\\r\\n\\r\\n if not track_loaded:\\r\\n\\r\\n # Check existence of detection results\\r\\n\\r\\n if len(self.detected_faces) == 0:\\r\\n\\r\\n # Try to load YAML file\\r\\n if os.path.exists(self.det_file_path):\\r\\n\\r\\n print 'Loading YAML file with detection results'\\r\\n logger.debug('Loading YAML file with detection results')\\r\\n\\r\\n with open(self.det_file_path) as f:\\r\\n\\r\\n self.detected_faces = yaml.load(f)\\r\\n\\r\\n print 'YAML file with detection results loaded'\\r\\n logger.debug('YAML file with detection results loaded')\\r\\n\\r\\n else:\\r\\n\\r\\n print 'Warning! No detection results found!'\\r\\n logger.warning('No detection results found!')\\r\\n\\r\\n return\\r\\n\\r\\n # Get shot cuts\\r\\n self.calc_hist_diff()\\r\\n\\r\\n print '\\\\n\\\\n### Face tracking ###\\\\n'\\r\\n logger.debug('\\\\n\\\\n### Face tracking ###\\\\n')\\r\\n\\r\\n # Save processing time\\r\\n start_time = cv2.getTickCount()\\r\\n\\r\\n self.tracked_faces = []\\r\\n\\r\\n self.disc_tracked_faces = []\\r\\n\\r\\n # Counter for frames with detected faces\\r\\n frame_counter = 0\\r\\n\\r\\n # If a reduced frame rate is used, frames are less\\r\\n use_or_fps = c.USE_ORIGINAL_FPS\\r\\n used_fps = c.USED_FPS\\r\\n min_segment_duration = c.MIN_SEGMENT_DURATION\\r\\n tracking_min_int_area = c.TRACKING_MIN_INT_AREA\\r\\n min_size_width = c.FACE_DETECTION_MIN_SIZE_WIDTH\\r\\n min_size_height = c.FACE_DETECTION_MIN_SIZE_HEIGHT\\r\\n max_fr_with_miss_det = c.MAX_FR_WITH_MISSED_DET\\r\\n use_aligned_face = c.USE_ALIGNED_FACE_IN_TRACKING\\r\\n\\r\\n if self.params is not None:\\r\\n if c.USE_ORIGINAL_FPS_KEY in self.params:\\r\\n use_or_fps = self.params[c.USE_ORIGINAL_FPS_KEY]\\r\\n if c.USED_FPS_KEY in self.params:\\r\\n used_fps = self.params[c.USED_FPS_KEY]\\r\\n if c.MIN_SEGMENT_DURATION_KEY in self.params:\\r\\n min_segment_duration = self.params[\\r\\n c.MIN_SEGMENT_DURATION_KEY]\\r\\n if c.TRACKING_MIN_INT_AREA_KEY in self.params:\\r\\n tracking_min_int_area = self.params[\\r\\n c.TRACKING_MIN_INT_AREA_KEY]\\r\\n if c.MIN_SIZE_WIDTH_KEY in self.params:\\r\\n min_size_width = self.params[c.MIN_SIZE_WIDTH_KEY]\\r\\n if c.MIN_SIZE_HEIGHT_KEY in self.params:\\r\\n min_size_height = self.params[c.MIN_SIZE_HEIGHT_KEY]\\r\\n if c.MAX_FR_WITH_MISSED_DET_KEY in self.params:\\r\\n max_fr_with_miss_det = self.params[\\r\\n c.MAX_FR_WITH_MISSED_DET_KEY]\\r\\n if c.USE_ALIGNED_FACE_IN_TRACKING_KEY in self.params:\\r\\n use_aligned_face = self.params[\\r\\n c.USE_ALIGNED_FACE_IN_TRACKING_KEY]\\r\\n\\r\\n # Minimum duration of a segment in frames\\r\\n min_segment_frames = int(\\r\\n math.ceil(self.fps * min_segment_duration))\\r\\n\\r\\n if not use_or_fps:\\r\\n min_segment_frames = int(\\r\\n math.ceil((used_fps + 1) * min_segment_duration))\\r\\n\\r\\n # Make copy of detected faces\\r\\n detection_list = list(self.detected_faces)\\r\\n\\r\\n # Iterate through frames in detected_faces\\r\\n for detection_dict in detection_list:\\r\\n\\r\\n self.progress = 100 * (frame_counter / self.saved_frames)\\r\\n\\r\\n print('progress: ' + str(self.progress) + ' % \\\\r'),\\r\\n\\r\\n elapsed_s = detection_dict[c.ELAPSED_VIDEO_TIME_KEY]\\r\\n\\r\\n frame_name = detection_dict[c.SAVED_FRAME_NAME_KEY]\\r\\n\\r\\n faces = detection_dict[c.FACES_KEY]\\r\\n\\r\\n face_counter = 0\\r\\n\\r\\n # Iterate though faces in frame\\r\\n for face_dict in faces:\\r\\n\\r\\n track_window = face_dict[c.BBOX_KEY]\\r\\n\\r\\n left_eye_pos = face_dict[c.LEFT_EYE_POS_KEY]\\r\\n\\r\\n right_eye_pos = face_dict[c.RIGHT_EYE_POS_KEY]\\r\\n\\r\\n nose_pos = face_dict[c.NOSE_POSITION_KEY]\\r\\n\\r\\n file_name = face_dict[c.ALIGNED_FACE_FILE_NAME_KEY]\\r\\n\\r\\n # Counter for faces in segment\\r\\n segment_face_counter = 1\\r\\n\\r\\n segment_frame_list = []\\r\\n\\r\\n # Start new segment\\r\\n segment_frame_dict = {c.FRAME_COUNTER_KEY: frame_counter,\\r\\n c.ELAPSED_VIDEO_TIME_KEY: elapsed_s,\\r\\n c.DETECTION_BBOX_KEY: track_window,\\r\\n c.TRACKING_BBOX_KEY: track_window,\\r\\n c.LEFT_EYE_POS_KEY: left_eye_pos,\\r\\n c.RIGHT_EYE_POS_KEY: right_eye_pos,\\r\\n c.NOSE_POSITION_KEY: nose_pos,\\r\\n c.ALIGNED_FACE_FILE_NAME_KEY: file_name,\\r\\n c.DETECTED_KEY: True,\\r\\n c.SAVED_FRAME_NAME_KEY: frame_name}\\r\\n\\r\\n segment_frame_list.append(segment_frame_dict)\\r\\n\\r\\n aligned_file_path = None\\r\\n rgb_roi = None\\r\\n if use_aligned_face:\\r\\n # Use the aligned face as the\\r\\n # Region of Interest for tracking\\r\\n complete_file_name = file_name + '.png'\\r\\n aligned_file_path = os.path.join(\\r\\n self.align_path, complete_file_name)\\r\\n\\r\\n rgb_roi = cv2.imread(\\r\\n aligned_file_path, cv2.IMREAD_COLOR)\\r\\n\\r\\n else:\\r\\n # Use detected face as the\\r\\n # Region of Interest for tracking\\r\\n x0 = track_window[0]\\r\\n y0 = track_window[1]\\r\\n w = track_window[2]\\r\\n h = track_window[3]\\r\\n x1 = x0 + w\\r\\n y1 = y0 + h\\r\\n\\r\\n frame_path = os.path.join(\\r\\n self.frames_path, frame_name)\\r\\n\\r\\n # Whole frame\\r\\n rgb = cv2.imread(frame_path, cv2.IMREAD_COLOR)\\r\\n\\r\\n # Face\\r\\n rgb_roi = rgb[y0:y1, x0:x1]\\r\\n\\r\\n if rgb_roi is None:\\r\\n print('Warning! Face to be tracked is None')\\r\\n\\r\\n if use_aligned_face:\\r\\n logger.warning(\\r\\n 'Face ' + aligned_file_path + ' is None')\\r\\n else:\\r\\n logger.warning(\\r\\n 'Face from frame ' + frame_name + ' is None')\\r\\n\\r\\n face_counter += 1\\r\\n\\r\\n continue\\r\\n\\r\\n # Convert image to hsv\\r\\n hsv_roi = cv2.cvtColor(rgb_roi, cv2.COLOR_BGR2HSV)\\r\\n\\r\\n mask_roi = cv2.inRange(\\r\\n hsv_roi, np.array((0., 60., 32.)),\\r\\n np.array((180., 255., 255.)))\\r\\n\\r\\n hist = cv2.calcHist(\\r\\n [hsv_roi], [0], mask_roi, [16], [0, 180])\\r\\n\\r\\n cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX)\\r\\n hist = hist.reshape(-1)\\r\\n\\r\\n # Face should not be considered anymore\\r\\n del (detection_list[frame_counter]\\r\\n [c.FACES_KEY][face_counter])\\r\\n\\r\\n sub_frame_counter = frame_counter + 1\\r\\n\\r\\n missed_det_counter = 0\\r\\n\\r\\n # Iterate through subsequent frames\\r\\n for sub_det_dict in detection_list[sub_frame_counter:]:\\r\\n\\r\\n # Check if a new shot begins\\r\\n if sub_frame_counter in self.cut_idxs:\\r\\n break\\r\\n\\r\\n sub_frame_name = sub_det_dict[c.SAVED_FRAME_NAME_KEY]\\r\\n\\r\\n sub_frame_path = os.path.join(\\r\\n self.frames_path, sub_frame_name)\\r\\n\\r\\n # Read image from given path\\r\\n sub_image = cv2.imread(\\r\\n sub_frame_path, cv2.IMREAD_COLOR)\\r\\n\\r\\n if sub_image is None:\\r\\n print('Warning! Image is None')\\r\\n logger.warning(\\r\\n 'Image ' + sub_frame_path + ' is None')\\r\\n\\r\\n continue\\r\\n\\r\\n # Convert image to hsv\\r\\n sub_hsv = cv2.cvtColor(sub_image, cv2.COLOR_BGR2HSV)\\r\\n\\r\\n sub_mask = cv2.inRange(sub_hsv,\\r\\n np.array((0., 60., 32.)),\\r\\n np.array((180., 255., 255.)))\\r\\n\\r\\n # Apply meanshift to get the new location\\r\\n prob = cv2.calcBackProject(\\r\\n [sub_hsv], [0], hist, [0, 180], 1)\\r\\n prob &= sub_mask\\r\\n term_crit = (cv2.TERM_CRITERIA_EPS\\r\\n | cv2.TERM_CRITERIA_COUNT, 10, 1)\\r\\n\\r\\n track_box, track_window = cv2.CamShift(\\r\\n prob, track_window, term_crit)\\r\\n\\r\\n track_x0 = track_window[0]\\r\\n track_y0 = track_window[1]\\r\\n track_w = track_window[2]\\r\\n track_h = track_window[3]\\r\\n\\r\\n # Check size of track window\\r\\n if ((track_w <= min_size_width)\\r\\n or (track_h <= min_size_height)):\\r\\n\\r\\n break\\r\\n\\r\\n segment_frame_dict = {}\\r\\n\\r\\n track_list = (\\r\\n int(track_x0), int(track_y0), int(track_w),\\r\\n int(track_h))\\r\\n\\r\\n segment_frame_dict[c.TRACKING_BBOX_KEY] = track_list\\r\\n\\r\\n sub_faces = sub_det_dict[c.FACES_KEY]\\r\\n\\r\\n sub_face_counter = 0\\r\\n\\r\\n sim = False\\r\\n\\r\\n det_bbox = None\\r\\n\\r\\n for sub_face_dict in sub_faces:\\r\\n\\r\\n det_bbox = sub_face_dict[c.BBOX_KEY]\\r\\n\\r\\n # If track window corresponds to\\r\\n # a detected face,\\r\\n # delete detection from list\\r\\n\\r\\n (sim, int_area, int_area_pct) = utils.is_rect_similar(\\r\\n track_window, det_bbox, tracking_min_int_area)\\r\\n\\r\\n if sim:\\r\\n # det_face_counter = det_face_counter + 1\\r\\n\\r\\n track_window = det_bbox\\r\\n\\r\\n break\\r\\n\\r\\n sub_face_counter += 1\\r\\n\\r\\n t_x0 = track_window[0]\\r\\n t_y0 = track_window[1]\\r\\n t_w = track_window[2]\\r\\n t_h = track_window[3]\\r\\n\\r\\n segment_frame_dict[c.DETECTION_BBOX_KEY] = det_bbox\\r\\n\\r\\n # If a detected face corresponds to track window\\r\\n # delete detected face from detection list\\r\\n\\r\\n if sim:\\r\\n\\r\\n missed_det_counter = 0\\r\\n\\r\\n segment_frame_dict[c.DETECTED_KEY] = True\\r\\n\\r\\n segment_frame_dict[c.LEFT_EYE_POS_KEY] = (\\r\\n sub_face_dict[c.LEFT_EYE_POS_KEY])\\r\\n segment_frame_dict[c.RIGHT_EYE_POS_KEY] = (\\r\\n sub_face_dict[c.RIGHT_EYE_POS_KEY])\\r\\n\\r\\n segment_frame_dict[c.NOSE_POSITION_KEY] = (\\r\\n sub_face_dict[c.NOSE_POSITION_KEY])\\r\\n\\r\\n segment_frame_dict[c.ALIGNED_FACE_FILE_NAME_KEY] = (\\r\\n sub_face_dict[c.ALIGNED_FACE_FILE_NAME_KEY])\\r\\n\\r\\n del (detection_list[sub_frame_counter]\\r\\n [c.FACES_KEY][sub_face_counter])\\r\\n\\r\\n else:\\r\\n\\r\\n # Check if distance from last detection\\r\\n # is too big\\r\\n missed_det_counter += 1\\r\\n\\r\\n if missed_det_counter > max_fr_with_miss_det:\\r\\n\\r\\n # Remove last frames and\\r\\n # interrupt tracking\\r\\n for i in range(0, max_fr_with_miss_det):\\r\\n segment_frame_list.pop()\\r\\n\\r\\n segment_face_counter = (\\r\\n segment_face_counter - max_fr_with_miss_det)\\r\\n\\r\\n break\\r\\n\\r\\n segment_frame_dict[c.DETECTED_KEY] = False\\r\\n\\r\\n elapsed_ms = sub_det_dict[c.ELAPSED_VIDEO_TIME_KEY]\\r\\n\\r\\n # Update list of frames for segment\\r\\n segment_frame_dict[\\r\\n c.FRAME_COUNTER_KEY] = sub_frame_counter\\r\\n segment_frame_dict[\\r\\n c.ELAPSED_VIDEO_TIME_KEY] = elapsed_ms\\r\\n\\r\\n track_list = (\\r\\n int(t_x0), int(t_y0), int(t_w), int(t_h))\\r\\n\\r\\n segment_frame_dict[c.TRACKING_BBOX_KEY] = track_list\\r\\n segment_frame_dict[\\r\\n c.SAVED_FRAME_NAME_KEY] = sub_frame_name\\r\\n\\r\\n segment_frame_list.append(segment_frame_dict)\\r\\n\\r\\n del sub_image\\r\\n\\r\\n sub_frame_counter += 1\\r\\n\\r\\n segment_face_counter += 1\\r\\n\\r\\n # Segment must be considered only if its number\\r\\n # of frames is greater or equals than a minimum\\r\\n if segment_face_counter >= min_segment_frames:\\r\\n\\r\\n segments = self.divide_segment_by_face(\\r\\n segment_frame_list)\\r\\n\\r\\n if len(segments) > 0:\\r\\n self.tracked_faces.extend(segments)\\r\\n\\r\\n else:\\r\\n\\r\\n segment_dict = {c.FRAMES_KEY: segment_frame_list}\\r\\n\\r\\n self.disc_tracked_faces.append(segment_dict)\\r\\n\\r\\n # Check histograms of detected faces and\\r\\n # divide segment accordingly\\r\\n\\r\\n face_counter += 1\\r\\n\\r\\n frame_counter += 1\\r\\n\\r\\n # Create directory for this video\\r\\n\\r\\n if not (os.path.exists(self.track_path)):\\r\\n os.makedirs(self.track_path)\\r\\n\\r\\n # Save tracking result in YAML file\\r\\n utils.save_YAML_file(self.track_file_path, self.tracked_faces)\\r\\n\\r\\n # Save processing time\\r\\n time_in_clocks = cv2.getTickCount() - start_time\\r\\n time_in_seconds = time_in_clocks / cv2.getTickFrequency()\\r\\n\\r\\n print 'Time for face tracking:', time_in_seconds, 's\\\\n'\\r\\n logger.debug('Time for face tracking:', time_in_seconds, 's\\\\n')\\r\\n\\r\\n self.anal_times[c.FACE_TRACKING_TIME_KEY] = time_in_seconds\\r\\n\\r\\n utils.save_YAML_file(self.analysis_file_path, self.anal_times)\",\n \"def crop_faces(cv_imgs, only_one=True, using_bundled_library=False):\\n faces_coords = []\\n\\n if using_bundled_library:\\n for image in cv_imgs:\\n coords = face_recognition.face_locations(image)\\n coords = [(y2, x1, y1 - y2, x2 - x1) for x1, y1, x2, y2 in coords]\\n faces_coords.append(coords)\\n return faces_coords\\n\\n img_with_several_faces = 0\\n img_with_no_face = 0\\n img_with_one_face = 0\\n for index, image in enumerate(cv_imgs):\\n faceCascade = cv2.CascadeClassifier(cv2.data.haarcascades + \\\"haarcascade_frontalface_default.xml\\\")\\n faces = faceCascade.detectMultiScale(\\n image,\\n scaleFactor=1.01,\\n minNeighbors=5,\\n minSize=(200, 200)\\n )\\n\\n if only_one:\\n if len(faces) == 1:\\n img_with_one_face += 1\\n (x, y, w, h) = faces[0]\\n faces_coords.append((x, y, w, h))\\n else:\\n faces_coords.append(None)\\n if len(faces) == 0:\\n img_with_no_face += 1\\n else:\\n img_with_several_faces += 1\\n else:\\n faces_coords.append(faces)\\n\\n return faces_coords\",\n \"def faces(self):\\r\\n return self._faces\",\n \"def face_detector( img_path, face_cascade):\\n img = cv2.imread( img_path )\\n gray = cv2.cvtColor( img, cv2.COLOR_BGR2GRAY )\\n faces = face_cascade.detectMultiScale( gray )\\n if len( faces ) > 0:\\n return True\\n else:\\n return False\",\n \"def parse(self):\\n imset = []\\n imdir = remkdir(os.path.join(self._datadir, 'images'))\\n csv_actors = readcsv(os.path.join(self._datadir, 'facescrub_actors.txt'), separator='\\\\t')\\n for (subjectname, imageid, faceid, url, bbox, sha256) in csv_actors[1:]:\\n categoryname = subjectname.replace(' ', '_')\\n (xmin,ymin,xmax,ymax) = bbox.split(',')\\n imset.append(ImageDetection(url=url, filename=os.path.join(imdir, '%s_%s.jpg' % (categoryname, imageid)), category=categoryname, xmin=xmin, ymin=ymin, xmax=xmax, ymax=ymax, attributes={'GENDER':'male'}))\\n\\n csv_actresses = readcsv(os.path.join(self._datadir, 'facescrub_actresses.txt'), separator='\\\\t')\\n for (subjectname, imageid, faceid, url, bbox, sha256) in csv_actresses[1:]:\\n categoryname = subjectname.replace(' ', '_')\\n (xmin,ymin,xmax,ymax) = bbox.split(',')\\n imset.append(ImageDetection(url=url, filename=os.path.join(imdir, '%s_%s.jpg' % (categoryname, imageid)), category=categoryname, xmin=xmin, ymin=ymin, xmax=xmax, ymax=ymax, attributes={'GENDER':'female'}))\\n\\n return imset\",\n \"def add_image_face():\\n\\n try:\\n img = decode_image(request.files[\\\"image\\\"].read())\\n except Exception as e:\\n log.error(e)\\n data = {\\\"error\\\": \\\"Error while loading image\\\"}\\n return jsonify(data), 500\\n save_picture = False\\n if request.args.get(\\\"save\\\") == \\\"true\\\":\\n save_picture = True\\n \\n face_img, _ = processor.extract_faces()\\n #TODO\\n #1. get several images if possible\\n #2. save face_img array as picture if save_picture == True\\n #3. pipe face_img array to embedder --> embedder needs to be modified to not from a folder, but from array of face_img\\n #4. get the embedder result, insert to a pickle object --> can be section ID, or whatever\",\n \"def face_detector(img_path: str):\\r\\n img = cv2.imread(img_path)\\r\\n\\r\\n # if no image at that path, return False\\r\\n if img is None:\\r\\n return False\\r\\n\\r\\n # convert to grey\\r\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\r\\n\\r\\n # detect faces. If no face detected, it's empty and len(faces) will be 0\\r\\n faces = face_cascade.detectMultiScale(gray)\\r\\n return len(faces) > 0\",\n \"def get_encoded_faces():\\r\\n encoded = {}\\r\\n\\r\\n for dirpath, dnames, fnames in os.walk(\\\"./faces\\\"):\\r\\n for f in fnames:\\r\\n if f.endswith(\\\".jpg\\\") or f.endswith(\\\".png\\\"):\\r\\n face = fr.load_image_file(\\\"faces/\\\" + f)\\r\\n encoding = fr.face_encodings(face)[0]\\r\\n encoded[f.split(\\\".\\\")[0]] = encoding\\r\\n\\r\\n return encoded\",\n \"def get_faces():\\n detected_faces = request()\\n\\n if not detected_faces:\\n raise FaceNotDetectedError()\\n return detected_faces\",\n \"def get_faceboxes(self, image, threshold=0.5):\\r\\n rows, cols, _ = image.shape\\r\\n\\r\\n confidences = []\\r\\n faceboxes = []\\r\\n\\r\\n self.face_net.setInput(cv2.dnn.blobFromImage(\\r\\n image, 1.0, (300, 300), (104.0, 177.0, 123.0), False, False))\\r\\n detections = self.face_net.forward()\\r\\n\\r\\n for result in detections[0, 0, :, :]:\\r\\n confidence = result[2]\\r\\n if confidence > threshold:\\r\\n x_left_bottom = int(result[3] * cols)\\r\\n y_left_bottom = int(result[4] * rows)\\r\\n x_right_top = int(result[5] * cols)\\r\\n y_right_top = int(result[6] * rows)\\r\\n confidences.append(confidence)\\r\\n faceboxes.append(\\r\\n [x_left_bottom, y_left_bottom, x_right_top, y_right_top])\\r\\n\\r\\n self.detection_result = [faceboxes, confidences]\\r\\n\\r\\n return confidences, faceboxes\",\n \"def read_images(path, sz=None, cr=None):\\n c = 0\\n X,y = [], []\\n for dirname, dirnames, filenames in os.walk(path):\\n for subdirname in dirnames:\\n subject_path = os.path.join(dirname, subdirname)\\n for filename in os.listdir(subject_path):\\n\\n if filename.endswith('.jpg'):\\n try:\\n im = cv2.imread(os.path.join(subject_path, filename), cv2.IMREAD_GRAYSCALE)\\n #print os.path.join(subject_path, filename)\\n # crop the image on the face\\n if (cr is not None):\\n rect, img = detect(im)\\n if len(rect) == 0:\\n return [None,None]\\n im = img[rect[0][1]:rect[0][3], rect[0][0]:rect[0][2]]\\n \\n #im = Image.fromarray(img)\\n # resize to given size (if given)\\n if (sz is not None):\\n #print im, sz\\n im = cv2.resize(im, sz)\\n cv2.imwrite('../data_pictures/prova'+str(c)+'.jpg',im)\\n X.append(np.asarray(im, dtype=np.uint8))\\n y.append(c)\\n except IOError, (errno, strerror):\\n print \\\"I/O error({0}): {1}\\\".format(errno, strerror)\\n except:\\n print \\\"Unexpected error:\\\", sys.exc_info()[0]\\n raise\\n\\n\\n c = c+1\\n return [X,y]\",\n \"def detect_face_api(self, img):\\n\\n curr_face_loc, name_list, info_list = load_encode_loc(img, self.kwn_names,\\n self.kwn_encoding,\\n self.status_list, self.since_list)\\n print('Current value is ', curr_face_loc, name_list)\\n face_list = []\\n face_area = []\\n print('face loc', curr_face_loc)\\n if len(curr_face_loc):\\n\\n for (top, right, bottom, left), name in zip(curr_face_loc, name_list):\\n print(top, right, bottom, left)\\n cv2.rectangle(img, (top, right), (bottom, left), (0, 255, 2), 2)\\n\\n w = right - left\\n h = bottom - top\\n cx = left + w // 2\\n cy = top + h // 2\\n area = w * h\\n\\n for idx, info in enumerate(info_list):\\n cv2.putText(img, info, (bottom, int(left * idx * 0.2)),\\n cv2.FONT_HERSHEY_COMPLEX, 1,\\n (0, 0, 255), 1)\\n\\n face_list.append([cx, cy])\\n face_area.append(area)\\n\\n i = face_area.index(max(face_area))\\n\\n return img, [face_list[i], face_area[i]]\\n\\n else:\\n return img, [[0, 0], 0]\",\n \"def detectObjects(image):\\n\\tgrayscale = cvCreateImage(cvSize(image.width, image.height), 8, 1)\\n\\tcvCvtColor(image, grayscale, CV_BGR2GRAY)\\n\\n\\tstorage = cvCreateMemStorage(0)\\n\\tcvClearMemStorage(storage)\\n\\tcvEqualizeHist(grayscale, grayscale)\\n\\tcascade = cvLoadHaarClassifierCascade(\\n\\t\\t'/usr/share/opencv/haarcascades/haarcascade_frontalface_default.xml',\\n\\t\\tcvSize(1,1))\\n\\n\\tscalefactor = 1.1 # How much to increase window size each pass\\n\\tminsize = 50 # Smallest face to detect. Up this if you have small falsepositives\\n\\tfaces = cvHaarDetectObjects(grayscale, cascade, storage, scalefactor, 50,\\n\\t\\t\\t\\tCV_HAAR_DO_CANNY_PRUNING, cvSize(minsize, minsize))\\n\\n\\treturn [(f.x, f.y, f.x + f.width, f.y + f.height) for f in faces]\",\n \"def face_detection_image(self, image_path):\\n body = {'file': (image_path, open(image_path, 'rb'), \\\"multipart/form-data\\\")}\\n url = self.base_url + '/vision-service/phoenix-vision/face-detection/image'\\n headers = {\\\"ApiKey\\\": self.api_key}\\n response = requests.post(url=url, files=body, headers=headers).text\\n return response\",\n \"def find_candidate_images(images_path):\\n images = []\\n for root, dirs, files in os.walk(images_path):\\n for name in files:\\n file_path = os.path.abspath(os.path.join(root, name))\\n if (os.path.splitext(name)[1]).lower() in [\\\".jpg\\\", \\\".png\\\", \\\".jpeg\\\"]:\\n images.append(file_path)\\n return images\",\n \"def detect(img, cascade, settings):\\n # Parameters taken verbatim from OpenCV 2.4 example:\\n # https://github.com/opencv/opencv/blob/2.4/samples/python2/facedetect.py\\n rects = cascade.detectMultiScale(img, \\n **settings)\\n\\n if len(rects) == 0:\\n return []\\n\\n print(rects)\\n\\n # Turn width and height of box\\n # into plot-ready image coordinates.\\n # rects contains (x,y),(w,h), return (x,y),(x+w,x+h)\\n\\n rects[:,2:] += rects[:,:2]\\n return rects\",\n \"def find_faces(self, img: Array3D, det_prob_threshold: float = None) -> List[BoundingBoxDTO]:\\n raise NotImplementedError\",\n \"def imageFileProcessor(path):\\n # Show all files in RawCapturedPicture\\n # ..., and get the completed path files\\n img_paths = []\\n for ea in o_tl.showAllFiles(path):\\n img_paths.append(os.path.join(path, ea))\\n\\n # Empty face list\\n faces = []\\n # Empty ID list\\n IDs = []\\n\\n # Looping through all the image paths and loading the IDs and the faces\\n for each_path in img_paths:\\n # Loading the image and converting it to gray scale\\n pil_img = Image.open(each_path).convert('L')\\n # Converting the PIL image into numpy array\\n image_numpy = np.array(pil_img, 'uint8')\\n # Getting the Id from the image\\n Id = int(os.path.split(each_path)[-1].split(\\\"_\\\")[1])\\n # Extract the face from the training image sample\\n faces.append(image_numpy)\\n IDs.append(Id)\\n return faces, IDs\",\n \"def make_face_recognition(update: Update, _: CallbackContext) -> None:\\n # message.photo is a list of PhotoSize objects,\\n # which represent different sizes of the same photo\\n\\n # print(\\\"Enter to make_face_recognition\\\")\\n img_from_user = update.message.photo[-1].get_file()\\n img_file = io.BytesIO()\\n img_from_user.download(out=img_file)\\n img_array = face_recognition.load_image_file(img_file)\\n # Find all the faces in the image\\n face_locations = face_recognition.face_locations(img_array)\\n # print(face_locations)\\n img_with_rects = _make_rects(img_array, face_locations)\\n out_file = 'tmp.jpg'\\n Image.fromarray(img_with_rects, 'RGB').save(out_file, format=\\\"JPEG\\\")\\n update.message.bot.send_photo(\\n update.message.chat_id,\\n photo=open(out_file, 'rb'))\",\n \"def recognize_faces(x_img,\\n knn_clf=None,\\n model_path=None,\\n distance_threshold=0.3):\\n print(\\\"Start recognize\\\")\\n # Making a check\\n if knn_clf is None and model_path is None:\\n raise Exception(\\\"Must supply knn classifier either thought knn_clf or model_path\\\")\\n\\n # Load a trained KNN model (if one was passed in)\\n if knn_clf is None:\\n with open(model_path, 'rb') as f:\\n knn_clf = pickle.load(f)\\n\\n # Load image file and find face locations\\n x_face_locations = face_recognition.face_locations(x_img)\\n # Set variable for changes on camera (if connected) check\\n # x_face_locations_len = 0\\n\\n # If no faces are found in the image, return an empty result\\n if len(x_face_locations) == 0:\\n return []\\n \\n\\n # Checking for changes on camera (if connected)\\n # if len(x_face_locations) != x_face_locations_len:\\n # Find encodings for faces in the test iamge\\n faces_encodings = face_recognition.face_encodings(x_img, known_face_locations=x_face_locations)\\n # Use the KNN model to find the best matches for the test face\\n closest_distances = knn_clf.kneighbors(faces_encodings, n_neighbors=1)\\n are_matches = [closest_distances[0][i][0] <= distance_threshold for i in range(len(x_face_locations))]\\n accur_list = [1-closest_distances[0][i][0] for i in range(len(x_face_locations))]\\n x_face_locations_len = len(x_face_locations)\\n # Predict classes and remove classifications that aren't within the threshold\\n return [(pred, loc, accur, rec) if rec else (\\\"unknown\\\", loc, 0,0) for pred, loc, accur, rec in\\n zip(knn_clf.predict(faces_encodings),\\n x_face_locations,\\n accur_list,\\n are_matches)]\",\n \"async def detect_face(face_file, max_results=4):\\n image_content = face_file.read()\\n batch_request = [{\\n 'image': {\\n 'content': base64.b64encode(image_content).decode('utf-8')\\n },\\n 'features': [{\\n 'type': 'FACE_DETECTION',\\n 'maxResults': max_results,\\n }]\\n }]\\n\\n service = get_vision_service()\\n request = service.images().annotate(body={\\n 'requests': batch_request,\\n })\\n loop = asyncio.get_event_loop()\\n response = await loop.run_in_executor(None, request.execute)\\n\\n return response['responses'][0]['faceAnnotations'] if 'faceAnnotations' in response['responses'][0] else None\",\n \"def get_filtered_faces(self, faces):\\n filtered_faces = []\\n for face in faces:\\n i, j, k = face\\n thresh = 100.0\\n if self.get_distance_between_points(i, j) > thresh:\\n continue\\n elif self.get_distance_between_points(j, k) > thresh:\\n continue\\n elif self.get_distance_between_points(i, k) > thresh:\\n continue\\n filtered_faces.append(face)\\n return filtered_faces\",\n \"def save_faces(img, faces, width, height):\\n\\n for i, (x, y, w, h) in enumerate(faces):\\n # TODO: Change output string\\n save_image(resize_img(img[y:y+h, x:x+w], width, height), 'out' + str(i) + '.jpg')\",\n \"def detectFacesWithRectangle(img, faces):\\n\\n for (x, y, w, h) in faces:\\n cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 3)\",\n \"def get_data(self):\\n global CAM\\n count = 0\\n while CAM.isOpened():\\n count += 1\\n print('COUNT' + str(count))\\n _, frame = CAM.read()\\n\\n # cropped face\\n cropped_face, bbox_coordinate, anchor_coordinate = detect_faces(frame)\\n if cropped_face is None:\\n print(\\\"NONE FACE DETECTED\\\")\\n sleep(1)\\n continue\\n\\n # get fake face\\n fake_face, profile_feature_vector = generate_frontal_face(cropped_face)\\n\\n cropped_face = cv2.cvtColor(cropped_face, cv2.COLOR_BGR2RGB)\\n fake_face = cv2.cvtColor(fake_face, cv2.COLOR_BGR2RGB)\\n\\n # face matching\\n face_matcher = FaceMatcher()\\n matched_face, matched_name, matched_front_fake_face, matched_diff = \\\\\\n face_matcher.match(cropped_face, fake_face, profile_feature_vector)\\n\\n matched_face = cv2.cvtColor(matched_face, cv2.COLOR_BGR2RGB)\\n matched_front_fake_face = cv2.cvtColor(matched_front_fake_face, cv2.COLOR_BGR2RGB)\\n\\n _, cropped_face_jpeg = cv2.imencode('.jpg', cropped_face)\\n _, fake_face_jpeg = cv2.imencode('.jpg', fake_face)\\n _, matched_face_jpeg = cv2.imencode('.jpg', matched_face)\\n _, matched_front_fake_face_jpeg = cv2.imencode('.jpg', matched_front_fake_face)\\n\\n encoded_cropped_face = \\\"data:image/jpg;base64,\\\" + str(\\n base64.b64encode(cropped_face_jpeg.tobytes()).decode())\\n encoded_fake_face = \\\"data:image/jpg;base64,\\\" + str(\\n base64.b64encode(fake_face_jpeg.tobytes()).decode())\\n\\n encoded_matched_face = \\\"data:image/jpg;base64,\\\" + str(\\n base64.b64encode(matched_face_jpeg.tobytes()).decode())\\n encoded_matched_front_fake_face = \\\"data:image/jpg;base64,\\\" + str(\\n base64.b64encode(matched_front_fake_face_jpeg.tobytes()).decode())\\n\\n # get detection model return here and send to face frontalization model\\n SIO.emit('detection', {'cropped_face': encoded_cropped_face,\\n 'fake_face': encoded_fake_face,\\n 'matched_face': encoded_matched_face,\\n 'matched_name': matched_name,\\n 'matched_front_fake_face': encoded_matched_front_fake_face,\\n 'id': uuid.uuid4().hex},\\n namespace='/detections')\\n sleep(self.delay)\",\n \"def _detect_face_ResNet10_SSD(self, img):\\n\\n detector = self.detector\\n (h, w) = img.shape[:2]\\n # construct a blob from the image\\n img_blob = cv2.dnn.blobFromImage(\\n cv2.resize(img, (300, 300)),\\n 1.0,\\n (300, 300),\\n (104.0, 177.0, 123.0),\\n swapRB=False,\\n crop=False,\\n )\\n\\n detector.setInput(img_blob)\\n detections = detector.forward()\\n\\n (start_x, start_y, end_x, end_y) = (0, 0, 0, 0)\\n faces_bb = []\\n if len(detections) > 0:\\n # we're making the assumption that each image has only ONE\\n # face, so find the bounding box with the largest probability\\n for i in range(0, detections.shape[2]):\\n\\n score = detections[0, 0, i, 2]\\n\\n # ensure that the detection greater than our threshold is\\n # selected\\n if score > self.confidence:\\n # compute the (x, y)-coordinates of the bounding box for\\n # the face\\n box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])\\n box = box.astype(\\\"int\\\")\\n (start_x, start_y, end_x, end_y) = box\\n\\n # print(\\\"start x : {}\\\".format(start_x))\\n # print(\\\"start y : {}\\\".format(start_y))\\n # print(\\\"end x : {}\\\".format(end_x))\\n # print(\\\"end y : {}\\\".format(end_y))\\n\\n # extract the face ROI and grab the ROI dimensions\\n face = img[start_y:end_y, start_x:end_x]\\n\\n (fh, fw) = face.shape[:2]\\n # ensure the face width and height are sufficiently large\\n if fw < 20 or fh < 20:\\n pass\\n else:\\n faces_bb.append(box)\\n\\n if len(faces_bb) > 0:\\n faces_bb = np.array(faces_bb)\\n\\n return faces_bb\",\n \"def process_image(file_path):\\n img_array = io.imread(file_path)\\n detections, shapes, descriptors = detect_faces(person_database,img_array)\\n\\n names = []\\n\\n for desc in descriptors:\\n name = find_match(person_database, desc)\\n names.append(name)\\n\\n return pic_array, names, detections, shapes, descriptors\",\n \"def classify_face(im):\\r\\n faces = get_encoded_faces()\\r\\n faces_encoded = list(faces.values())\\r\\n known_face_names = list(faces.keys())\\r\\n\\r\\n img = cv2.imread(im, 1)\\r\\n \\\"\\\"\\\"\\r\\n Resize optinal \\r\\n \\\"\\\"\\\"\\r\\n #img = cv2.resize(img, (0, 0), fx=0.5, fy=0.5)\\r\\n #img = img[:,:,::-1]\\r\\n face_locations = face_recognition.face_locations(img)\\r\\n unknown_face_encodings = face_recognition.face_encodings(img, face_locations)\\r\\n\\r\\n face_names = []\\r\\n for face_encoding in unknown_face_encodings:\\r\\n # See if the face is a match for the known face(s)\\r\\n matches = face_recognition.compare_faces(faces_encoded, face_encoding)\\r\\n name = \\\"Unknown\\\"\\r\\n\\r\\n # use the known face with the smallest distance to the new face\\r\\n face_distances = face_recognition.face_distance(faces_encoded, face_encoding)\\r\\n best_match_index = np.argmin(face_distances)\\r\\n if matches[best_match_index]:\\r\\n name = known_face_names[best_match_index]\\r\\n\\r\\n face_names.append(name)\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n All the photo lables in the faces foler end with (number) so a simiple .find(\\\"(\\\") command takes the () away from\\r\\n the label leaving us with the full name of the person\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n result = name.find('(') \\r\\n fullname = (name[:result])\\r\\n \\\"\\\"\\\"\\r\\n If face_recogntion module recognizes a face but that face is not in the faces module then \\r\\n it will print unknown and we print 12345678 to use it on the start attednace program \\r\\n\\r\\n \\\"\\\"\\\"\\r\\n if (name == \\\"Unknown\\\"):\\r\\n print(\\\"12345678\\\")\\r\\n else:\\r\\n \\\"\\\"\\\"\\r\\n f'{len(face_locayion)}-people - will return the number of people in photo taken by Nao'\\r\\n \\\"\\\"\\\"\\r\\n print (f'{len(face_locations)}-people')\\r\\n print (fullname)\\r\\n print(courseid)\\r\\n print (lateornot)\\r\\n c34 = fullname.find(' ')\\r\\n firstname = (fullname[:c34])\\r\\n lastname = (fullname[c34:])\\r\\n \\\"\\\"\\\"\\r\\n We get all the data courseid , fristname , lastname, datetime1,and late or not and submited on the website \\r\\n \\r\\n\\r\\n \\\"\\\"\\\"\\r\\n login_data = {\\r\\n\\t 'Course': courseid,\\r\\n\\t 'FirstName': firstname,\\r\\n\\t 'LastName': lastname,\\r\\n\\t 'Date': datetime2,\\r\\n\\t 'Attendance': 'on',\\r\\n\\t 'Late': latev,\\r\\n\\t 'submitbutton': 'Submit'\\r\\n }\\r\\n if(fullname == \\\"Unknow\\\"):\\r\\n \\tprint(\\\"I-dont-know-you\\\")\\r\\n else:\\r\\n \\r\\n with requests.Session() as s:\\r\\n \\turl = \\\"https://rbattendance.000webhostapp.com/update.php\\\"\\r\\n \\tr = s.get(url)\\r\\n \\tsoup = BeautifulSoup(r.content, 'html5lib')\\r\\n \\tr = s.post(url, data = login_data)\\r\\n \\t#print(r.content)\\r\\n \\r\\n \\r\\n\\r\\n\\r\\n\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n This for loop is reponsible for drawing on the image \\r\\n \\\"\\\"\\\"\\r\\n\\r\\n for (top, right, bottom, left), name in zip(face_locations, face_names):\\r\\n # Draw a box around the face\\r\\n cv2.rectangle(img, (left-20, top-20), (right+20, bottom+20), (255, 0, 0), 2)\\r\\n\\r\\n # Draw a label with a name below the face\\r\\n cv2.rectangle(img, (left-20, bottom -15), (right+20, bottom+20), (255, 0, 0), cv2.FILLED)\\r\\n font = cv2.FONT_HERSHEY_DUPLEX\\r\\n cv2.putText(img, name, (left -20, bottom + 15), font, 1.0, (255, 255, 255), 2)\\r\\n\\r\\n\\r\\n # Display the resulting image\\r\\n \\r\\n \\r\\n while True:\\r\\n #cv2.imshow('Video', img)\\r\\n #if cv2.waitKey(1) & 0xFF == ord('q'):\\r\\n return face_names\",\n \"def scan_images(images, clf, first_index, vstep=15, hstep=15, dnum=5):\\n detections = []\\n for i in tqdm(range(len(images))):\\n labels = find_faces(util.img_as_float(rgb2gray(images[i])), clf, first_index + i,\\n vstep, hstep, dnum)\\n for label in labels:\\n detections.append(label)\\n return np.array(detections)\",\n \"def _get_images_and_labels(self, path: str, user_id: int):\\n\\n image_paths = [os.path.join(path, f) for f in os.listdir(path)]\\n face_samples = []\\n ids = []\\n\\n for imagePath in image_paths:\\n\\n pil_image = Image.open(imagePath).convert('L') # convert it to grayscale\\n img_numpy = np.array(pil_image, 'uint8')\\n\\n faces = self.detector.detectMultiScale(img_numpy)\\n\\n for (x, y, w, h) in faces:\\n face_samples.append(img_numpy[y:y + h, x:x + w])\\n ids.append(user_id)\\n\\n return face_samples, ids\",\n \"def detect_faces_in_video(self):\\r\\n logger.debug('Executing face detection')\\r\\n\\r\\n use_eyes_position = c.USE_EYES_POSITION\\r\\n\\r\\n if ((self.params is not None) and\\r\\n (c.USE_EYES_POSITION_KEY in self.params)):\\r\\n use_eyes_position = self.params[c.USE_EYES_POSITION_KEY]\\r\\n\\r\\n det_loaded = False\\r\\n\\r\\n # Try to load YAML file with detection results\\r\\n if os.path.exists(self.det_file_path):\\r\\n\\r\\n print 'Loading YAML file with detection results'\\r\\n logger.debug('Loading YAML file with detection results')\\r\\n\\r\\n det_faces = utils.load_YAML_file(self.det_file_path)\\r\\n\\r\\n if det_faces:\\r\\n self.detected_faces = det_faces\\r\\n\\r\\n print 'YAML file with detection results loaded'\\r\\n logger.debug('YAML file with detection results loaded')\\r\\n\\r\\n det_loaded = True\\r\\n\\r\\n if not det_loaded:\\r\\n\\r\\n # Check existence of frame list\\r\\n if len(self.frame_list) == 0:\\r\\n\\r\\n # Try to load YAML file with frame list\\r\\n if os.path.exists(self.frames_file_path):\\r\\n\\r\\n print 'Loading YAML file with frame list'\\r\\n logger.debug('Loading YAML file with frame list')\\r\\n\\r\\n f_list = utils.load_YAML_file(self.frames_file_path)\\r\\n\\r\\n if f_list:\\r\\n\\r\\n self.frame_list = f_list\\r\\n\\r\\n print 'YAML file with frame list loaded'\\r\\n logger.debug('YAML file with frame list loaded')\\r\\n\\r\\n else:\\r\\n\\r\\n print 'Warning! Error in loading file!'\\r\\n logger.warning('Error in loading file!')\\r\\n\\r\\n else:\\r\\n\\r\\n print 'Warning! No frame list found!'\\r\\n logger.warning('No frame list found!')\\r\\n\\r\\n return\\r\\n\\r\\n print '\\\\n\\\\n### Face detection ###\\\\n'\\r\\n logger.debug('\\\\n\\\\n### Face detection ###\\\\n')\\r\\n\\r\\n # Save processing time\\r\\n start_time = cv2.getTickCount()\\r\\n\\r\\n if not (os.path.exists(self.det_path)):\\r\\n # Create directory for this video\\r\\n\\r\\n os.makedirs(self.det_path)\\r\\n\\r\\n if not (os.path.exists(self.align_path)):\\r\\n # Create directory with aligned faces\\r\\n\\r\\n os.makedirs(self.align_path)\\r\\n\\r\\n frame_counter = 0\\r\\n self.detected_faces = []\\r\\n\\r\\n detection_results = []\\r\\n\\r\\n # Build list of frame names, frame paths and elapsed time\\r\\n frame_name_list = []\\r\\n\\r\\n frame_path_list = []\\r\\n\\r\\n elapsed_s_list = []\\r\\n\\r\\n for frame_dict in self.frame_list:\\r\\n frame_name = frame_dict[c.SAVED_FRAME_NAME_KEY]\\r\\n\\r\\n frame_name_list.append(frame_name)\\r\\n\\r\\n frame_path = os.path.join(self.frames_path, frame_name)\\r\\n\\r\\n frame_path_list.append(frame_path)\\r\\n\\r\\n elapsed_s = frame_dict[c.ELAPSED_VIDEO_TIME_KEY]\\r\\n\\r\\n elapsed_s_list.append(elapsed_s)\\r\\n\\r\\n # Iterate through frame paths in list\\r\\n for frame_path in frame_path_list:\\r\\n self.progress = 100 * (frame_counter / self.saved_frames)\\r\\n\\r\\n print('progress: ' + str(self.progress) + ' % \\\\r'),\\r\\n\\r\\n detection_result = fd.detect_faces_in_image(\\r\\n frame_path, self.align_path, self.params, False)\\r\\n\\r\\n detection_results.append(detection_result)\\r\\n\\r\\n frame_counter += 1\\r\\n\\r\\n frame_counter = 0\\r\\n\\r\\n # Iterate through detection results\\r\\n for detection_result in detection_results:\\r\\n\\r\\n detection_error = detection_result[c.ERROR_KEY]\\r\\n\\r\\n detection_dict = {\\r\\n c.SAVED_FRAME_NAME_KEY: frame_name_list[frame_counter],\\r\\n c.FRAME_COUNTER_KEY: frame_counter}\\r\\n\\r\\n elapsed_s = elapsed_s_list[frame_counter]\\r\\n\\r\\n detection_dict[c.ELAPSED_VIDEO_TIME_KEY] = elapsed_s\\r\\n\\r\\n faces = []\\r\\n if not detection_error:\\r\\n\\r\\n det_faces = detection_result[c.FACES_KEY]\\r\\n\\r\\n for det_face in det_faces:\\r\\n\\r\\n face_dict = {c.BBOX_KEY: det_face[c.BBOX_KEY]}\\r\\n\\r\\n if use_eyes_position:\\r\\n face_dict[c.LEFT_EYE_POS_KEY] = (\\r\\n det_face[c.LEFT_EYE_POS_KEY])\\r\\n\\r\\n face_dict[c.RIGHT_EYE_POS_KEY] = (\\r\\n det_face[c.RIGHT_EYE_POS_KEY])\\r\\n\\r\\n face_dict[c.NOSE_POSITION_KEY] = (\\r\\n det_face[c.NOSE_POSITION_KEY])\\r\\n\\r\\n face_dict[c.ALIGNED_FACE_FILE_NAME_KEY] = (\\r\\n det_face[c.ALIGNED_FACE_FILE_NAME_KEY])\\r\\n\\r\\n faces.append(face_dict)\\r\\n\\r\\n detection_dict[c.FACES_KEY] = faces\\r\\n\\r\\n self.detected_faces.append(detection_dict)\\r\\n\\r\\n frame_counter += 1\\r\\n\\r\\n # Save detection results in YAML file\\r\\n\\r\\n utils.save_YAML_file(self.det_file_path, self.detected_faces)\\r\\n\\r\\n time_in_clocks = cv2.getTickCount() - start_time\\r\\n time_in_seconds = time_in_clocks / cv2.getTickFrequency()\\r\\n\\r\\n print 'Time for face detection: ', time_in_seconds, 's\\\\n'\\r\\n logger.debug('Time for face detection: ', time_in_seconds, 's\\\\n')\\r\\n\\r\\n self.anal_times[c.FACE_DETECTION_TIME_KEY] = time_in_seconds\\r\\n\\r\\n utils.save_YAML_file(self.analysis_file_path, self.anal_times)\",\n \"def train():\\n face_recognizer = cv2.face.LBPHFaceRecognizer_create()\\n \\n # Load all saved people\\n people = PersonModel.select()\\n\\n # List of face images\\n photos = []\\n # List of person IDs corresponding to images in photos[]\\n labels = []\\n\\n for person in people:\\n person_dataset_path = os.path.join(Constants.PATH_DATASET, \\\"person_{}\\\".format(person.id))\\n\\n if not os.path.exists(person_dataset_path):\\n continue\\n\\n # List of all images for current person\\n photo_files = [os.path.join(person_dataset_path, item) for item in os.listdir(person_dataset_path)]\\n person.update(photos_count=len(photo_files)).execute()\\n\\n # Load all photos\\n for photo_file in photo_files:\\n photos.append(\\n np.array(Image.open(photo_file).convert(\\\"L\\\"))\\n )\\n \\n labels.append(person.id)\\n\\n face_recognizer.train(photos, np.array(labels))\\n\\n if not face_recognizer.write(Constants.FILE_MODEL):\\n return False\\n\\n return True\",\n \"def _raw_face_locations(img, number_of_times_to_upsample=1, model=\\\"hog\\\"):\\n if model == \\\"cnn\\\":\\n cnn_face_detector = dlib.cnn_face_detection_model_v1('mmod_human_face_detector.dat')\\n return cnn_face_detector(img, number_of_times_to_upsample)\\n else:\\n # face_detector = dlib.get_frontal_face_detector()\\n return face_detector(img, number_of_times_to_upsample)\",\n \"def compare_faces(file1, file2):\\n # Load the jpg files into numpy arrays\\n image1 = fr.load_image_file(file1)\\n image2 = fr.load_image_file(file2)\\n\\n # Get the face encodings for each face in each image file\\n # Assume there is only 1 face in each image, so get 1st face of an image.\\n image1_encoding = fr.face_encodings(image1)[0]\\n image2_encoding = fr.face_encodings(image2)[0]\\n\\n # results is an array of True/False telling if the unknown face matched anyone in the known_faces array\\n results = fr.compare_faces([image1_encoding], image2_encoding, tolerance=0.5)\\n return results[0]\",\n \"def read_image():\\n images = []\\n for hand in os.listdir('images'):\\n img = cv2.imread(os.path.join('images', hand))\\n if img is not None:\\n images.append(img)\\n return images\",\n \"def detect_face(image):\\n cascadePath = \\\"haarcascade_frontalface_default.xml\\\"\\n faceCascade = cv2.CascadeClassifier(cascadePath)\\n faces = faceCascade.detectMultiScale(image)\\n if len(faces)>=1:#Should be == , not >=\\n return True\\n return False\",\n \"def update(self,image):\\r\\n \\r\\n self._faces=[]\\r\\n \\r\\n if util.isgray(image):\\r\\n image=cv2.equalizeHist(image)\\r\\n \\r\\n else:\\r\\n \\r\\n image=cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)\\r\\n cv2.equalizeHist(image,image)\\r\\n \\r\\n minsize=util.widthheightdividedby(image,8)\\r\\n\\r\\n \\r\\n\\r\\n \\r\\n facerect=self._faceclassifier.detectMultiScale(image,\\r\\n self.scalefactor,\\r\\n self.minneighbors,\\r\\n self.flags,\\r\\n minsize)\\r\\n \\r\\n \\\"\\\"\\\"if facerects is not None:\\r\\n \\r\\n for facerect in facerects:\\r\\n face=face()\\r\\n \\r\\n face.facerect=facerect\\r\\n \\r\\n \\r\\n x,y,w,h=facerect\\r\\n \\r\\n # Seek an eye in the upper-left part of the face. \\r\\n searchRect = (x+w/7, y, w*2/7, h/2) \\r\\n face.leftEyeRect = self._detectOneObject( \\r\\n self._eyeClassifier, image, searchRect, 64) \\r\\n \\r\\n \\r\\n \\r\\n # Seek an eye in the upper-right part of the face. \\r\\n searchRect = (x+w*4/7, y, w*2/7, h/2) \\r\\n face.rightEyeRect = self._detectOneObject( \\r\\n self._eyeClassifier, image, searchRect, 64) \\r\\n \\r\\n \\r\\n \\r\\n # Seek a nose in the middle part of the face. \\r\\n searchRect = (x+w/4, y+h/4, w/2, h/2) \\r\\n face.noseRect = self._detectOneObject( \\r\\n self._noseClassifier, image, searchRect, 32) \\r\\n \\r\\n # Seek a mouth in the lower-middle part of the face. \\r\\n searchRect = (x+w/6, y+h*2/3, w*2/3, h/3) \\r\\n face.mouthRect = self._detectOneObject( \\r\\n self._mouthClassifier, image, searchRect, 16) \\r\\n \\r\\n \\r\\n \\r\\n self._faces.append(face)\\r\\n\\r\\n \\r\\n \\r\\n def _detectoneobject(self,\\r\\n classifier,\\r\\n image,\\r\\n rect,\\r\\n imagesizetominsizeratio):\\r\\n \\r\\n x ,y ,w ,h=rect\\r\\n \\r\\n minsize=util.widthheightdividedby(image,\\r\\n imagesizetominsizeratio)\\r\\n \\r\\n subimage=image[y:y+h,x:x+w]\\r\\n \\r\\n subrect=classifier.dectectMultiScale(subimage,\\r\\n self.scalefactor,\\r\\n self.minneighbors,\\r\\n self.flags,\\r\\n minsize)\\r\\n \\r\\n if len(subrect)==0:\\r\\n return None\\r\\n \\r\\n subx,suby,subw,subh=subrects[0]\\r\\n \\r\\n return (x+subx,y+suby,w+subw,h+subh)\\r\\n \\r\\n \\\"\\\"\\\"\",\n \"def _raw_face_locations(img, number_of_times_to_upsample=1, model=\\\"hog\\\"):\\n\\tif model == \\\"cnn\\\":\\n\\t\\treturn cnn_face_detector(img, number_of_times_to_upsample)\\n\\telse:\\n\\t\\treturn face_detector(img, number_of_times_to_upsample)\",\n \"def read_images_from_single_face_profile(face_profile, face_profile_name_index, dim = (120, 120)):\\n index = 0\\n \\n print(face_profile)\\n for the_file in os.listdir(face_profile):\\n file_path = os.path.join(face_profile, the_file)\\n \\n print(file_path)\\n if file_path.endswith(\\\".png\\\") or file_path.endswith(\\\".jpg\\\") or file_path.endswith(\\\".jpeg\\\") or file_path.endswith(\\\".pgm\\\"):\\n \\n img = cv2.imread(file_path, 0)\\n # print(img.shape)\\n # cv2.waitKey(0)\\n img = cv2.resize(img, (120, 160))\\n cv2.imwrite(file_path, img)\\n \\n index += 1\\n\\n if index == 0 : \\n shutil.rmtree(face_profile)\\n logging.error(\\\"\\\\nThere exists face profiles without images\\\")\",\n \"def loading_faces(source_image_set_path, dest_image_set_path, source_image_set):\\n dimensions_of_img = find_dimensions_not_attentive_imgs\\n if 'attentive' in dest_image_set_path:\\n dimensions_of_img = find_dimensions_attentive_imgs\\n for image_name in source_image_set:\\n\\n # loading gray image\\n gray_image = cv2.imread(source_image_set_path + \\\"/\\\" + image_name, 0)\\n\\n # find co-ordinates of faces in images\\n y1, x2, y2, x1 = dimensions_of_img(*face_recognition.face_locations(gray_image)[0], np.shape(gray_image))\\n\\n # crop image and resize to particular dimension\\n crop_img = gray_image[y1:y2, x1:x2]\\n resize_crop_img = cv2.resize(crop_img, (int(dimension[0:3]), int(dimension[0:3])))\\n\\n # load images from source to destination directory\\n cv2.imwrite(dest_image_set_path + \\\"/\\\" + image_name, resize_crop_img)\",\n \"def face_detection_json(self, image_path):\\n body = {'file': (image_path, open(image_path, 'rb'), \\\"multipart/form-data\\\")}\\n url = self.base_url + '/vision-service/phoenix-vision/face-detection/json'\\n headers = {\\\"ApiKey\\\": self.api_key}\\n response = requests.post(url=url, files=body, headers=headers).json()\\n return response\",\n \"def _raw_face_locations(img, number_of_times_to_upsample=1):\\n return face_detector(img, number_of_times_to_upsample)\",\n \"def detectFaceAndClassify(faceNet, faceMaskClassifier, testImagePath, threshold):\\n # load the input test image from disk\\n image = cv2.imread(testImagePath)\\n # making a copy of image and finding the image spatial dimensions\\n orig = image.copy()\\n (h, w) = image.shape[:2]\\n\\n # construct a blob from the image to pass to the network\\n # using standard weights for the face detection model for image preprocessing\\n blob = cv2.dnn.blobFromImage(image, 1.0, (300, 300), (104.0, 177.0, 123.0))\\n\\n # obtain the face detections by passing the blob through the network\\n print(\\\"computing face detections...\\\")\\n faceNet.setInput(blob)\\n faceDetections = faceNet.forward()\\n\\n # loop over the detections to classify them and form bounding boxes and labels\\n for i in range(0, faceDetections.shape[2]):\\n # extract only confident detections using the confidence/probability\\n # associated with the detection\\n confidence = faceDetections[0, 0, i, 2]\\n\\n # filter out weak detections by ensuring the confidence is\\n # greater than the minimum confidence 0.5 or input variable\\n if confidence > threshold:\\n # extract bounding box dimensions and face Region of intrest for classification\\n faceROI, startX, startY, endX, endY = extractBoxAndFaceROI(image, faceDetections, itemNum=i,\\n height=h, width=w)\\n\\n faceROI = np.expand_dims(faceROI, axis=0)\\n\\n # Passing the pre-processed image with classification model to check if there is a mask or not\\n (mask, withoutMask) = faceMaskClassifier.predict(faceROI)[0]\\n # (mask, withoutMask) = faceMaskClassifier.predict(faceROI)\\n\\n # find the class and associated colour to use for the bounding box and text\\n label = \\\"Mask\\\" if mask > withoutMask else \\\"No Mask\\\"\\n color = (0, 255, 0) if label == \\\"Mask\\\" else (0, 0, 255)\\n\\n # include the probability of prediction in the label of the bounding box\\n label = \\\"{}: {:.2f}%\\\".format(label, max(mask, withoutMask) * 100)\\n\\n # forming bounding box rectangle and display the label the output image frame\\n cv2.putText(image, label, (startX, startY - 10),\\n cv2.FONT_HERSHEY_COMPLEX, 0.45, color, 2)\\n cv2.rectangle(image, (startX, startY), (endX, endY), color, 2)\\n\\n # show the output image\\n cv2.imshow(\\\"Output\\\", image)\\n # display the image still a key is pressed, when key is pressed program is terminated\\n cv2.waitKey(0)\",\n \"def test_measurement_on_images(file_list):\\n test_details_list = []\\n for idx, file in enumerate(file_list):\\n dict_results = {}\\n image = cv2.imread(file)\\n FaceDetector().run(image, dict_results)\\n file_name = ntpath.basename(file)\\n is_there_face = \\\"True\\\" in file_name\\n test_details_list.append([file_name, is_there_face, dict_results[\\\"FaceDetector\\\"],\\n is_there_face == dict_results[\\\"FaceDetector\\\"]])\\n\\n # print test results in a readable table format\\n headers = ['File Name', 'Face Exist', 'Measurement Result', 'Test Result']\\n print(tabulate(test_details_list, headers))\",\n \"def extract_faces(frame_path, out_path, face_path, processes=1):\\n if os.path.exists(out_path):\\n msg = '[extract_faces] Skipping extraction since faces already exist at {}'\\n print(msg.format(out_path))\\n return\\n\\n from faceoff.faceswap_api import FaceSwapInterface\\n\\n os.makedirs(out_path)\\n print('[extract_faces] Starting on {}'.format(frame_path))\\n start_time = time.time()\\n\\n api = FaceSwapInterface()\\n api.extract(frame_path, out_path, face_path, processes)\",\n \"def face_scraper():\\n base_directory = pathlib.Path(__file__).parent.absolute()\\n test_or_train, is_target_face = ask_for_directory()\\n folders = ['test', 'train']\\n test_or_train = folders[test_or_train]\\n source_directory = os.path.join(base_directory, 'rawimages', test_or_train, str(is_target_face))\\n target_directory = os.path.join(base_directory, 'datasets', test_or_train, str(is_target_face))\\n print('The source folder is ' + source_directory)\\n print('The target folder is ' + target_directory)\\n print('Files before saving images:')\\n print(os.listdir(target_directory))\\n crop_and_save_images(source_directory, target_directory)\\n print('Files after saving images:')\\n print(os.listdir(target_directory))\",\n \"def collect_image_files():\\n negs = [] # Non image files found\\n for filename in os.listdir('.'):\\n if filename.lower().endswith('.jpg') or filename.lower().\\\\\\n endswith('.jpeg'):\\n jpg_files.append(filename)\\n elif filename.lower().endswith('.gif'):\\n gif_files.append(filename)\\n elif filename.lower().endswith('.png'):\\n png_files.append(filename)\\n else:\\n negs.append(filename)\\n return negs\",\n \"def validate(model: str = \\\"hog\\\"):\\n for filepath in Path(\\\"validation\\\").rglob(\\\"*\\\"):\\n if filepath.is_file():\\n recognize_faces(\\n image_location=str(filepath.absolute()), model=model\\n )\",\n \"def _getface_cascade(self,img,mode):\\n gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\\n faces = self.model.detectMultiScale(gray, 1.3, 5)\\n if len(faces)==0:\\n return None\\n x,y,w,h = faces[0]\\n top, right, bottom, left = self._change_shape(x,y,w,h)\\n\\n if mode == 1 :\\n out = [x,y,w,h]\\n elif mode == 2 :\\n out = [top, right, bottom, left]\\n return out\",\n \"def detect_faces(self, img, return_best=False):\\n if numpy.all(img != None):\\n\\n try:\\n if not self.is_cuda_enable:\\n caffe.set_mode_cpu()\\n else:\\n caffe.set_mode_gpu()\\n caffe.set_device(cfg.GPU_ID)\\n\\n scores, boxes = im_detect(self.net, img)\\n\\n cls_ind = 1\\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n dets = numpy.hstack((cls_boxes,\\n cls_scores[:, numpy.newaxis])).astype(numpy.float32)\\n keep = nms(dets, NMS_THRESH)\\n dets = dets[keep, :]\\n\\n keep = numpy.where(dets[:, 4] > CONF_THRESH)\\n dets = dets[keep]\\n\\n if len(dets) > 0:\\n if return_best:\\n # dets is ordered by confidence dets[:, 4], so the first one is the best\\n det = [int(dets[0, 0]), int(dets[0, 1]), int(dets[0, 2]), int(dets[0, 3]), dets[0, 4]]\\n # extend detection\\n extend_factor = self.face_rect_expand_factor\\n width = round(det[2]-det[0])\\n height = round(det[3]-det[1])\\n length = (width + height)/2.0\\n centrepoint = [round(det[0]) + width/2.0, round(det[1]) + height/2.0]\\n det[0] = centrepoint[0] - round((1+extend_factor)*length/2.0)\\n det[1] = centrepoint[1] - round((1+extend_factor)*length/2.0)\\n det[2] = centrepoint[0] + round((1+extend_factor)*length/2.0)\\n det[3] = centrepoint[1] + round((1+extend_factor)*length/2.0)\\n ## prevent going off image\\n det[0] = int(max(det[0], 0))\\n det[1] = int(max(det[1], 0))\\n det[2] = int(min(det[2], img.shape[1]))\\n det[3] = int(min(det[3], img.shape[0]))\\n return [det]\\n else:\\n det_list = []\\n for j in range(dets.shape[0]):\\n det = [int(dets[j, 0]), int(dets[j, 1]), int(dets[j, 2]), int(dets[j, 3]), dets[0, 4]]\\n # extend detection\\n extend_factor = self.face_rect_expand_factor\\n width = round(det[2]-det[0])\\n height = round(det[3]-det[1])\\n length = (width + height)/2.0\\n centrepoint = [round(det[0]) + width/2.0, round(det[1]) + height/2.0]\\n det[0] = centrepoint[0] - round((1+extend_factor)*length/2.0)\\n det[1] = centrepoint[1] - round((1+extend_factor)*length/2.0)\\n det[2] = centrepoint[0] + round((1+extend_factor)*length/2.0)\\n det[3] = centrepoint[1] + round((1+extend_factor)*length/2.0)\\n ## prevent going off image\\n det[0] = int(max(det[0], 0))\\n det[1] = int(max(det[1], 0))\\n det[2] = int(min(det[2], img.shape[1]))\\n det[3] = int(min(det[3], img.shape[0]))\\n det_list.append(det)\\n return det_list\\n else:\\n return None\\n\\n except Exception as e:\\n print ('Exception in FaceDetectorFasterRCNN: ' + str(e))\\n pass\\n\\n return None\",\n \"async def asyncRedetectFaces():\\n faceEngine = VLFaceEngine()\\n detector = faceEngine.createFaceDetector(DetectorType.FACE_DET_V3)\\n\\n imageWithSeveralFaces = VLImage.load(filename=EXAMPLE_SEVERAL_FACES)\\n severalFaces = detector.detect([imageWithSeveralFaces], detect5Landmarks=False, detect68Landmarks=False)\\n\\n detections = await detector.redetect(\\n images=[\\n ImageForRedetection(imageWithSeveralFaces, [face.boundingBox.rect for face in severalFaces[0]]),\\n ],\\n asyncEstimate=True,\\n )\\n pprint.pprint(detections)\\n task1 = detector.redetect(\\n images=[\\n ImageForRedetection(imageWithSeveralFaces, [severalFaces[0][0].boundingBox.rect]),\\n ],\\n asyncEstimate=True,\\n )\\n task2 = detector.redetect(\\n images=[\\n ImageForRedetection(imageWithSeveralFaces, [severalFaces[0][1].boundingBox.rect]),\\n ],\\n asyncEstimate=True,\\n )\\n for task in (task1, task2):\\n pprint.pprint(task.get())\",\n \"def addPhoto(fileName, personName):\\n\\n #Check if image is a jpg\\n if (fileName[-4:] != \\\".jpg\\\"):\\n print(\\\"\\\\n[!] File extenstion must be .jpg!\\\\n\\\")\\n return\\n\\n #Check image exists\\n if (not os.path.isfile(fileName)):\\n print(\\\"\\\\n[!] File does not exist!\\\\n\\\")\\n return\\n\\n #Check no illegal characters in file name\\n for c in ILLEGAL_FILE_NAMES:\\n if (c in personName):\\n print(\\\"\\\\n[!] Provided name contains an illegal argument\\\\n\\\")\\n return\\n\\n #Load image\\n image = face_recognition.load_image_file(fileName)\\n\\n #Use the name in the filename as the identity key\\n identity = os.path.splitext(os.path.basename(fileName))[0]\\n\\n #Get the face location\\n locationsHog = hogDetectFaceLocations(image)\\n\\n locationsHaar = haarDetectFaceLocations(image)\\n\\n #Get the face encoding\\n encodingsHaar = face_recognition.face_encodings(image, locationsHaar)\\n encodingsHog = face_recognition.face_encodings(image, locationsHog)\\n\\n #check if exactly one face is in the photo\\n if ((len(encodingsHaar) == 0) or (len(encodingsHog) == 0)):\\n print(\\\"\\\\n[!] No face detected in the provided photo\\\\n\\\")\\n return\\n\\n elif ((len(encodingsHaar) > 1) or (len(encodingsHog) > 1)):\\n print(\\\"\\\\n[!] More than one face detected in the provided photo\\\\n\\\")\\n return\\n\\n #Set path to respective dataset\\n directoryToAddTo = DATABASE_PATH + personName\\n\\n #Look for directory\\n exists = False\\n for subdir, dirs, files in os.walk(DATABASE_PATH):\\n if (subdir == directoryToAddTo):\\n exists = True\\n\\n #If directory doesnt exist, make it\\n if (not exists):\\n os.mkdir(directoryToAddTo)\\n\\n #Save data to file\\n np.savetxt((directoryToAddTo + \\\"/\\\" + identity + \\\"Haar.txt\\\"),\\n encodingsHaar[0])\\n np.savetxt((directoryToAddTo + \\\"/\\\" + identity + \\\"Hog.txt\\\"),\\n encodingsHog[0])\\n\\n print(\\\"\\\\n[*] Face successfully added!\\\\n\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7326142","0.72739726","0.72709846","0.72338194","0.7221177","0.7106792","0.7075032","0.6982013","0.69769347","0.6973032","0.69372755","0.6921899","0.68639034","0.67961735","0.6771518","0.67294437","0.6728292","0.66689503","0.66174954","0.661695","0.66108","0.65956116","0.6564738","0.65638787","0.65473056","0.6529947","0.6481992","0.6470148","0.6450846","0.6444785","0.64426935","0.6429892","0.6417587","0.6411797","0.64052516","0.6376003","0.63622946","0.6350217","0.63485545","0.6346638","0.63363683","0.6316921","0.6307894","0.6300149","0.6276872","0.6269355","0.62594974","0.62452006","0.6243398","0.62378895","0.621092","0.6202002","0.6190044","0.6171594","0.61513907","0.6143384","0.61164415","0.61016613","0.6096078","0.6083832","0.6081312","0.60549945","0.60368514","0.60321456","0.6017722","0.6016832","0.60073847","0.6001852","0.5998418","0.5976983","0.5968588","0.59572756","0.59562325","0.5949888","0.59434575","0.5942634","0.59389824","0.5921886","0.591327","0.5908559","0.5908347","0.5890654","0.5885215","0.58844966","0.5874739","0.58703625","0.58645254","0.58641773","0.5859847","0.5847635","0.58343285","0.58096623","0.57810086","0.5766291","0.57653624","0.5756265","0.5745783","0.57411706","0.5739605","0.57274556"],"string":"[\n \"0.7326142\",\n \"0.72739726\",\n \"0.72709846\",\n \"0.72338194\",\n \"0.7221177\",\n \"0.7106792\",\n \"0.7075032\",\n \"0.6982013\",\n \"0.69769347\",\n \"0.6973032\",\n \"0.69372755\",\n \"0.6921899\",\n \"0.68639034\",\n \"0.67961735\",\n \"0.6771518\",\n \"0.67294437\",\n \"0.6728292\",\n \"0.66689503\",\n \"0.66174954\",\n \"0.661695\",\n \"0.66108\",\n \"0.65956116\",\n \"0.6564738\",\n \"0.65638787\",\n \"0.65473056\",\n \"0.6529947\",\n \"0.6481992\",\n \"0.6470148\",\n \"0.6450846\",\n \"0.6444785\",\n \"0.64426935\",\n \"0.6429892\",\n \"0.6417587\",\n \"0.6411797\",\n \"0.64052516\",\n \"0.6376003\",\n \"0.63622946\",\n \"0.6350217\",\n \"0.63485545\",\n \"0.6346638\",\n \"0.63363683\",\n \"0.6316921\",\n \"0.6307894\",\n \"0.6300149\",\n \"0.6276872\",\n \"0.6269355\",\n \"0.62594974\",\n \"0.62452006\",\n \"0.6243398\",\n \"0.62378895\",\n \"0.621092\",\n \"0.6202002\",\n \"0.6190044\",\n \"0.6171594\",\n \"0.61513907\",\n \"0.6143384\",\n \"0.61164415\",\n \"0.61016613\",\n \"0.6096078\",\n \"0.6083832\",\n \"0.6081312\",\n \"0.60549945\",\n \"0.60368514\",\n \"0.60321456\",\n \"0.6017722\",\n \"0.6016832\",\n \"0.60073847\",\n \"0.6001852\",\n \"0.5998418\",\n \"0.5976983\",\n \"0.5968588\",\n \"0.59572756\",\n \"0.59562325\",\n \"0.5949888\",\n \"0.59434575\",\n \"0.5942634\",\n \"0.59389824\",\n \"0.5921886\",\n \"0.591327\",\n \"0.5908559\",\n \"0.5908347\",\n \"0.5890654\",\n \"0.5885215\",\n \"0.58844966\",\n \"0.5874739\",\n \"0.58703625\",\n \"0.58645254\",\n \"0.58641773\",\n \"0.5859847\",\n \"0.5847635\",\n \"0.58343285\",\n \"0.58096623\",\n \"0.57810086\",\n \"0.5766291\",\n \"0.57653624\",\n \"0.5756265\",\n \"0.5745783\",\n \"0.57411706\",\n \"0.5739605\",\n \"0.57274556\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72242236"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":83195,"cells":{"query":{"kind":"string","value":"Finds the age of the person on the photo, based on the filename"},"document":{"kind":"string","value":"def find_age(str):\n regex = r\"_([0-9]+).+_([0-9]+)\"\n matches = re.search(regex, str)\n if matches:\n birth = matches.group(1)\n picture = matches.group(2)\n age = int(picture) - int(birth)\n return age"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_file_age(self, filepath):\n try:\n fileage = os.path.getmtime(filepath)\n return fileage\n except:\n return 0","def file_info(self, f):\n ld8 = self.ld8_extract(f) # get luna_date\n sid = self.sesid(ld8) # make luna_visitnum\n age = self.age_lookup.get(sid)\n return (sid, age)","def get_file_age_win(path, cur_parsed, cur_datetime):\n\ttry:\n\t\tdate_str = time.ctime(os.path.getctime(path))\n\t\tdate_parsed = parse_date_str(date_str, ' ', 4, 1, 2)\n\t\tprint(\"file crtime: {}\".format(date_parsed))\n\t\tdate_dif = date_dif_precomputed(cur_parsed[0], cur_parsed[1], cur_parsed[2], date_parsed[0], date_parsed[1], date_parsed[2])\n\t\treturn date_dif\n\texcept:\n\t\tprint(\"EXCEPTION! fallback to mtime!\")\n\t\treturn get_file_age_default(path, cur_parsed, cur_datetime)","def read_photo_date(file_name):\n # Open image file for reading (binary mode)\n fd = open(file_name, 'rb')\n\n # Return Exif tags\n tags = exifread.process_file(fd)\n try:\n date_time = tags['EXIF DateTimeOriginal']\n except KeyError:\n date_time = get_timestamp_from_mp4(os.path.basename(file_name))\n if date_time == \"\":\n # date time info is not valid in exif, try to get file's create time\n date_time = get_file_modification_time(file_name)\n \n\n log(str(date_time) + \"--->\" + str(file_name))\n\n #parse date time string and returns tuple\n words = str(date_time).split(' ')[0].split(':') #2013:11:16 17:44:16\n if len(words) == 3:\n y = words[0]\n m = words[1]\n d = words[2]\n else:\n words = str(date_time).split(' ')[0].split('-') # 2015-01-08 16:05:13\n y = words[0]\n m = words[1]\n d = words[2]\n\n #returns a tuple\n return y, m, d","def _get_date_taken(path):\n return Image.open(path)._getexif()[36867]","def get_age(self, name=None):\n now = datetime.now()\n delta = relativedelta(now, self.date_of_birth)\n years_months_days = str(delta.years) + 'y ' + str(delta.months) + \\\n 'm ' + str(delta.days) + 'd'\n return years_months_days","def get_file_age_default(path, cur_parsed, cur_datetime):\n\tmtime = datetime.fromtimestamp(os.path.getmtime(path))\n\tmtime = str(mtime).split(' ')[0]\n\tmtime = parse_date_str(mtime, '-', 0, 1, 2)\n\tprint(\"file mtime: {}\".format(mtime))\n\tdate_dif = date_dif_precomputed(cur_parsed[0], cur_parsed[1], cur_parsed[2], mtime[0], mtime[1], mtime[2])\n\treturn date_dif","def age(self):\n return datetime.now().year - self.birth_day.year","def age(self, year=None):\n y, m = self.master['birthYear'], self.master['birthMonth']\n return (year if year else self.currentyear) - y - (m > 6)","def getDataAge(self, filesByLumi):\n maxInsertTime = 0\n for filesInfos in list(filesByLumi.values()):\n for fileInfo in filesInfos:\n if fileInfo['insert_time'] > maxInsertTime:\n maxInsertTime = fileInfo['insert_time']\n\n return self.currentTime - maxInsertTime","def file_creation_age(file_path):\n current_time = datetime.now()\n # Seconds passed since the file was created\n seconds_passed = (current_time - file_creation_date(file_path)).total_seconds()\n\n # Converting to minutes\n days = round(seconds_passed/60/60/24,5)\n\n return days","def age(self):\n today = datetime.date.today()\n\n return today.year - int(self.birthday[0:4])","def age(birthdate):\n today=date.today()\n birthdate=date(birthdate[2],birthdate[1],birthdate[0])\n if birthdate>today:\n return \"Person has not been born yet!\"\n difference=today-birthdate\n return difference.days","def get_age(self):\n born = self.birth_date\n if not born:\n return 0\n today = fields.Date.today()\n return today.year - born.year - ((today.month, today.day) < (born.month, born.day))","def get_age(self):\n today = datetime.now()\n return today.year \\\n - self.date_of_birth.year \\\n - ((today.month, self.date_of_birth.day) \\\n < (self.date_of_birth.month, self.date_of_birth.day))","def get_age(self):\n return int(CURRENT_YEAR[:4]) - self.year # String-slice only the year","def age(self):\n\n years, months, days = calculate_age(self.birthdate)\n if years:\n return \"%d year%s old\" % (years, \"s\" if years > 1 else \"\")\n elif months:\n return \"%d month%s old\" % (months, \"s\" if months > 1 else \"\")\n else:\n return \"%d day%s old\" % (days, \"s\" if days > 1 else \"\")","def get_file_two_years(file):\n f = '_' + '(\\d+)' + '_' + '(\\d+)'\n match = re.search(f, file)\n if match:\n return int(match.group(1)), int(match.group(2))","def age(self):\n today = date.today()\n birthday = datetime.strptime(self.birt['date'], \"%d %b %Y\")\n return birthday","def get_age(self):\n\t\treturn self.age","def getCacheEntryAge(self, theKey):\n theGameFile = File(self.theCacheDirectory, theKey + \".zip\")\n if theGameFile.exists():\n return System.currentTimeMillis() - theGameFile.lastModified()\n return System.currentTimeMillis()","def get_person_age(name):\n groups = {}\n \n groups.update(group1)\n groups.update(group2)\n groups.update(group3)\n \n try:\n if name.lower() in groups:\n return groups[name.lower()]\n else:\n return NOT_FOUND\n except:\n return NOT_FOUND\n pass","def age(self):\n today = datetime.date(2001, 5, 12)\n yyyy = self.birthday[0:4]\n mm = int(self.birthday[4:6])\n dd = int(self.birthday[6:8])\n dob = datetime.date(int(yyyy), mm, dd)\n age_in_days = (today - dob).days\n age_in_years = age_in_days / 365\n return int(age_in_years)","def age(self, z):\n if self.k0 == 0.0:\n return(self.age_flat(z))\n fullage = self.lookback_time(np.Inf)\n tl = self.lookback_time(z)\n age = fullage - tl\n return(age)","def get_age(self):\n age = CURRENT_YEAR - self.year\n return age","def getage(birth_year):\n today = datetime.date.today()\n print(\"Today is: \", today)\n year = today.year\n\n age = year - int(birth_year)\n # print(type(age)) you return int value by taking str\n return age","def findcreatedate(self):\n try:\n exifdata = subprocess.check_output(['exiftool', '-j', '-TAG', '-CreateDate', self.filename])\n except OSError as e:\n print \"exiftool may not be installed. Please go check.\"\n print \"Here is the error thrown: {}\".format(e)\n raise\n\n data = json.loads(exifdata)\n self.createdate = date(*[int(elt) for elt in re.split('[ :]', data[0]['CreateDate'])][0:3])\n return self.createdate","def get_age(actor: Actor, movie: Movie) -> str:\r\n opening_date = dateutil.parser.parse(movie.release_date)\r\n birth_date = dateutil.parser.parse(actor.born)\r\n age = int((opening_date - birth_date).days / 365)\r\n return f'{actor.name} was {age} years old when {movie.title} came out.'","def age(self, agent):\n return (self.time - agent.born)/52.0","def creation_date_from_exif(filename):\n # Source: https://orthallelous.wordpress.com/2015/04/19/extracting-date-and-time-from-images-with-python/\n with Image.open(filename) as img:\n exif = img.getexif()\n\n if exif is None:\n raise ValueError(f\"No exif data for {filename}\")\n\n # for subsecond prec, see doi.org/10.3189/2013JoG12J126 , sect. 2.2, 2.3\n tags = [\n (36867, 37521), # (DateTimeOriginal, SubsecTimeOriginal)\n (36868, 37522), # (DateTimeDigitized, SubsecTimeDigitized)\n (306, 37520), # (DateTime, SubsecTime)\n ]\n\n for tag in tags:\n dat = exif.get(tag[0])\n sub = exif.get(tag[1], 0)\n\n # PIL.PILLOW_VERSION >= 3.0 returns a tuple\n dat = dat[0] if isinstance(dat, tuple) else dat\n if not dat:\n continue\n\n sub = sub[0] if isinstance(sub, tuple) else sub\n if isinstance(sub, int):\n sub = f\"{sub:06d}\"\n\n date, time = dat.split(\" \")\n date = date.replace(\":\", \"-\")\n return fromisoformat(f\"{date}T{time}.{sub}\")\n\n raise ValueError(f\"No date found in the exif data for {filename}\")","def get_age(self):\n return Guitar.CURRENT_YEAR - self.year","def get_age(self) -> int:\n return self.age","def get_file_year(filepath):\n filename = os.path.split(filepath)[-1]\n date = filename.split('.')[-2]\n year = int(date.split('-')[0])\n month = int(date.split('-')[1])\n return year, month","def get_age(self):\n return CURRENT_YEAR - self.year","def get_age(self):\n return CURRENT_YEAR - self.year","def get_age(self):\n if validate_date_format(self.birt):\n birth_year, birth_month, birth_day = change_date_format(self.birt).split('-')\n\n if self.alive:\n provided_date = datetime.today().date()\n age = (provided_date.year - int(birth_year) - ((datetime.today().month, datetime.today().day) < (int(birth_month), int(birth_day))))\n else:\n death_year, death_month, death_day = change_date_format(self.deat).split('-')\n age = (int(death_year) - int(birth_year) - ((int(death_month), int(death_day)) < (int(birth_month), int(birth_day))))\n\n return age","def get_age(self):\r\n return self.age","def getAge(self):\n if self.birthday == None:\n raise ValueError\n return (datetime.date.today() - self.birthday).days","def getAge(self):\n if self.birthday == None:\n raise ValueError\n return (datetime.date.today() - self.birthday).days","def getAge(self):\n if self.birthday == None:\n raise ValueError\n return (datetime.date.today() - self.birthday).days","def getAge(self):\n if self.birthday == None:\n raise ValueError\n return (datetime.date.today() - self.birthday).days","def getAge(self):\r\n return self.age","def get_age(self):\n age = 2021 - self.year\n return age","def age(self):\r\n return self._age","def parseFilename(fileName):\n # regex to match names like Axis-BaldCA_2018-05-29T16_02_30_129496.jpg\n # and bm-n-mobo-c__2017-06-25z11;53;33.jpg\n regexExpanded = '([A-Za-z0-9-_]+[^_])_+(\\d{4}-\\d\\d-\\d\\d)T(\\d\\d)[_;](\\d\\d)[_;](\\d\\d)'\n # regex to match diff minutes spec for subtracted images\n regexDiff = '(_Diff(\\d+))?'\n # regex to match optional crop information e.g., Axis-Cowles_2019-02-19T16;23;49_Crop_270x521x569x820.jpg\n regexOptionalCrop = '(_Crop_(-?\\d+)x(-?\\d+)x(\\d+)x(\\d+))?'\n matchesExp = re.findall(regexExpanded + regexDiff + regexOptionalCrop, fileName)\n # regex to match names like 1499546263.jpg\n regexUnixTime = '(1\\d{9})'\n matchesUnix = re.findall(regexUnixTime + regexDiff + regexOptionalCrop, fileName)\n cropInfo = None\n if len(matchesExp) == 1:\n match = matchesExp[0]\n parsed = {\n 'cameraID': match[0],\n 'date': match[1],\n 'hours': match[2],\n 'minutes': match[3],\n 'seconds': match[4]\n }\n isoStr = '{date}T{hour}:{min}:{sec}'.format(date=parsed['date'],hour=parsed['hours'],min=parsed['minutes'],sec=parsed['seconds'])\n dt = dateutil.parser.parse(isoStr)\n unixTime = int(dt.timestamp())\n parsed['diffMinutes'] = int(match[6] or 0)\n cropInfo = match[-4:]\n elif len(matchesUnix) == 1:\n match = matchesUnix[0]\n unixTime = int(match[0])\n dt = datetime.datetime.fromtimestamp(unixTime)\n isoStr = datetime.datetime.fromtimestamp(unixTime).isoformat()\n parsed = {\n 'cameraID': 'UNKNOWN_' + fileName,\n 'date': dt.date().isoformat(),\n 'hours': str(dt.hour),\n 'minutes': str(dt.minute),\n 'seconds': str(dt.second)\n }\n parsed['diffMinutes'] = int(match[2] or 0)\n cropInfo = match[-4:]\n else:\n logging.error('Failed to parse name %s', fileName)\n return None\n if cropInfo[0]:\n parsed['minX'] = int(cropInfo[0])\n parsed['minY'] = int(cropInfo[1])\n parsed['maxX'] = int(cropInfo[2])\n parsed['maxY'] = int(cropInfo[3])\n parsed['isoStr'] = isoStr\n parsed['unixTime'] = int(unixTime)\n return parsed","def get_age(self):\n if self.birthday is None:\n raise(ValueError('Birthday is not set.'))\n return (datetime.date.today() - self.birthday).days","def get_file_age_linux(path, cur_parsed, cur_datetime):\n\ttry:\n\t\t# calls standard stat command to get file's inode\n\t\tinode = subprocess.check_output([\"stat\", \"-c\", \"%i\", path])\n\t\tprint(\"inode: \" + inode)\n\t\tinode = int(inode)\n\t\t# calls df command to get fs type\n\t\tfs = subprocess.check_output([\"df\", \"--output=source\", path])\n\t\tprint(\"fs: \" + fs)\n\t\tfs = str(fs).split(\"\\n\")[1]\n\t\t# calls debugfs in order to get crtime timesamp\n\t\tcrtime_str = os.popen(\"sudo debugfs -R 'stat <\"+str(inode)+\">' \"+fs+\" | grep -E 'crtime'\").read()\n\t\tprint(\"crtime: \"+crtime_str)\n\t\tcrtime_str = crtime_str.split(\" -- \")[1]\n\t\tcrtime = parse_date_str(crtime_str, ' ', 4, 1, 2)\n\t\tprint(\"file crtime: {}\".format(crtime))\n\t\tdate_dif = date_dif_precomputed(cur_parsed[0], cur_parsed[1], cur_parsed[2], crtime[0], crtime[1], crtime[2])\n\t\treturn date_dif\n\texcept:\n\t\texc_type, exc_value, exc_traceback = sys.exc_info()\n\t\tprint(\"EXCEPTION! fallback to mtime!\")\n\t\ttraceback.print_exception(exc_type, exc_value, exc_traceback, file=sys.stdout)\n\t\treturn get_file_age_default(path, cur_parsed, cur_datetime)","def get_patient_info(file_path):\n f = open(file_path, 'rb')\n content = f.read()\n f.close()\n\n header = content[:88]\n patient_id = header[8:88].decode('ascii')\n # the headers \"fixed\" by tuh nedc data team show a '-' right before the age of the patient. therefore add this to\n # the regex and use the absolute value of the casted age\n [age] = re.findall(\"Age:(-?\\d+)\", patient_id)\n [sex] = re.findall(\"\\s\\w\\s\", patient_id)\n\n sex_id = 0 if sex.strip() == 'M' else 1\n\n return sex_id, abs(int(age))","def exif_date(path):\n\n # gets the exif data for jpg files\n ext = path.split(\".\")[-1].lower()\n if ext != \"jpg\":\n return False\n\n with open(path, \"rb\") as image_file:\n my_image = Image(image_file)\n\n if my_image.has_exif:\n try:\n date = datetime.datetime.strptime(my_image.datetime, \"%Y:%m:%d %H:%M:%S\")\n print(\"exif date\", path, date)\n except AttributeError:\n print(\"attribute error on\", path)\n return False\n return date\n\n return False","def compute_age(epoch):\n birth_date = datetime.datetime.fromtimestamp(epoch/1000)\n now = datetime.datetime.now()\n age = (now - birth_date).days / 365\n return age","def age_diff(self, other):\n diff = self.age - other.age\n print(abs(diff), \"year difference\")","def get_age(self):\n return self.glb[iage]","def calculate_age(born):\n today = datetime.date.today()\n return today.year - born.year - ((today.month, today.day) < (born.month, born.day))","def _find_average_age():\r\n count, total = 0, 0\r\n for resource in resources:\r\n patient = resource[\"resource\"]\r\n if \"birthDate\" in patient:\r\n count += 1\r\n dob = patient[\"birthDate\"].split(\"-\")\r\n dob = datetime(int(dob[0]), int(dob[1]), int(dob[2]), 0, 0, 0, 0)\r\n if \"deceasedDateTime\" in patient:\r\n death_time = patient[\"deceasedDateTime\"].split(\"T\")[0].split(\r\n \"-\")\r\n death_time = datetime(int(death_time[0]), int(death_time[1]),\r\n int(death_time[2]), 0, 0, 0, 0)\r\n else:\r\n death_time = datetime.now()\r\n age = relativedelta(death_time, dob).years\r\n total += age\r\n if count == 0:\r\n return count, count\r\n return total / count, count","def _get_age(self):\n for employee in self:\n if employee.sudo().birthday:\n employee.age = relativedelta(\n fields.Date.from_string(fields.Date.today()),\n fields.Date.from_string(employee.sudo().birthday)).years\n else:\n employee.age = 0","def age(self):\n return self.__age","def getFileModifTime(filename):\n\tfilename = adaptPath(filename)\n\tfrom os import stat\n\ttry:\n\t\tresult = stat(filename).st_mtime\n\texcept:\n\t\tresult = 0\n\treturn result","def getAge(self):\n if self.setBirthday == None:\n raise ValueError\n return (datetime.date.today() - self.birthday).days","def parse_info_from_file(path):\n try:\n filename = os.path.split(path)[1]\n filename = os.path.splitext(filename)[0]\n age, gender, race, _ = filename.split('_')\n\n return int(age), dataset_dict['gender_id'][int(gender)], dataset_dict['race_id'][int(race)]\n except Exception as ex:\n return None, None, None","def get_year(self, filename):\n year = self.file.replace('s24_', '').replace('.vrt', '')\n self.logger.info(f'This .vrt file contains data for the year {year}')\n return year","def getAge(self):\n return self.age","def _get_age(self):\n return self.__age","def parse_patient_age(age):\n if age == 'None' or not age:\n return None\n\n conversion = { # conversion to days\n 'Y': 365,\n 'M': 30,\n 'W': 7,\n 'D': 1,\n }\n scale = age[-1:]\n value = age[:-1]\n if scale not in conversion.keys():\n # Assume years\n scale = 'Y'\n value = age\n\n age_in_seconds = datetime.timedelta(int(value) * conversion.get(scale)).total_seconds()\n\n # Make sure that the age is reasonable\n if not age_in_seconds or age_in_seconds <= 0:\n age_in_seconds = None\n\n return age_in_seconds","def filter_by_age(files, comparator):\n today = date.today()\n results = []\n for f in files:\n m = DATE_REGEX.search(f)\n if not m:\n continue\n f_date = date(int(m.group(1)), int(m.group(2)), int(m.group(3)))\n\n if comparator(today - f_date):\n results.append((f_date, f))\n\n results.sort()\n return [f for _, f in results]","def get_age(date):\n today = datetime.date.today()\n return today.year - date.year - ((today.month, today.day) < (date.month, date.day))","def get_exif_data(fname):\n ret = {}\n try:\n img = Image.open(fname)\n if hasattr( img, '_getexif' ):\n exifinfo = img._getexif()\n if exifinfo != None:\n for tag, value in exifinfo.items():\n decoded = TAGS.get(tag, tag)\n ret[decoded] = value\n except IOError:\n print ('IOERROR ' + fname)\n return ret","def get_age(self):\n return self._age","def get_age(self):\n return self._age","def get_age(self):\n return self._age","def parse_age_actor(soup, pageurl):\n\tage = None\n\t# search for class containing age\n\tage_span = soup.findAll('span', { 'class' : 'noprint ForceAgeToShow' });\n\tif len(age_span) == 0:\n\t\t# check if actor is dead.\n\t\tdeath_span = soup.findAll('span', {'class': 'deathplace'})\n\t\t# if actor is dead, need to parse slightly differently to get age\n\t\tif len(death_span) != 0:\n\t\t\ts = death_span[0].find_parent().get_text()\n\t\t\tidx = s.index('aged')\n\t\t\tend_idx = s[idx:].index(')')\n\t\t\ts = s[idx:idx+end_idx]\n\t\t\tage = [int(s) for s in s.split() if s.isdigit()]\n\t\t\t# entry did not contain age, likely only contained deathplace.\n\t\t\tif len(age) == 0:\n\t\t\t\tlogging.warning('' + pageurl + ' does not contain an age for the actor and will not be parsed')\n\t\t\t\treturn None\n\t\t\tage = age[0]\n\t\t# if actor is not dead and no age field, no other way to get age\n\t\telse:\n\t\t\tlogging.warning('' + pageurl + ' does not contain an age for the actor and will not be parsed')\n\t\t\treturn None\n\t# clean the input and cast to int\n\tif age == None:\n\t\tage = int(age_span[0].next[1:-1].split()[1])\n\treturn age","def get_age(self):\n return self.__age","def find_age(row):\n #pass\n today = datetime.datetime.today()\n try:\n x = round((today - row).days/365)\n except ValueError:\n x = np.nan\n return x","def age():\n return 1\n import os\n\n #imported_xls_data[x][1] = age of participant (i.e.adult or child)\n self.age = 1\n #imported_xls_data[x][2] = event (i.e. hit or miss)\n self.event = 2\n #imported_xls_data[x][3] = the target (i.e. Dispense, dispensor Controls, Fridge door (dispensor side), Fridge door (no dispensor), Freezer Door)\n self.target = 3\n\n #Entering the mat\n #imported_xls_data[x][4] = foot distance of the 1st step onto the MAT with LEFT foot (in inches)\n self.firstLEFTradius_in = 4\n #imported_xls_data[x][5] = angle of the 1st step onto the MAT with LEFT foot (in degrees)\n self.firstLEFTdegrees = 5\n #imported_xls_data[x][6] = timestamp of the 1st step onto the MAT with LEFT foot (in 00:00:000 hours, mins, milliseconds)\n self.firstLEFTtstamp = 6\n #imported_xls_data[x][7] = foot distance of the 1st step onto the MAT with RIGHT foot (in inches)\n self.self.firstRIGHTradius_in = 7\n #imported_xls_data[x][8] = angle of the 1st step onto the MAT with RIGHT foot (in degrees)\n self.firstRIGHTdegrees = 8\n #imported_xls_data[x][9] = timestamp of the 1st step onto the MAT with RIGHT foot (in 00:00:000 hours, mins, milliseconds)\n self.firstRIGHTtstamp = 9\n\n #Arriving at the fridge\n #imported_xls_data[x][10] = foot distance of the LEFT foot at fridge (if a hit) (in inches)\n self.atfridgeLEFTradius_in = 10\n #imported_xls_data[x][11] = angle of the LEFT foot at fridge (if a hit) (in degrees)\n self.atfridgeLEFTdegrees = 11\n #imported_xls_data[x][12] = timestamp of the LEFT foot at fridge (if a hit) (in 00:00:000 hours, mins, milliseconds)\n self.atfridgeLEFTtstamp = 12\n #imported_xls_data[x][13] = foot distance of the RIGHT foot at fridge (if a hit) (in inches)\n self.atfridgeRIGHTradius_in = 13\n #imported_xls_data[x][14] = angle of the RIGHT foot at fridge (if a hit) (in degrees)\n self.atfridgeRIGHTdegrees = 14\n #imported_xls_data[x][15] = timestamp of the RIGHT foot at fridge (if a hit) (in 00:00:000 hours, mins, milliseconds)\n self.atfridgeRIGHTtstamp = 15\n\n\n\n\n #Leaving the mat\n #imported_xls_data[x][16] = foot distance of the Last LEFT foot step before leaving mat (in inches)\n self.lastLEFTradius_in = 16\n #imported_xls_data[x][17] = angle of the Last LEFT foot step before leaving mat (in degrees)\n self.lastLEFTdegrees = 17\n #imported_xls_data[x][18] = timestamp of the Last LEFT foot step before leaving mat (in 00:00:000 hours, mins, milliseconds)\n self.lastLEFTtstamp = 18\n #imported_xls_data[x][19] = foot distance of the Last RIGHT foot step before leaving mat: (in inches)\n self.lastRIGHTradius_in = 19\n #imported_xls_data[x][20] = angle of the Last RIGHT foot step before leaving mat: (in degrees)\n self.lastRIGHTdegrees = 20\n #imported_xls_data[x][21] = timestamp of the Last RIGHT foot step before leaving mat: (in 00:00:000 hours, mins, milliseconds)\n self.lastRIGHTtstamp = 21","def _isAge(self, words, index):\n start = index\n length = len(words)\n \n # [age[:]] number [yr/yrs] [old]\n if words[index]['word'] == 'age':\n index += 1\n if index == length:\n return None, 0\n if words[index]['word'] == ':':\n index += 1\n if index == length:\n return None, 0\n age_key = True\n else:\n age_key = False\n \n if not words[index]['word'].isdigit():\n return None, 0\n \n age = words[index]['word']\n \n index += 1\n if index < length:\n if words[index]['word'] in [ 'yr', 'yrs', 'year', 'years' ]:\n age_key = True\n index += 1\n if index < length:\n if words[index]['word'] == 'old':\n index += 1\n \n if age_key:\n return age, index - start - 1\n \n return None, 0","def get_imageId_from_fileName(filename):\n filename = os.path.splitext(filename)[0]\n if filename.isdigit():\n return int(filename)\n return id_iter","def exif_timestamp(filename):\n # PIL lazy-loads the image data, so this open and _getexif() is fast.\n img = PIL.Image.open(filename)\n if ('exif' not in img.info.keys()) or (not hasattr(img, '_getexif')):\n raise exceptions.ICExifReadError(f\"no EXIF data found in {filename}\")\n # Avoid constucting the whole EXIF dict just to extract the DateTime field.\n # DateTime -> key 306 is in the EXIF standard, so let's use that directly.\n ## date_time = {TAGS[k] : v for k,v in exif.items()}['DateTime']\n exif = img._getexif()\n key = 306\n if key not in exif.keys():\n raise exceptions.ICExifReadError(f\"key 306 (DateTime) not found in \"\n f\"EXIF data of file {filename}\")\n # '2019:03:10 22:42:42'\n date_time = exif[key]\n if date_time.count(':') != 4:\n msg = f\"unsupported EXIF DateTime format in '{date_time}' of {filename}\"\n raise exceptions.ICExifReadError(msg)\n # '2019:03:10 22:42:42' -> ['2019', '03', '10', '22', '42', '42']\n date_time_str = date_time.replace(':', ' ').split()\n names = ('year', 'month', 'day', 'hour', 'minute', 'second')\n stamp = datetime.datetime(**{nn:int(vv) for nn,vv in zip(names,date_time_str)},\n tzinfo=datetime.timezone.utc).timestamp()\n return stamp","def _get_average_age(self):\n sql = \"\"\"\n SELECT AVG(age) as avg_age\n FROM(\n SELECT DATE_PART('year', AGE(now(), birth_date)) as age\n FROM {schema}.participant_match\n WHERE birth_date is not null\n ) x\n \"\"\".format(schema=self.database.schema)\n df = pd.read_sql(sql, self.database.connection)\n avg_age = None\n if len(df) > 0:\n avg_age = df.loc[0]['avg_age']\n return avg_age","def get_exif_data(filename):\n ret = {}\n try:\n img = Image.open(filename)\n if hasattr( img, '_getexif' ):\n exifinfo = img._getexif()\n if exifinfo != None:\n for tag, value in exifinfo.items():\n decoded = TAGS.get(tag, tag)\n ret[decoded] = value\n except IOError:\n print 'IOERROR ' + filename\n return ret","def oldest_person_dc(all_profile_dict: dict) -> float:\n \"\"\"Param:all_profile_dc: dictionary containing all profiles\"\"\"\n value = min(all_profile_dict.values(), key=lambda v: v['birthdate'])\n date_today = datetime.date.today()\n age = (date_today - value['birthdate']).days\n return int(age/365)","def get_exif_data(fname):\n ret = {}\n try:\n img = Image.open(StringIO.StringIO(fname))\n if hasattr( img, '_getexif' ):\n exifinfo = img._getexif()\n if exifinfo != None:\n for tag, value in exifinfo.items():\n decoded = TAGS.get(tag, tag)\n ret[decoded] = value\n except IOError:\n print 'IOERROR ' + fname\n return ret","def num_older_than(age: float) -> int:\r\n cur = con.cursor()\r\n count_older = cur.execute(\r\n \"\"\"SELECT COUNT(Patient_ID)\r\n FROM Patient\r\n WHERE (JULIANDAY('now') - JULIANDAY(Date_Of_Birth)) / ? > ?\"\"\",\r\n [DAYS_IN_YEAR, age],\r\n ).fetchall()\r\n\r\n return count_older[0][0]","def retrieve_geotiff_metadata(sFilename_geotiff_in):\n pDriver = gdal.GetDriverByName('GTiff')\n \n pDataset = gdal.Open(sFilename_geotiff_in, gdal.GA_ReadOnly)\n\n if pDataset is None:\n print(\"Couldn't open this file: \" + sFilename_geotiff_in)\n sys.exit(\"Try again!\")\n else: \n pProjection = pDataset.GetProjection()\n pSpatial_reference = osr.SpatialReference(wkt=pProjection) \n ncolumn = pDataset.RasterXSize\n nrow = pDataset.RasterYSize \n pGeotransform = pDataset.GetGeoTransform()\n dOriginX = pGeotransform[0]\n dOriginY = pGeotransform[3]\n dPixelWidth = pGeotransform[1]\n pPixelHeight = pGeotransform[5] \n return dPixelWidth, dOriginX, dOriginY, nrow, ncolumn, pSpatial_reference, pProjection, pGeotransform","def _get_diameter(self,filename,maxLen=3):\n filename = os.path.splitext(filename)[0] \n filename = os.path.split(filename)[1] \n filename = filename.split(\"_\",3)[2] \n diameter = filename \n return diameter","def oldest_person_nt(all_profile_nt: namedtuple) -> float:\n \"\"\"Param: all_profile_nt: Named tuple containing all profiles\"\"\"\n value = min(all_profile_nt, key=lambda v: v[-1])\n date_today = datetime.date.today()\n age = (date_today - value.birthdate).days\n return int(age/365)","def age(self):\n # TODO(user) move up to AFF4Object after some analysis of how .age is\n # used in the codebase.\n aff4_type = self.Get(self.Schema.TYPE)\n\n if aff4_type:\n return aff4_type.age\n else:\n # If there is no type attribute yet, we have only just been created and\n # not flushed yet, so just set timestamp to now.\n return rdfvalue.RDFDatetime().Now()","def calc_age_in_seconds(self, number_years):\n\t\thours = self.calc_hours_in_a_year(number_years)\n\t\t\n\t\treturn hours * 60 * 60","def __file_sorter(self, filename: str) -> int:\n filename = filename.split('/')[-1]\n year = int(filename[-3:-1]) # extracts YY from ssssdddh.YYo\n day_info = filename[4:8] # extracts dddh from ssssdddh.YYo\n day_of_year = int(day_info[:3]) # ddd\n hour_block = day_info[-1] # h\n if hour_block.isdigit():\n return (year, day_of_year)\n return (year, day_of_year + ord(hour_block))","def extract_exif(fname):\n\n try:\n # check if file has EXIF date, exception if not\n exif_data = fileops.get_exif_datetimeorig_tag(fname)\n\n # extract the date/time string from EXIF, exception if\n # not the proper format\n datetimestr = exif_to_datetimestr(exif_data)\n\n logging.debug(\"Found EXIF Tag %r for file %r\", datetimestr, \n os.path.basename(fname))\n\n return datetimestr\n\n except fileops.EXIFTagError:\n logging.warning(\"%r does not have a proper EXIF tag\",\n os.path.basename(fname))\n return \"\";\n\n except DateStrError:\n logging.warning(\"%r EXIF tag not the right format\",\n os.path.basename(fname))\n return \"\";","def profile_photo(self):\n images_directory_index = 6\n filepath = None\n photo = self.profile_photo_path\n if photo is not None:\n photo_dir = photo.split(\"/\")[images_directory_index:]\n filepath = \"/\".join(photo_dir)\n return filepath","def get_date(img):\n exif = img.getexif()\n date = exif.get(306)\n if date is not None:\n date = date.replace(' ', '-').replace(':', '')\n return date","def _get_info_from_filename(filename: str) -> dict:\n *parts, suffix = filename.split('.')\n dct = re.match(r'^(?P<name>[A-z0-9.]*)(-(?P<num_rows>[0-9]+))?$', '.'.join(parts)).groupdict()\n return {\n 'name': dct['name'],\n 'num_rows': int(dct['num_rows']) if dct['num_rows'] else None,\n 'format': suffix,\n }","def get_cached_data_age(name):\n cache_path = get_cachefile('%s.cache' % name)\n if not os.path.exists(cache_path):\n return 0\n return time.time() - os.stat(cache_path).st_mtime","def photo(self):\n person = self.get_person()\n if person is None:\n return None\n return person.photo","def get_age(YY_OF_BIRTH, MM_OF_BIRTH, DD_OF_BIRTH):\n\n date_ = date.today()\n year = date_.year\n month = date_.month\n day = date_.day\n\n age = year - YY_OF_BIRTH\n\n if (month < MM_OF_BIRTH):\n age -= 1\n elif (month == MM_OF_BIRTH):\n if (day < DD_OF_BIRTH):\n age -= 1\n\n return age","def calculate_current_age(dob):\n today = datetime.date.today()\n years = today.year - dob.year\n if today.month < dob.month or (today.month == dob.month and today.day < dob.day):\n years -= 1\n return years","def age(self):\n delta = now() - self.creation\n return delta.seconds","def read_file(filename):\n\tprint(\"Beginning file read...\")\n\tmy_image = cv2.imread(filename)\n\treturn computer_hash(my_image)","def _set_age(cls, data):\n birth = data.get(\"birth\")\n if birth:\n today = datetime.now().date()\n data[\"age\"] = relativedelta(today, birth).years\n return data","def test_jpeg_exif(h, f):\n if h[6:10].lower() == 'exif':\n return 'jpeg'","def __get_modification_time(filename: str) -> float:\n return os.stat(filename).st_mtime"],"string":"[\n \"def get_file_age(self, filepath):\\n try:\\n fileage = os.path.getmtime(filepath)\\n return fileage\\n except:\\n return 0\",\n \"def file_info(self, f):\\n ld8 = self.ld8_extract(f) # get luna_date\\n sid = self.sesid(ld8) # make luna_visitnum\\n age = self.age_lookup.get(sid)\\n return (sid, age)\",\n \"def get_file_age_win(path, cur_parsed, cur_datetime):\\n\\ttry:\\n\\t\\tdate_str = time.ctime(os.path.getctime(path))\\n\\t\\tdate_parsed = parse_date_str(date_str, ' ', 4, 1, 2)\\n\\t\\tprint(\\\"file crtime: {}\\\".format(date_parsed))\\n\\t\\tdate_dif = date_dif_precomputed(cur_parsed[0], cur_parsed[1], cur_parsed[2], date_parsed[0], date_parsed[1], date_parsed[2])\\n\\t\\treturn date_dif\\n\\texcept:\\n\\t\\tprint(\\\"EXCEPTION! fallback to mtime!\\\")\\n\\t\\treturn get_file_age_default(path, cur_parsed, cur_datetime)\",\n \"def read_photo_date(file_name):\\n # Open image file for reading (binary mode)\\n fd = open(file_name, 'rb')\\n\\n # Return Exif tags\\n tags = exifread.process_file(fd)\\n try:\\n date_time = tags['EXIF DateTimeOriginal']\\n except KeyError:\\n date_time = get_timestamp_from_mp4(os.path.basename(file_name))\\n if date_time == \\\"\\\":\\n # date time info is not valid in exif, try to get file's create time\\n date_time = get_file_modification_time(file_name)\\n \\n\\n log(str(date_time) + \\\"--->\\\" + str(file_name))\\n\\n #parse date time string and returns tuple\\n words = str(date_time).split(' ')[0].split(':') #2013:11:16 17:44:16\\n if len(words) == 3:\\n y = words[0]\\n m = words[1]\\n d = words[2]\\n else:\\n words = str(date_time).split(' ')[0].split('-') # 2015-01-08 16:05:13\\n y = words[0]\\n m = words[1]\\n d = words[2]\\n\\n #returns a tuple\\n return y, m, d\",\n \"def _get_date_taken(path):\\n return Image.open(path)._getexif()[36867]\",\n \"def get_age(self, name=None):\\n now = datetime.now()\\n delta = relativedelta(now, self.date_of_birth)\\n years_months_days = str(delta.years) + 'y ' + str(delta.months) + \\\\\\n 'm ' + str(delta.days) + 'd'\\n return years_months_days\",\n \"def get_file_age_default(path, cur_parsed, cur_datetime):\\n\\tmtime = datetime.fromtimestamp(os.path.getmtime(path))\\n\\tmtime = str(mtime).split(' ')[0]\\n\\tmtime = parse_date_str(mtime, '-', 0, 1, 2)\\n\\tprint(\\\"file mtime: {}\\\".format(mtime))\\n\\tdate_dif = date_dif_precomputed(cur_parsed[0], cur_parsed[1], cur_parsed[2], mtime[0], mtime[1], mtime[2])\\n\\treturn date_dif\",\n \"def age(self):\\n return datetime.now().year - self.birth_day.year\",\n \"def age(self, year=None):\\n y, m = self.master['birthYear'], self.master['birthMonth']\\n return (year if year else self.currentyear) - y - (m > 6)\",\n \"def getDataAge(self, filesByLumi):\\n maxInsertTime = 0\\n for filesInfos in list(filesByLumi.values()):\\n for fileInfo in filesInfos:\\n if fileInfo['insert_time'] > maxInsertTime:\\n maxInsertTime = fileInfo['insert_time']\\n\\n return self.currentTime - maxInsertTime\",\n \"def file_creation_age(file_path):\\n current_time = datetime.now()\\n # Seconds passed since the file was created\\n seconds_passed = (current_time - file_creation_date(file_path)).total_seconds()\\n\\n # Converting to minutes\\n days = round(seconds_passed/60/60/24,5)\\n\\n return days\",\n \"def age(self):\\n today = datetime.date.today()\\n\\n return today.year - int(self.birthday[0:4])\",\n \"def age(birthdate):\\n today=date.today()\\n birthdate=date(birthdate[2],birthdate[1],birthdate[0])\\n if birthdate>today:\\n return \\\"Person has not been born yet!\\\"\\n difference=today-birthdate\\n return difference.days\",\n \"def get_age(self):\\n born = self.birth_date\\n if not born:\\n return 0\\n today = fields.Date.today()\\n return today.year - born.year - ((today.month, today.day) < (born.month, born.day))\",\n \"def get_age(self):\\n today = datetime.now()\\n return today.year \\\\\\n - self.date_of_birth.year \\\\\\n - ((today.month, self.date_of_birth.day) \\\\\\n < (self.date_of_birth.month, self.date_of_birth.day))\",\n \"def get_age(self):\\n return int(CURRENT_YEAR[:4]) - self.year # String-slice only the year\",\n \"def age(self):\\n\\n years, months, days = calculate_age(self.birthdate)\\n if years:\\n return \\\"%d year%s old\\\" % (years, \\\"s\\\" if years > 1 else \\\"\\\")\\n elif months:\\n return \\\"%d month%s old\\\" % (months, \\\"s\\\" if months > 1 else \\\"\\\")\\n else:\\n return \\\"%d day%s old\\\" % (days, \\\"s\\\" if days > 1 else \\\"\\\")\",\n \"def get_file_two_years(file):\\n f = '_' + '(\\\\d+)' + '_' + '(\\\\d+)'\\n match = re.search(f, file)\\n if match:\\n return int(match.group(1)), int(match.group(2))\",\n \"def age(self):\\n today = date.today()\\n birthday = datetime.strptime(self.birt['date'], \\\"%d %b %Y\\\")\\n return birthday\",\n \"def get_age(self):\\n\\t\\treturn self.age\",\n \"def getCacheEntryAge(self, theKey):\\n theGameFile = File(self.theCacheDirectory, theKey + \\\".zip\\\")\\n if theGameFile.exists():\\n return System.currentTimeMillis() - theGameFile.lastModified()\\n return System.currentTimeMillis()\",\n \"def get_person_age(name):\\n groups = {}\\n \\n groups.update(group1)\\n groups.update(group2)\\n groups.update(group3)\\n \\n try:\\n if name.lower() in groups:\\n return groups[name.lower()]\\n else:\\n return NOT_FOUND\\n except:\\n return NOT_FOUND\\n pass\",\n \"def age(self):\\n today = datetime.date(2001, 5, 12)\\n yyyy = self.birthday[0:4]\\n mm = int(self.birthday[4:6])\\n dd = int(self.birthday[6:8])\\n dob = datetime.date(int(yyyy), mm, dd)\\n age_in_days = (today - dob).days\\n age_in_years = age_in_days / 365\\n return int(age_in_years)\",\n \"def age(self, z):\\n if self.k0 == 0.0:\\n return(self.age_flat(z))\\n fullage = self.lookback_time(np.Inf)\\n tl = self.lookback_time(z)\\n age = fullage - tl\\n return(age)\",\n \"def get_age(self):\\n age = CURRENT_YEAR - self.year\\n return age\",\n \"def getage(birth_year):\\n today = datetime.date.today()\\n print(\\\"Today is: \\\", today)\\n year = today.year\\n\\n age = year - int(birth_year)\\n # print(type(age)) you return int value by taking str\\n return age\",\n \"def findcreatedate(self):\\n try:\\n exifdata = subprocess.check_output(['exiftool', '-j', '-TAG', '-CreateDate', self.filename])\\n except OSError as e:\\n print \\\"exiftool may not be installed. Please go check.\\\"\\n print \\\"Here is the error thrown: {}\\\".format(e)\\n raise\\n\\n data = json.loads(exifdata)\\n self.createdate = date(*[int(elt) for elt in re.split('[ :]', data[0]['CreateDate'])][0:3])\\n return self.createdate\",\n \"def get_age(actor: Actor, movie: Movie) -> str:\\r\\n opening_date = dateutil.parser.parse(movie.release_date)\\r\\n birth_date = dateutil.parser.parse(actor.born)\\r\\n age = int((opening_date - birth_date).days / 365)\\r\\n return f'{actor.name} was {age} years old when {movie.title} came out.'\",\n \"def age(self, agent):\\n return (self.time - agent.born)/52.0\",\n \"def creation_date_from_exif(filename):\\n # Source: https://orthallelous.wordpress.com/2015/04/19/extracting-date-and-time-from-images-with-python/\\n with Image.open(filename) as img:\\n exif = img.getexif()\\n\\n if exif is None:\\n raise ValueError(f\\\"No exif data for {filename}\\\")\\n\\n # for subsecond prec, see doi.org/10.3189/2013JoG12J126 , sect. 2.2, 2.3\\n tags = [\\n (36867, 37521), # (DateTimeOriginal, SubsecTimeOriginal)\\n (36868, 37522), # (DateTimeDigitized, SubsecTimeDigitized)\\n (306, 37520), # (DateTime, SubsecTime)\\n ]\\n\\n for tag in tags:\\n dat = exif.get(tag[0])\\n sub = exif.get(tag[1], 0)\\n\\n # PIL.PILLOW_VERSION >= 3.0 returns a tuple\\n dat = dat[0] if isinstance(dat, tuple) else dat\\n if not dat:\\n continue\\n\\n sub = sub[0] if isinstance(sub, tuple) else sub\\n if isinstance(sub, int):\\n sub = f\\\"{sub:06d}\\\"\\n\\n date, time = dat.split(\\\" \\\")\\n date = date.replace(\\\":\\\", \\\"-\\\")\\n return fromisoformat(f\\\"{date}T{time}.{sub}\\\")\\n\\n raise ValueError(f\\\"No date found in the exif data for {filename}\\\")\",\n \"def get_age(self):\\n return Guitar.CURRENT_YEAR - self.year\",\n \"def get_age(self) -> int:\\n return self.age\",\n \"def get_file_year(filepath):\\n filename = os.path.split(filepath)[-1]\\n date = filename.split('.')[-2]\\n year = int(date.split('-')[0])\\n month = int(date.split('-')[1])\\n return year, month\",\n \"def get_age(self):\\n return CURRENT_YEAR - self.year\",\n \"def get_age(self):\\n return CURRENT_YEAR - self.year\",\n \"def get_age(self):\\n if validate_date_format(self.birt):\\n birth_year, birth_month, birth_day = change_date_format(self.birt).split('-')\\n\\n if self.alive:\\n provided_date = datetime.today().date()\\n age = (provided_date.year - int(birth_year) - ((datetime.today().month, datetime.today().day) < (int(birth_month), int(birth_day))))\\n else:\\n death_year, death_month, death_day = change_date_format(self.deat).split('-')\\n age = (int(death_year) - int(birth_year) - ((int(death_month), int(death_day)) < (int(birth_month), int(birth_day))))\\n\\n return age\",\n \"def get_age(self):\\r\\n return self.age\",\n \"def getAge(self):\\n if self.birthday == None:\\n raise ValueError\\n return (datetime.date.today() - self.birthday).days\",\n \"def getAge(self):\\n if self.birthday == None:\\n raise ValueError\\n return (datetime.date.today() - self.birthday).days\",\n \"def getAge(self):\\n if self.birthday == None:\\n raise ValueError\\n return (datetime.date.today() - self.birthday).days\",\n \"def getAge(self):\\n if self.birthday == None:\\n raise ValueError\\n return (datetime.date.today() - self.birthday).days\",\n \"def getAge(self):\\r\\n return self.age\",\n \"def get_age(self):\\n age = 2021 - self.year\\n return age\",\n \"def age(self):\\r\\n return self._age\",\n \"def parseFilename(fileName):\\n # regex to match names like Axis-BaldCA_2018-05-29T16_02_30_129496.jpg\\n # and bm-n-mobo-c__2017-06-25z11;53;33.jpg\\n regexExpanded = '([A-Za-z0-9-_]+[^_])_+(\\\\d{4}-\\\\d\\\\d-\\\\d\\\\d)T(\\\\d\\\\d)[_;](\\\\d\\\\d)[_;](\\\\d\\\\d)'\\n # regex to match diff minutes spec for subtracted images\\n regexDiff = '(_Diff(\\\\d+))?'\\n # regex to match optional crop information e.g., Axis-Cowles_2019-02-19T16;23;49_Crop_270x521x569x820.jpg\\n regexOptionalCrop = '(_Crop_(-?\\\\d+)x(-?\\\\d+)x(\\\\d+)x(\\\\d+))?'\\n matchesExp = re.findall(regexExpanded + regexDiff + regexOptionalCrop, fileName)\\n # regex to match names like 1499546263.jpg\\n regexUnixTime = '(1\\\\d{9})'\\n matchesUnix = re.findall(regexUnixTime + regexDiff + regexOptionalCrop, fileName)\\n cropInfo = None\\n if len(matchesExp) == 1:\\n match = matchesExp[0]\\n parsed = {\\n 'cameraID': match[0],\\n 'date': match[1],\\n 'hours': match[2],\\n 'minutes': match[3],\\n 'seconds': match[4]\\n }\\n isoStr = '{date}T{hour}:{min}:{sec}'.format(date=parsed['date'],hour=parsed['hours'],min=parsed['minutes'],sec=parsed['seconds'])\\n dt = dateutil.parser.parse(isoStr)\\n unixTime = int(dt.timestamp())\\n parsed['diffMinutes'] = int(match[6] or 0)\\n cropInfo = match[-4:]\\n elif len(matchesUnix) == 1:\\n match = matchesUnix[0]\\n unixTime = int(match[0])\\n dt = datetime.datetime.fromtimestamp(unixTime)\\n isoStr = datetime.datetime.fromtimestamp(unixTime).isoformat()\\n parsed = {\\n 'cameraID': 'UNKNOWN_' + fileName,\\n 'date': dt.date().isoformat(),\\n 'hours': str(dt.hour),\\n 'minutes': str(dt.minute),\\n 'seconds': str(dt.second)\\n }\\n parsed['diffMinutes'] = int(match[2] or 0)\\n cropInfo = match[-4:]\\n else:\\n logging.error('Failed to parse name %s', fileName)\\n return None\\n if cropInfo[0]:\\n parsed['minX'] = int(cropInfo[0])\\n parsed['minY'] = int(cropInfo[1])\\n parsed['maxX'] = int(cropInfo[2])\\n parsed['maxY'] = int(cropInfo[3])\\n parsed['isoStr'] = isoStr\\n parsed['unixTime'] = int(unixTime)\\n return parsed\",\n \"def get_age(self):\\n if self.birthday is None:\\n raise(ValueError('Birthday is not set.'))\\n return (datetime.date.today() - self.birthday).days\",\n \"def get_file_age_linux(path, cur_parsed, cur_datetime):\\n\\ttry:\\n\\t\\t# calls standard stat command to get file's inode\\n\\t\\tinode = subprocess.check_output([\\\"stat\\\", \\\"-c\\\", \\\"%i\\\", path])\\n\\t\\tprint(\\\"inode: \\\" + inode)\\n\\t\\tinode = int(inode)\\n\\t\\t# calls df command to get fs type\\n\\t\\tfs = subprocess.check_output([\\\"df\\\", \\\"--output=source\\\", path])\\n\\t\\tprint(\\\"fs: \\\" + fs)\\n\\t\\tfs = str(fs).split(\\\"\\\\n\\\")[1]\\n\\t\\t# calls debugfs in order to get crtime timesamp\\n\\t\\tcrtime_str = os.popen(\\\"sudo debugfs -R 'stat <\\\"+str(inode)+\\\">' \\\"+fs+\\\" | grep -E 'crtime'\\\").read()\\n\\t\\tprint(\\\"crtime: \\\"+crtime_str)\\n\\t\\tcrtime_str = crtime_str.split(\\\" -- \\\")[1]\\n\\t\\tcrtime = parse_date_str(crtime_str, ' ', 4, 1, 2)\\n\\t\\tprint(\\\"file crtime: {}\\\".format(crtime))\\n\\t\\tdate_dif = date_dif_precomputed(cur_parsed[0], cur_parsed[1], cur_parsed[2], crtime[0], crtime[1], crtime[2])\\n\\t\\treturn date_dif\\n\\texcept:\\n\\t\\texc_type, exc_value, exc_traceback = sys.exc_info()\\n\\t\\tprint(\\\"EXCEPTION! fallback to mtime!\\\")\\n\\t\\ttraceback.print_exception(exc_type, exc_value, exc_traceback, file=sys.stdout)\\n\\t\\treturn get_file_age_default(path, cur_parsed, cur_datetime)\",\n \"def get_patient_info(file_path):\\n f = open(file_path, 'rb')\\n content = f.read()\\n f.close()\\n\\n header = content[:88]\\n patient_id = header[8:88].decode('ascii')\\n # the headers \\\"fixed\\\" by tuh nedc data team show a '-' right before the age of the patient. therefore add this to\\n # the regex and use the absolute value of the casted age\\n [age] = re.findall(\\\"Age:(-?\\\\d+)\\\", patient_id)\\n [sex] = re.findall(\\\"\\\\s\\\\w\\\\s\\\", patient_id)\\n\\n sex_id = 0 if sex.strip() == 'M' else 1\\n\\n return sex_id, abs(int(age))\",\n \"def exif_date(path):\\n\\n # gets the exif data for jpg files\\n ext = path.split(\\\".\\\")[-1].lower()\\n if ext != \\\"jpg\\\":\\n return False\\n\\n with open(path, \\\"rb\\\") as image_file:\\n my_image = Image(image_file)\\n\\n if my_image.has_exif:\\n try:\\n date = datetime.datetime.strptime(my_image.datetime, \\\"%Y:%m:%d %H:%M:%S\\\")\\n print(\\\"exif date\\\", path, date)\\n except AttributeError:\\n print(\\\"attribute error on\\\", path)\\n return False\\n return date\\n\\n return False\",\n \"def compute_age(epoch):\\n birth_date = datetime.datetime.fromtimestamp(epoch/1000)\\n now = datetime.datetime.now()\\n age = (now - birth_date).days / 365\\n return age\",\n \"def age_diff(self, other):\\n diff = self.age - other.age\\n print(abs(diff), \\\"year difference\\\")\",\n \"def get_age(self):\\n return self.glb[iage]\",\n \"def calculate_age(born):\\n today = datetime.date.today()\\n return today.year - born.year - ((today.month, today.day) < (born.month, born.day))\",\n \"def _find_average_age():\\r\\n count, total = 0, 0\\r\\n for resource in resources:\\r\\n patient = resource[\\\"resource\\\"]\\r\\n if \\\"birthDate\\\" in patient:\\r\\n count += 1\\r\\n dob = patient[\\\"birthDate\\\"].split(\\\"-\\\")\\r\\n dob = datetime(int(dob[0]), int(dob[1]), int(dob[2]), 0, 0, 0, 0)\\r\\n if \\\"deceasedDateTime\\\" in patient:\\r\\n death_time = patient[\\\"deceasedDateTime\\\"].split(\\\"T\\\")[0].split(\\r\\n \\\"-\\\")\\r\\n death_time = datetime(int(death_time[0]), int(death_time[1]),\\r\\n int(death_time[2]), 0, 0, 0, 0)\\r\\n else:\\r\\n death_time = datetime.now()\\r\\n age = relativedelta(death_time, dob).years\\r\\n total += age\\r\\n if count == 0:\\r\\n return count, count\\r\\n return total / count, count\",\n \"def _get_age(self):\\n for employee in self:\\n if employee.sudo().birthday:\\n employee.age = relativedelta(\\n fields.Date.from_string(fields.Date.today()),\\n fields.Date.from_string(employee.sudo().birthday)).years\\n else:\\n employee.age = 0\",\n \"def age(self):\\n return self.__age\",\n \"def getFileModifTime(filename):\\n\\tfilename = adaptPath(filename)\\n\\tfrom os import stat\\n\\ttry:\\n\\t\\tresult = stat(filename).st_mtime\\n\\texcept:\\n\\t\\tresult = 0\\n\\treturn result\",\n \"def getAge(self):\\n if self.setBirthday == None:\\n raise ValueError\\n return (datetime.date.today() - self.birthday).days\",\n \"def parse_info_from_file(path):\\n try:\\n filename = os.path.split(path)[1]\\n filename = os.path.splitext(filename)[0]\\n age, gender, race, _ = filename.split('_')\\n\\n return int(age), dataset_dict['gender_id'][int(gender)], dataset_dict['race_id'][int(race)]\\n except Exception as ex:\\n return None, None, None\",\n \"def get_year(self, filename):\\n year = self.file.replace('s24_', '').replace('.vrt', '')\\n self.logger.info(f'This .vrt file contains data for the year {year}')\\n return year\",\n \"def getAge(self):\\n return self.age\",\n \"def _get_age(self):\\n return self.__age\",\n \"def parse_patient_age(age):\\n if age == 'None' or not age:\\n return None\\n\\n conversion = { # conversion to days\\n 'Y': 365,\\n 'M': 30,\\n 'W': 7,\\n 'D': 1,\\n }\\n scale = age[-1:]\\n value = age[:-1]\\n if scale not in conversion.keys():\\n # Assume years\\n scale = 'Y'\\n value = age\\n\\n age_in_seconds = datetime.timedelta(int(value) * conversion.get(scale)).total_seconds()\\n\\n # Make sure that the age is reasonable\\n if not age_in_seconds or age_in_seconds <= 0:\\n age_in_seconds = None\\n\\n return age_in_seconds\",\n \"def filter_by_age(files, comparator):\\n today = date.today()\\n results = []\\n for f in files:\\n m = DATE_REGEX.search(f)\\n if not m:\\n continue\\n f_date = date(int(m.group(1)), int(m.group(2)), int(m.group(3)))\\n\\n if comparator(today - f_date):\\n results.append((f_date, f))\\n\\n results.sort()\\n return [f for _, f in results]\",\n \"def get_age(date):\\n today = datetime.date.today()\\n return today.year - date.year - ((today.month, today.day) < (date.month, date.day))\",\n \"def get_exif_data(fname):\\n ret = {}\\n try:\\n img = Image.open(fname)\\n if hasattr( img, '_getexif' ):\\n exifinfo = img._getexif()\\n if exifinfo != None:\\n for tag, value in exifinfo.items():\\n decoded = TAGS.get(tag, tag)\\n ret[decoded] = value\\n except IOError:\\n print ('IOERROR ' + fname)\\n return ret\",\n \"def get_age(self):\\n return self._age\",\n \"def get_age(self):\\n return self._age\",\n \"def get_age(self):\\n return self._age\",\n \"def parse_age_actor(soup, pageurl):\\n\\tage = None\\n\\t# search for class containing age\\n\\tage_span = soup.findAll('span', { 'class' : 'noprint ForceAgeToShow' });\\n\\tif len(age_span) == 0:\\n\\t\\t# check if actor is dead.\\n\\t\\tdeath_span = soup.findAll('span', {'class': 'deathplace'})\\n\\t\\t# if actor is dead, need to parse slightly differently to get age\\n\\t\\tif len(death_span) != 0:\\n\\t\\t\\ts = death_span[0].find_parent().get_text()\\n\\t\\t\\tidx = s.index('aged')\\n\\t\\t\\tend_idx = s[idx:].index(')')\\n\\t\\t\\ts = s[idx:idx+end_idx]\\n\\t\\t\\tage = [int(s) for s in s.split() if s.isdigit()]\\n\\t\\t\\t# entry did not contain age, likely only contained deathplace.\\n\\t\\t\\tif len(age) == 0:\\n\\t\\t\\t\\tlogging.warning('' + pageurl + ' does not contain an age for the actor and will not be parsed')\\n\\t\\t\\t\\treturn None\\n\\t\\t\\tage = age[0]\\n\\t\\t# if actor is not dead and no age field, no other way to get age\\n\\t\\telse:\\n\\t\\t\\tlogging.warning('' + pageurl + ' does not contain an age for the actor and will not be parsed')\\n\\t\\t\\treturn None\\n\\t# clean the input and cast to int\\n\\tif age == None:\\n\\t\\tage = int(age_span[0].next[1:-1].split()[1])\\n\\treturn age\",\n \"def get_age(self):\\n return self.__age\",\n \"def find_age(row):\\n #pass\\n today = datetime.datetime.today()\\n try:\\n x = round((today - row).days/365)\\n except ValueError:\\n x = np.nan\\n return x\",\n \"def age():\\n return 1\\n import os\\n\\n #imported_xls_data[x][1] = age of participant (i.e.adult or child)\\n self.age = 1\\n #imported_xls_data[x][2] = event (i.e. hit or miss)\\n self.event = 2\\n #imported_xls_data[x][3] = the target (i.e. Dispense, dispensor Controls, Fridge door (dispensor side), Fridge door (no dispensor), Freezer Door)\\n self.target = 3\\n\\n #Entering the mat\\n #imported_xls_data[x][4] = foot distance of the 1st step onto the MAT with LEFT foot (in inches)\\n self.firstLEFTradius_in = 4\\n #imported_xls_data[x][5] = angle of the 1st step onto the MAT with LEFT foot (in degrees)\\n self.firstLEFTdegrees = 5\\n #imported_xls_data[x][6] = timestamp of the 1st step onto the MAT with LEFT foot (in 00:00:000 hours, mins, milliseconds)\\n self.firstLEFTtstamp = 6\\n #imported_xls_data[x][7] = foot distance of the 1st step onto the MAT with RIGHT foot (in inches)\\n self.self.firstRIGHTradius_in = 7\\n #imported_xls_data[x][8] = angle of the 1st step onto the MAT with RIGHT foot (in degrees)\\n self.firstRIGHTdegrees = 8\\n #imported_xls_data[x][9] = timestamp of the 1st step onto the MAT with RIGHT foot (in 00:00:000 hours, mins, milliseconds)\\n self.firstRIGHTtstamp = 9\\n\\n #Arriving at the fridge\\n #imported_xls_data[x][10] = foot distance of the LEFT foot at fridge (if a hit) (in inches)\\n self.atfridgeLEFTradius_in = 10\\n #imported_xls_data[x][11] = angle of the LEFT foot at fridge (if a hit) (in degrees)\\n self.atfridgeLEFTdegrees = 11\\n #imported_xls_data[x][12] = timestamp of the LEFT foot at fridge (if a hit) (in 00:00:000 hours, mins, milliseconds)\\n self.atfridgeLEFTtstamp = 12\\n #imported_xls_data[x][13] = foot distance of the RIGHT foot at fridge (if a hit) (in inches)\\n self.atfridgeRIGHTradius_in = 13\\n #imported_xls_data[x][14] = angle of the RIGHT foot at fridge (if a hit) (in degrees)\\n self.atfridgeRIGHTdegrees = 14\\n #imported_xls_data[x][15] = timestamp of the RIGHT foot at fridge (if a hit) (in 00:00:000 hours, mins, milliseconds)\\n self.atfridgeRIGHTtstamp = 15\\n\\n\\n\\n\\n #Leaving the mat\\n #imported_xls_data[x][16] = foot distance of the Last LEFT foot step before leaving mat (in inches)\\n self.lastLEFTradius_in = 16\\n #imported_xls_data[x][17] = angle of the Last LEFT foot step before leaving mat (in degrees)\\n self.lastLEFTdegrees = 17\\n #imported_xls_data[x][18] = timestamp of the Last LEFT foot step before leaving mat (in 00:00:000 hours, mins, milliseconds)\\n self.lastLEFTtstamp = 18\\n #imported_xls_data[x][19] = foot distance of the Last RIGHT foot step before leaving mat: (in inches)\\n self.lastRIGHTradius_in = 19\\n #imported_xls_data[x][20] = angle of the Last RIGHT foot step before leaving mat: (in degrees)\\n self.lastRIGHTdegrees = 20\\n #imported_xls_data[x][21] = timestamp of the Last RIGHT foot step before leaving mat: (in 00:00:000 hours, mins, milliseconds)\\n self.lastRIGHTtstamp = 21\",\n \"def _isAge(self, words, index):\\n start = index\\n length = len(words)\\n \\n # [age[:]] number [yr/yrs] [old]\\n if words[index]['word'] == 'age':\\n index += 1\\n if index == length:\\n return None, 0\\n if words[index]['word'] == ':':\\n index += 1\\n if index == length:\\n return None, 0\\n age_key = True\\n else:\\n age_key = False\\n \\n if not words[index]['word'].isdigit():\\n return None, 0\\n \\n age = words[index]['word']\\n \\n index += 1\\n if index < length:\\n if words[index]['word'] in [ 'yr', 'yrs', 'year', 'years' ]:\\n age_key = True\\n index += 1\\n if index < length:\\n if words[index]['word'] == 'old':\\n index += 1\\n \\n if age_key:\\n return age, index - start - 1\\n \\n return None, 0\",\n \"def get_imageId_from_fileName(filename):\\n filename = os.path.splitext(filename)[0]\\n if filename.isdigit():\\n return int(filename)\\n return id_iter\",\n \"def exif_timestamp(filename):\\n # PIL lazy-loads the image data, so this open and _getexif() is fast.\\n img = PIL.Image.open(filename)\\n if ('exif' not in img.info.keys()) or (not hasattr(img, '_getexif')):\\n raise exceptions.ICExifReadError(f\\\"no EXIF data found in {filename}\\\")\\n # Avoid constucting the whole EXIF dict just to extract the DateTime field.\\n # DateTime -> key 306 is in the EXIF standard, so let's use that directly.\\n ## date_time = {TAGS[k] : v for k,v in exif.items()}['DateTime']\\n exif = img._getexif()\\n key = 306\\n if key not in exif.keys():\\n raise exceptions.ICExifReadError(f\\\"key 306 (DateTime) not found in \\\"\\n f\\\"EXIF data of file {filename}\\\")\\n # '2019:03:10 22:42:42'\\n date_time = exif[key]\\n if date_time.count(':') != 4:\\n msg = f\\\"unsupported EXIF DateTime format in '{date_time}' of {filename}\\\"\\n raise exceptions.ICExifReadError(msg)\\n # '2019:03:10 22:42:42' -> ['2019', '03', '10', '22', '42', '42']\\n date_time_str = date_time.replace(':', ' ').split()\\n names = ('year', 'month', 'day', 'hour', 'minute', 'second')\\n stamp = datetime.datetime(**{nn:int(vv) for nn,vv in zip(names,date_time_str)},\\n tzinfo=datetime.timezone.utc).timestamp()\\n return stamp\",\n \"def _get_average_age(self):\\n sql = \\\"\\\"\\\"\\n SELECT AVG(age) as avg_age\\n FROM(\\n SELECT DATE_PART('year', AGE(now(), birth_date)) as age\\n FROM {schema}.participant_match\\n WHERE birth_date is not null\\n ) x\\n \\\"\\\"\\\".format(schema=self.database.schema)\\n df = pd.read_sql(sql, self.database.connection)\\n avg_age = None\\n if len(df) > 0:\\n avg_age = df.loc[0]['avg_age']\\n return avg_age\",\n \"def get_exif_data(filename):\\n ret = {}\\n try:\\n img = Image.open(filename)\\n if hasattr( img, '_getexif' ):\\n exifinfo = img._getexif()\\n if exifinfo != None:\\n for tag, value in exifinfo.items():\\n decoded = TAGS.get(tag, tag)\\n ret[decoded] = value\\n except IOError:\\n print 'IOERROR ' + filename\\n return ret\",\n \"def oldest_person_dc(all_profile_dict: dict) -> float:\\n \\\"\\\"\\\"Param:all_profile_dc: dictionary containing all profiles\\\"\\\"\\\"\\n value = min(all_profile_dict.values(), key=lambda v: v['birthdate'])\\n date_today = datetime.date.today()\\n age = (date_today - value['birthdate']).days\\n return int(age/365)\",\n \"def get_exif_data(fname):\\n ret = {}\\n try:\\n img = Image.open(StringIO.StringIO(fname))\\n if hasattr( img, '_getexif' ):\\n exifinfo = img._getexif()\\n if exifinfo != None:\\n for tag, value in exifinfo.items():\\n decoded = TAGS.get(tag, tag)\\n ret[decoded] = value\\n except IOError:\\n print 'IOERROR ' + fname\\n return ret\",\n \"def num_older_than(age: float) -> int:\\r\\n cur = con.cursor()\\r\\n count_older = cur.execute(\\r\\n \\\"\\\"\\\"SELECT COUNT(Patient_ID)\\r\\n FROM Patient\\r\\n WHERE (JULIANDAY('now') - JULIANDAY(Date_Of_Birth)) / ? > ?\\\"\\\"\\\",\\r\\n [DAYS_IN_YEAR, age],\\r\\n ).fetchall()\\r\\n\\r\\n return count_older[0][0]\",\n \"def retrieve_geotiff_metadata(sFilename_geotiff_in):\\n pDriver = gdal.GetDriverByName('GTiff')\\n \\n pDataset = gdal.Open(sFilename_geotiff_in, gdal.GA_ReadOnly)\\n\\n if pDataset is None:\\n print(\\\"Couldn't open this file: \\\" + sFilename_geotiff_in)\\n sys.exit(\\\"Try again!\\\")\\n else: \\n pProjection = pDataset.GetProjection()\\n pSpatial_reference = osr.SpatialReference(wkt=pProjection) \\n ncolumn = pDataset.RasterXSize\\n nrow = pDataset.RasterYSize \\n pGeotransform = pDataset.GetGeoTransform()\\n dOriginX = pGeotransform[0]\\n dOriginY = pGeotransform[3]\\n dPixelWidth = pGeotransform[1]\\n pPixelHeight = pGeotransform[5] \\n return dPixelWidth, dOriginX, dOriginY, nrow, ncolumn, pSpatial_reference, pProjection, pGeotransform\",\n \"def _get_diameter(self,filename,maxLen=3):\\n filename = os.path.splitext(filename)[0] \\n filename = os.path.split(filename)[1] \\n filename = filename.split(\\\"_\\\",3)[2] \\n diameter = filename \\n return diameter\",\n \"def oldest_person_nt(all_profile_nt: namedtuple) -> float:\\n \\\"\\\"\\\"Param: all_profile_nt: Named tuple containing all profiles\\\"\\\"\\\"\\n value = min(all_profile_nt, key=lambda v: v[-1])\\n date_today = datetime.date.today()\\n age = (date_today - value.birthdate).days\\n return int(age/365)\",\n \"def age(self):\\n # TODO(user) move up to AFF4Object after some analysis of how .age is\\n # used in the codebase.\\n aff4_type = self.Get(self.Schema.TYPE)\\n\\n if aff4_type:\\n return aff4_type.age\\n else:\\n # If there is no type attribute yet, we have only just been created and\\n # not flushed yet, so just set timestamp to now.\\n return rdfvalue.RDFDatetime().Now()\",\n \"def calc_age_in_seconds(self, number_years):\\n\\t\\thours = self.calc_hours_in_a_year(number_years)\\n\\t\\t\\n\\t\\treturn hours * 60 * 60\",\n \"def __file_sorter(self, filename: str) -> int:\\n filename = filename.split('/')[-1]\\n year = int(filename[-3:-1]) # extracts YY from ssssdddh.YYo\\n day_info = filename[4:8] # extracts dddh from ssssdddh.YYo\\n day_of_year = int(day_info[:3]) # ddd\\n hour_block = day_info[-1] # h\\n if hour_block.isdigit():\\n return (year, day_of_year)\\n return (year, day_of_year + ord(hour_block))\",\n \"def extract_exif(fname):\\n\\n try:\\n # check if file has EXIF date, exception if not\\n exif_data = fileops.get_exif_datetimeorig_tag(fname)\\n\\n # extract the date/time string from EXIF, exception if\\n # not the proper format\\n datetimestr = exif_to_datetimestr(exif_data)\\n\\n logging.debug(\\\"Found EXIF Tag %r for file %r\\\", datetimestr, \\n os.path.basename(fname))\\n\\n return datetimestr\\n\\n except fileops.EXIFTagError:\\n logging.warning(\\\"%r does not have a proper EXIF tag\\\",\\n os.path.basename(fname))\\n return \\\"\\\";\\n\\n except DateStrError:\\n logging.warning(\\\"%r EXIF tag not the right format\\\",\\n os.path.basename(fname))\\n return \\\"\\\";\",\n \"def profile_photo(self):\\n images_directory_index = 6\\n filepath = None\\n photo = self.profile_photo_path\\n if photo is not None:\\n photo_dir = photo.split(\\\"/\\\")[images_directory_index:]\\n filepath = \\\"/\\\".join(photo_dir)\\n return filepath\",\n \"def get_date(img):\\n exif = img.getexif()\\n date = exif.get(306)\\n if date is not None:\\n date = date.replace(' ', '-').replace(':', '')\\n return date\",\n \"def _get_info_from_filename(filename: str) -> dict:\\n *parts, suffix = filename.split('.')\\n dct = re.match(r'^(?P<name>[A-z0-9.]*)(-(?P<num_rows>[0-9]+))?$', '.'.join(parts)).groupdict()\\n return {\\n 'name': dct['name'],\\n 'num_rows': int(dct['num_rows']) if dct['num_rows'] else None,\\n 'format': suffix,\\n }\",\n \"def get_cached_data_age(name):\\n cache_path = get_cachefile('%s.cache' % name)\\n if not os.path.exists(cache_path):\\n return 0\\n return time.time() - os.stat(cache_path).st_mtime\",\n \"def photo(self):\\n person = self.get_person()\\n if person is None:\\n return None\\n return person.photo\",\n \"def get_age(YY_OF_BIRTH, MM_OF_BIRTH, DD_OF_BIRTH):\\n\\n date_ = date.today()\\n year = date_.year\\n month = date_.month\\n day = date_.day\\n\\n age = year - YY_OF_BIRTH\\n\\n if (month < MM_OF_BIRTH):\\n age -= 1\\n elif (month == MM_OF_BIRTH):\\n if (day < DD_OF_BIRTH):\\n age -= 1\\n\\n return age\",\n \"def calculate_current_age(dob):\\n today = datetime.date.today()\\n years = today.year - dob.year\\n if today.month < dob.month or (today.month == dob.month and today.day < dob.day):\\n years -= 1\\n return years\",\n \"def age(self):\\n delta = now() - self.creation\\n return delta.seconds\",\n \"def read_file(filename):\\n\\tprint(\\\"Beginning file read...\\\")\\n\\tmy_image = cv2.imread(filename)\\n\\treturn computer_hash(my_image)\",\n \"def _set_age(cls, data):\\n birth = data.get(\\\"birth\\\")\\n if birth:\\n today = datetime.now().date()\\n data[\\\"age\\\"] = relativedelta(today, birth).years\\n return data\",\n \"def test_jpeg_exif(h, f):\\n if h[6:10].lower() == 'exif':\\n return 'jpeg'\",\n \"def __get_modification_time(filename: str) -> float:\\n return os.stat(filename).st_mtime\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6539053","0.63929635","0.6130632","0.6126099","0.60076624","0.59946716","0.5988924","0.5957687","0.5947357","0.5931525","0.5921615","0.5881921","0.5782887","0.57811505","0.5766714","0.5723021","0.57115793","0.5673089","0.5648261","0.56320405","0.56107926","0.5605629","0.5579449","0.55765206","0.55706024","0.55545896","0.5523439","0.55152476","0.5496826","0.54910904","0.54862773","0.54716825","0.5458666","0.5450982","0.5450982","0.5448989","0.5436019","0.5423913","0.5423913","0.5423913","0.5423913","0.54224336","0.541857","0.5415534","0.5410759","0.5406945","0.5386395","0.5385943","0.53827363","0.53764266","0.5365464","0.5360333","0.53508717","0.5350206","0.5344552","0.53444","0.53428364","0.5337172","0.5334575","0.53311133","0.5322131","0.53145224","0.5309135","0.52929664","0.52831465","0.5261734","0.5247704","0.5247704","0.5247704","0.5245512","0.52453387","0.52185893","0.5210147","0.520774","0.5207642","0.51945454","0.519345","0.5192581","0.51896626","0.51890576","0.5180537","0.51699436","0.51693195","0.5165273","0.5160096","0.5153853","0.51292855","0.51245046","0.5124421","0.5122522","0.5121559","0.5119851","0.5118712","0.5110687","0.51092935","0.51068157","0.50858045","0.5085099","0.5073604","0.50672275"],"string":"[\n \"0.6539053\",\n \"0.63929635\",\n \"0.6130632\",\n \"0.6126099\",\n \"0.60076624\",\n \"0.59946716\",\n \"0.5988924\",\n \"0.5957687\",\n \"0.5947357\",\n \"0.5931525\",\n \"0.5921615\",\n \"0.5881921\",\n \"0.5782887\",\n \"0.57811505\",\n \"0.5766714\",\n \"0.5723021\",\n \"0.57115793\",\n \"0.5673089\",\n \"0.5648261\",\n \"0.56320405\",\n \"0.56107926\",\n \"0.5605629\",\n \"0.5579449\",\n \"0.55765206\",\n \"0.55706024\",\n \"0.55545896\",\n \"0.5523439\",\n \"0.55152476\",\n \"0.5496826\",\n \"0.54910904\",\n \"0.54862773\",\n \"0.54716825\",\n \"0.5458666\",\n \"0.5450982\",\n \"0.5450982\",\n \"0.5448989\",\n \"0.5436019\",\n \"0.5423913\",\n \"0.5423913\",\n \"0.5423913\",\n \"0.5423913\",\n \"0.54224336\",\n \"0.541857\",\n \"0.5415534\",\n \"0.5410759\",\n \"0.5406945\",\n \"0.5386395\",\n \"0.5385943\",\n \"0.53827363\",\n \"0.53764266\",\n \"0.5365464\",\n \"0.5360333\",\n \"0.53508717\",\n \"0.5350206\",\n \"0.5344552\",\n \"0.53444\",\n \"0.53428364\",\n \"0.5337172\",\n \"0.5334575\",\n \"0.53311133\",\n \"0.5322131\",\n \"0.53145224\",\n \"0.5309135\",\n \"0.52929664\",\n \"0.52831465\",\n \"0.5261734\",\n \"0.5247704\",\n \"0.5247704\",\n \"0.5247704\",\n \"0.5245512\",\n \"0.52453387\",\n \"0.52185893\",\n \"0.5210147\",\n \"0.520774\",\n \"0.5207642\",\n \"0.51945454\",\n \"0.519345\",\n \"0.5192581\",\n \"0.51896626\",\n \"0.51890576\",\n \"0.5180537\",\n \"0.51699436\",\n \"0.51693195\",\n \"0.5165273\",\n \"0.5160096\",\n \"0.5153853\",\n \"0.51292855\",\n \"0.51245046\",\n \"0.5124421\",\n \"0.5122522\",\n \"0.5121559\",\n \"0.5119851\",\n \"0.5118712\",\n \"0.5110687\",\n \"0.51092935\",\n \"0.51068157\",\n \"0.50858045\",\n \"0.5085099\",\n \"0.5073604\",\n \"0.50672275\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68865573"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83196,"cells":{"query":{"kind":"string","value":"Finds the filename in a path."},"document":{"kind":"string","value":"def extract_filename(str):\n regex = r\"([0-9_-]+).jpg\"\n matches = re.search(regex, str)\n if matches:\n return matches.group(1)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def search_file(filename, search_path, pathsep=os.pathsep):\n for path in string.split(search_path, pathsep):\n candidate = os.path.join(path, filename)\n if os.path.exists(candidate): return os.path.abspath(candidate)\n return None","def search_file(filename, search_path, pathsep=os.pathsep):\n for path in string.split(search_path, pathsep):\n candidate = os.path.join(path, filename)\n if os.path.exists(candidate): return os.path.abspath(candidate)\n return None","def search_file(filename, search_path):\n file_path = None\n for path in search_path:\n if exists(join(path, filename)):\n file_path = path\n break\n if file_path:\n return abspath(join(file_path, filename))\n return None","def findInPath(fileName):\n\timport posixpath\n\tfor pathdir in ([\".\"]+sys.path):\n\t\tif posixpath.isfile(pathdir+\"/\"+fileName):\n\t\t\treturn pathdir+\"/\"+fileName","def find_file(filename):\n for i in list(_ctx.include_paths) + [ os.path.dirname(_ctx.filename) ]:\n full_path = os.path.join(i, filename)\n if os.path.exists(full_path):\n return full_path\n return filename # failure gets handled later on","def find_file(file_name):\n if (pathlib.Path(file_name).resolve()):\n file_name = str(file_name)\n logging.info(f' found {file_name}.')\n return file_name\n else:\n logging.error(f' no file {file_name} found for processing.')\n sys.exit()","def _findfile(self, path):\n\n # Build list of possible local file paths\n if not self._isurl(path):\n # Valid local paths\n filelist = self._possible_names(path)\n # Paths in self._destpath\n filelist += self._possible_names(self.abspath(path))\n else:\n # Cached URLs in self._destpath\n filelist = self._possible_names(self.abspath(path))\n # Remote URLs\n filelist = filelist + self._possible_names(path)\n\n for name in filelist:\n if self.exists(name):\n if self._isurl(name):\n name = self._cache(name)\n return name\n return None","def find_in_PATH(filename: str):\n if path.isfile(filename):\n return path.normpath(filename)\n\n os_paths = os.environ['PATH'].split(path.pathsep)\n for os_path in os_paths:\n fullpath_file = path.join(os_path, filename)\n if path.isfile(fullpath_file):\n return path.normpath(fullpath_file)\n raise FileNotFoundError(f'could not find {filename}')","def find_file(path):\n return NotImplemented","def find(name):\n\n if os.path.exists(name):\n return name\n\n path = os.path.dirname(__file__) or '.'\n filename = os.path.abspath(os.path.join(path,name))\n if os.path.exists(filename):\n return filename\n\n for d in os.listdir(path):\n fullpath = os.path.abspath(os.path.join(path,d))\n if os.path.isdir(fullpath):\n filename = os.path.abspath(os.path.join(fullpath,name))\n if os.path.exists(filename):\n return filename\n return None","def find_in_path(filenames):\n # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52224\n from os.path import exists, join, abspath\n from os import pathsep, environ\n search_path = environ[\"PATH\"]\n paths = search_path.split(pathsep)\n for path in paths:\n for filename in filenames:\n if exists(join(path, filename)):\n return abspath(join(path, filename))","def search_file(file_name, search_path):\n if os.path.exists(search_path):\n filenames = os.listdir(search_path)\n for filename in filenames:\n if file_name in filenames:\n return os.path.join(search_path, file_name)\n return None","def _FindPathSpec(self, path, filename):\n # TODO: determine why this first find is used add comment or remove.\n # It does not appear to help with making sure path segment separate\n # is correct.\n find_spec = file_system_searcher.FindSpec(\n location=path, case_sensitive=False)\n path_specs = list(self._searcher.Find(find_specs=[find_spec]))\n\n if not path_specs or len(path_specs) != 1:\n raise IOError(\n u'Unable to find directory: {0:s}'.format(path))\n\n relative_path = self._searcher.GetRelativePath(path_specs[0])\n if not relative_path:\n raise IOError(u'Unable to determine relative path of: {0:s}'.format(path))\n\n # The path is split in segments to make it path segement separator\n # independent (and thus platform independent).\n path_segments = self._searcher.SplitPath(relative_path)\n path_segments.append(filename)\n\n find_spec = file_system_searcher.FindSpec(\n location=path_segments, case_sensitive=False)\n path_specs = list(self._searcher.Find(find_specs=[find_spec]))\n\n if not path_specs:\n raise IOError(\n u'Unable to find file: {0:s} in directory: {1:s}'.format(\n filename, relative_path))\n\n if len(path_specs) != 1:\n raise IOError((\n u'Find for file: {0:s} in directory: {1:s} returned {2:d} '\n u'results.').format(filename, relative_path, len(path_specs)))\n\n if not relative_path:\n raise IOError(\n u'Missing file: {0:s} in directory: {1:s}'.format(\n filename, relative_path))\n\n return path_specs[0]","def search_on_path(filenames):\n # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52224\n\n from os.path import exists, join, abspath\n from os import pathsep, environ\n\n search_path = environ[\"PATH\"]\n\n paths = search_path.split(pathsep)\n for path in paths:\n for filename in filenames:\n if exists(join(path, filename)):\n return abspath(join(path, filename))","def _findfile(self, path):\n return DataSource._findfile(self, self._fullpath(path))","def _find(self, path):\n try:\n self.log.debug(\"Searching for '%s'\" % path)\n os.stat(path)\n self.log.debug(\" found!\")\n return path\n except OSError:\n self.log.debug(\" not found!\")\n segs = path.split(os.path.sep)\n found_parent = os.path.sep\n assert segs[0] == '' # expect a leading /\n for i in range(1, len(segs)): # start after leading /\n try:\n parent = os.path.sep.join(segs[:i+1])\n self.log.debug(\" searching parent %d %s\" % (i, str(parent)))\n os.stat(parent)\n self.log.debug(\" found\")\n found_parent = parent\n except OSError:\n self.log.debug(\" NOT found\")\n break\n\n # does the found_parent dir contain a differently-cased version of the requested path?\n candidates = [f for f in os.listdir(found_parent) if f.lower() == segs[i].lower()]\n self.log.debug(' Candidates: %s' % str(candidates))\n if candidates:\n if len(candidates) > 1:\n self.log.warn('Case ambiguity: %s%s{%s}' % (found_parent, os.path.sep, ','.join(candidates)))\n segs[i] = candidates[0]\n path = os.path.sep.join(segs)\n if i < (len(segs)-1):\n self.log.debug('recursing')\n path = self._find(path) # recursively search with the new case-corrected path segment\n\n self.log.debug('resolved to [or failed with] path: %s' % path)\n\n # returns path unmodified if we were unable to find case-corrected candidates.\n # expects underlying command implementations to handle file-not-found correctly if so.\n return path","def checkFilePath(self, filename, searchpath=[]):\n\t\tif filename is None:\n\t\t\treturn None\n\t\telif os.path.isfile(filename):\n\t\t\treturn filename\n\t\telse:\n\t\t\t# Append current dir to searchpath and try each in turn\n\t\t\tsearchpath.append(os.path.dirname(__file__))\n\t\t\t# print(searchpath)\n\t\t\tfor folder in searchpath:\n\t\t\t\tfilepath = os.path.join(folder, filename)\n\t\t\t\tif os.path.isfile(filepath):\n\t\t\t\t\treturn filepath\n\n\t\t# File not found\n\t\treturn None","def Filename(fname):\n if fname.startswith('##/'):\n if chroot_path:\n fname = os.path.join(chroot_path, fname[3:])\n else:\n return None\n\n # Search for a pathname that exists, and return it if found\n if fname and not os.path.exists(fname):\n for path in search_paths:\n pathname = os.path.join(path, os.path.basename(fname))\n if os.path.exists(pathname):\n return pathname\n\n # If not found, just return the standard, unchanged path\n return fname","def find_file(path, filename, max_depth=5):\n for root, dirs, files in os.walk(path):\n if filename in files:\n return os.path.join(root, filename)\n\n # Don't search past max_depth\n depth = root[len(path) + 1:].count(os.sep)\n if depth > max_depth:\n del dirs[:] # Clear dirs\n return None","def findFile(PATH, PATTERN):\n\t#### find all the file located in the PATH corresponding to the PATTERN\n\tfindPattern = subprocess.Popen('find {path} -name \"{pattern}\" 2> /dev/null'.format(path=PATH, pattern=PATTERN), shell=True, stdout=subprocess.PIPE);\n\t#### String containing all the path toward the file's name matching with the pattern\n\treturn findPattern.stdout.read().decode(\"utf-8\").strip().split(\"\\n\")","def getfilename(path):\r\n return path.split('\\\\').pop().split('/').pop().rsplit('.', 1)[0]","def getFilename(path):\n\tfrom os.path import split\n\tpath = normalizePath(path)\n\treturn split(path)[1]","def find_in_paths(name, paths):\n for path in paths:\n file_ = osp.join(path, name)\n if osp.exists(file_) and not osp.isdir(file_):\n abs_file = osp.abspath(file_)\n if os.access(file_, os.X_OK):\n return abs_file","def findInPath (exe):\n\n\tfor dirname in os.environ['PATH'].split (os.path.pathsep):\n\t\tpossible = os.path.join (dirname, exe)\n\t\tif os.path.isfile (possible):\n\t\t\treturn possible\n\n\t# Not found\n\traise NotFoundInPathException (exe)","def SearchPath(name):\n search_path = os.getenv('PATH', os.defpath).split(os.pathsep)\n for directory in search_path:\n if directory:\n path = os.path.join(directory, name)\n if os.path.isfile(path) and os.access(path, os.X_OK):\n return path\n return None","def find_file(filesystem, dirs, filename):\r\n for directory in dirs:\r\n filepath = path(directory) / filename\r\n if filesystem.exists(filepath):\r\n return filepath\r\n raise ResourceNotFoundError(u\"Could not find {0}\".format(filename))","def findPath(self, name=None, pattern=None, extension=None, ignorePatterns=None,\n path=None, paths=None):\n paths = self.findPaths(name, pattern, extension, ignorePatterns, path, paths)\n if paths: # If anything found, then answer the first one.\n return paths[0]\n return None","def get_filename(path):\n return path.split('/')[-1]","def find_binary_in_path(filename: str) -> str:\n if \"PATH\" not in os.environ:\n raise PATHNotFoundError\n for directory in os.environ[\"PATH\"].split(os.pathsep):\n binary = os.path.abspath(os.path.join(directory, filename))\n if os.path.isfile(binary) and os.access(binary, os.X_OK):\n return binary\n raise BinaryNotFoundError","def find_file_by_name(point,target):\n launcher_path = \"\"\n for (path, dir, files) in os.walk(point):\n for filename in files:\n # if target in filename:\n if filename == target:\n launcher_path = os.path.join(path, filename)\n return launcher_path","def find_one(path, filenames):\n for _path in find_all(path, filenames):\n return _path\n return ''","def _findfile(self,path,label):\n files=[];filenames=os.listdir(path)\n for name in filenames:\n if os.path.splitext(name)[0]==str(label):\n files.append(name)\n return files","def recursively_find_file(folder, file_name):\n # TODO: print a hint when not founding file_name","def _find_file(self, name, check_dir='c_files'):\n testdir = os.path.dirname(__file__)\n name = os.path.join(testdir, check_dir, name)\n return name","def locate_file(fname):\n out = []\n if platform._is_win: # pragma: windows\n out += find_all(fname, None)\n else:\n for path in os.environ.get('PATH').split(os.pathsep):\n if path:\n out += find_all(fname, path)\n if not out:\n return False\n first = out[0]\n if len(out) > 1:\n # pprint.pprint(out)\n warnings.warn(\"More than one (%d) match to %s. Using first match (%s)\" % (\n len(out), fname, first))\n return first","def _find_ref_fname(fname, ref_fname):\n curr_dir = \"\"\n next_dir = os.path.dirname(os.path.abspath(fname))\n while next_dir != curr_dir:\n curr_dir = next_dir\n rcfile = os.path.join(curr_dir, ref_fname)\n if os.path.exists(rcfile):\n return rcfile\n next_dir = os.path.dirname(curr_dir)\n return \"\"","def _lookupFileName (self,\n enclosingDirectoryName : String,\n originalFileName : String) -> String:\n\n Logging.trace(\">>: directory = %r, file = %r\",\n enclosingDirectoryName, originalFileName)\n\n cls = self.__class__\n result = None\n separator = OperatingSystem.pathSeparator\n simpleFileName = OperatingSystem.basename(originalFileName)\n searchPathList = list(cls._searchPathList)\n searchPathList.append(enclosingDirectoryName)\n\n for directoryName in searchPathList:\n fileName = iif(directoryName == \".\", originalFileName,\n directoryName + separator + simpleFileName)\n isFound = OperatingSystem.hasFile(fileName)\n Logging.trace(\"--: %r -> found = %r\", fileName, isFound)\n\n if isFound:\n result = fileName\n break\n\n Logging.trace(\"<<: %r\", result)\n return result","def find_file(line, column, *, cwd=None):\n cwd = cwd or pathlib.Path()\n path = None\n for finder in finders:\n path, lineno = finder(line, column, cwd)\n if path is not None:\n break\n\n if path is None:\n return None, None\n else:\n return path, lineno","def _find_config_file(self) -> str or None:\n import os\n\n for path in self.paths:\n path = os.path.expanduser(path)\n for extension in self.file_extensions:\n for file_name in self.file_names:\n file_path = os.path.join(path, \"{}.{}\".format(file_name, extension))\n if os.path.isfile(file_path):\n return file_path\n\n return None","def pathToFileName(self, path):\n\t\t# Find the path, and strip the leading slash.\n\t\tpath =urlparse.urlparse(self.path)[2].lstrip(\"/\")\n\t\t# Process url escape codes, and normalize the path.\n\t\tpath = os.path.normpath(urllib2.unquote(path))\n\t\t# normpath strips the last slash\n\t\tif os.path.isdir(path):\n\t\t\treturn path + '/'\n\t\telse:\n\t\t\treturn path","def find_file(filename: str, paths: List[str] = None, extensions=None) -> str:\n\n extensions = conf.SEARCH_EXTENSIONS if not extensions else extensions\n paths = conf.SEARCH_DIRS if not paths else paths\n\n if '' not in extensions:\n extensions += ['']\n\n if os.path.isabs(filename):\n with open(filename, 'r'):\n return filename\n\n for ext in extensions:\n _fn = [f'{filename}{ext}']\n if '/' in filename:\n _fn = list(filename.split('/'))\n _fn[-1] = f'{_fn[-1]}{ext}'\n\n for p in paths:\n fpath = join(p, *_fn)\n try:\n with open(fpath, 'r'):\n return fpath\n except FileNotFoundError:\n continue\n\n raise FileNotFoundError(f'File \"{filename}\" could not be found in any of the given paths.')","def get_file_by_name(mod_files: List[PatchedFile], filename: str):\n for mod in mod_files:\n if mod.path == filename:\n return mod\n return None","def find_path(name, path=None, exact=False):\n if path is None:\n path = os.environ.get('PATH', os.defpath)\n if isinstance(path, str):\n dpaths = path.split(os.pathsep)\n else:\n dpaths = path\n candidates = (join(dpath, name) for dpath in dpaths)\n if exact:\n if WIN32: # nocover\n # on WIN32 allow ``name`` to omit the extension suffix by trying\n # to match with all possible \"valid\" suffixes specified by PATHEXT\n pathext = [''] + os.environ.get('PATHEXT', '').split(os.pathsep)\n candidates = (p + ext for p in candidates for ext in pathext)\n candidates = filter(exists, candidates)\n else:\n import glob\n candidates = it.chain.from_iterable(\n glob.glob(pattern) for pattern in candidates)\n\n for candidate in candidates:\n yield candidate","def search(cls, name, lookup=[]):\r\n if os.path.isfile(name): return name\r\n for spath in lookup:\r\n fname = os.path.join(spath, name)\r\n if os.path.isfile(fname):\r\n return fname\r\n for ext in cls.extensions:\r\n if os.path.isfile('%s.%s' % (fname, ext)):\r\n return '%s.%s' % (fname, ext)","def find_asset(path, root=None):\n if root is None:\n root = 'z:\\\\Leif\\\\Dropbox\\\\mugen\\\\testing-build\\\\'\n\n check = ('', 'data', 'stages', 'sound')\n for folder in (join(root, i) for i in check):\n candidate = join(folder, path)\n if exists(candidate):\n return candidate\n\n return \"<NO PATH TO FILE>\"","def search_image(name=None, path=['.']):\n name = strutils.decode(name)\n\n for image_dir in path:\n if not os.path.isdir(image_dir):\n continue\n image_dir = strutils.decode(image_dir)\n image_path = os.path.join(image_dir, name)\n if os.path.isfile(image_path):\n return strutils.encode(image_path)\n\n for image_path in list_all_image(image_dir):\n if not image_name_match(name, image_path):\n continue\n return strutils.encode(image_path)\n return None","def search_file(path, f):\n output = []\n for root, dirs, files in os.walk(path, topdown=True):\n for file in files:\n if file == f:\n path = os.path.join(root, file)\n output.append(path)\n\n return output","def FindFile(seeker):\n\n for folder in var.MOD_LOCATION:\n for file in os.listdir(folder):\n if file.lower() == seeker.lower():\n if not folder.endswith((\"/\", \"\\\\\")):\n folder = folder + \"\\\\\"\n return folder, file\n\n if True in [slash in seeker for slash in (\"/\", \"\\\\\")]:\n return GetFile(seeker) # Full path\n\n raise FileNotFoundError(seeker) # Exit out if the mod could not be found","def search_existing_file(path):\n return os.path.isfile(path)","def _search_path_to_file(self, directory, binary_name):\n for root, dirs, files in os.walk(directory):\n if binary_name in files:\n return os.path.join(root, binary_name)\n raise micp_kernel.NoExecutableError","def findFoamFile(foamFile, foamCase='.'):\n # check first if the path is absolute or relative. \n if len(foamFile.split('/'))==1: \n foamFiles = getFoamFiles(foamCase)\n foamFilePath = [elem for elem in foamFiles if elem.endswith('/' + foamFile)]\n if len(foamFilePath)==0:\n print('foamFile ' + foamFile + ' could not be found.')\n foamFilePath =''\n else:\n foamFilePath = foamFilePath[0]\n else:\n foamFilePath = foamFile\n return foamFilePath","def find_file_in_folders(filename, folders):\n for folder in folders:\n folder = os.path.expanduser(folder)\n full_path = os.path.join(folder, filename)\n if os.path.exists(full_path):\n return full_path\n raise FileNotFoundError(\"Did not find file %s!\" % filename)","def _find_file(config, startswith=False):\n remote_files = _get_remote_files(config)\n if startswith:\n remote_folders = {}\n for fname, (pid, _) in remote_files.items():\n remote_folders[os.path.dirname(fname)] = (pid, None)\n remote_files = remote_folders\n\n def glob_match(f1, f2):\n \"\"\"Check for wildcard glob style matches.\n \"\"\"\n if f1.find(\"*\") >= 0:\n if fnmatch.fnmatch(f2, \"*/%s\" % f1):\n return True\n\n def get_file(f):\n if _is_remote(f):\n f = _get_id_fname(f)[-1]\n # handle both bare lookups and project-prefixed\n if f.find(\":\") > 0:\n fproject, f = f.split(\":\")\n else:\n fproject = None\n # check for exact matches\n for project, folder in _remote_folders(config):\n if fproject is None or fproject == project:\n folder_f = os.path.join(folder, f)\n if folder_f in remote_files:\n pid, fid = remote_files[folder_f]\n return \"%s:%s/%s:%s\" % (KEY, fid, pid, folder_f)\n # find any files nested in sub folders or as globs\n out = []\n for project, folder in _remote_folders(config):\n for rfname, (pid, rid) in remote_files.items():\n if rfname.startswith(folder + \"/\") and (rfname.endswith(\"/\" + f) or glob_match(f, rfname)):\n out.append(\"%s:%s/%s:%s\" % (KEY, rid, pid, rfname))\n if len(out) == 1:\n return out[0]\n elif len(out) > 1:\n return out\n return get_file","def find_file(lines, MF=1):\n v = [l[slices['MF']] for l in lines]\n n = len(v)\n cmpstr = '%2s' % MF # search string\n i0 = v.index(cmpstr) # first occurrence\n i1 = n - v[::-1].index(cmpstr) # last occurrence\n return lines[i0: i1]","def find_file(folders, path):\n for name in path[:-1]:\n folders = [sub for folder in folders for sub in subdirs(folder, name)]\n return [\n os.path.join(folder, f)\n for folder in folders\n for f in os.listdir(folder)\n if f.lower() == path[-1]\n ]","def SearchPath(name, path=None):\n path = path or os.environ['PATH']\n for dir in path.split(os.pathsep):\n binpath = os.path.join(dir, name)\n if os.path.exists(binpath):\n return os.path.abspath(binpath)\n return None","def _find_by_name_pattern(search_directory, name_pattern, is_file=True):\n if not os.listdir(search_directory):\n return None\n # filter check list\n choose_list = []\n if is_file:\n choose_list += filter(lambda x: os.path.isfile(x), [os.path.join(search_directory, y) for y in os.listdir(search_directory)])\n else:\n choose_list += filter(lambda x: os.path.isdir(x), [os.path.join(search_directory, y) for y in os.listdir(search_directory)])\n # check\n for sub_name in choose_list:\n if re.match(name_pattern, os.path.basename(sub_name), re.IGNORECASE):\n return sub_name\n return None","def find_file(regex):\n f_list = glob.glob(regex)\n if len(f_list) == 1:\n return f_list[0]\n elif len(f_list) > 1:\n return f_list\n else:\n raise Exception(\"[ERROR] There is no valid output file for this job\")","def get_file_name(path):\n return os.path.basename(path)","def find_template_filename(self, template_name):\n\n def next_file():\n filename = self.path / template_name\n yield filename\n try:\n exts = self.default_file_extensions\n except AttributeError:\n return\n\n strfilename = str(filename)\n for ext in exts:\n yield Path(strfilename + ext)\n\n for filename in next_file():\n if filename.is_file():\n return filename","def find_module_file(base_directory, path):\n return os.path.join(base_directory, path)","def _FindExecutableOnPath(executable, path, pathext):\n\n if isinstance(pathext, six.string_types):\n raise ValueError(\n \"_FindExecutableOnPath(..., pathext='{0}') failed \"\n \"because pathext must be an iterable of strings, but got \"\n \"a string.\".format(pathext)\n )\n\n # Prioritize preferred extension over earlier in path.\n for ext in pathext:\n for directory in path.split(os.pathsep):\n # Windows can have paths quoted.\n directory = directory.strip('\"')\n full = os.path.normpath(os.path.join(directory, executable) + ext)\n # On Windows os.access(full, os.X_OK) is always True.\n if os.path.isfile(full) and os.access(full, os.X_OK):\n return full\n return None","def get_filename(self):\n \n for f in os.listdir(self.get_directory()):\n if os.path.isfile(os.path.join(self.get_directory(), f)):\n return f\n \n return None","def GetInputFilename(fname):\n if not indir or fname[:1] == '/':\n return fname\n for dirname in indir:\n pathname = os.path.join(dirname, fname)\n if os.path.exists(pathname):\n return pathname\n\n raise ValueError(\"Filename '%s' not found in input path (%s) (cwd='%s')\" %\n (fname, ','.join(indir), os.getcwd()))","def auto_file(filename, where='.') -> str:\n\n if os.path.isabs(filename):\n return filename\n\n prob = os.path.join(where, filename)\n if os.path.exists(prob) and os.path.isfile(prob):\n return prob\n\n files = list(glob.iglob(os.path.join(where, '**', filename), recursive=True))\n if len(files) == 0:\n raise FileNotFoundError('Given file could not be found with recursive search:' + filename)\n\n if len(files) > 1:\n raise FileNotFoundError('More than one file matches given filename. Please specify it explicitly' + filename)\n\n return files[0]","def search_files(filename, search_path, pathsep=os.pathsep):\n clidFiles = []\n for path in search_path.split(pathsep):\n candidate = os.path.join(path, filename)\n if os.path.exists(candidate): clidFiles.append(os.path.abspath(candidate))\n return clidFiles","def locate(pth, fn):\n if is_listing(pth):\n for ii in pth:\n ret = locate(ii, fn)\n if ret:\n return ret\n return None\n # Some specific directory trees would take too much time to traverse.\n if pth in (\"/lib/modules\"): \n return None\n pthfn = pth + \"/\" + fn\n if os.path.isfile(pthfn):\n return os.path.normpath(pthfn)\n try:\n for ii in os.listdir(pth):\n iifn = pth + \"/\" + ii\n if os.path.isdir(iifn):\n ret = locate(iifn, fn)\n if ret:\n return ret\n except OSError as ee: # Permission denied or the like.\n if 13 == ee.errno:\n return None\n raise ee\n return None","def __findFileName(self):\n self.ui.showFindFileByNameDialog()","def find_in_app(self, app, path):\n storage = self.storages.get(app)\n if storage:\n # only try to find a file if the source dir actually exists\n if storage.exists(path):\n matched_path = storage.path(path)\n if matched_path:\n return matched_path","def module_path_finder(path, name, recursive=True):\n path_ = None\n paths = glob(os.path.join(path, '**', '*.py'), recursive=recursive)\n for path in paths:\n file_name = os.path.basename(path)\n if file_name == name + '.py':\n path_ = os.path.abspath(path)\n\n if path_ is None:\n raise FileNotFoundError(\"module %s not found\" % name)\n\n return path_","def find_full_path(path_to_file):\r\n for subdir, dirs, files in os.walk(\".\"):\r\n full = os.path.relpath(os.path.join(subdir, path_to_file))\r\n if os.path.exists(full):\r\n return full","def get_path(file_name):\n path_project = os.getcwd()\n list_files = os.listdir(path_project)\n # print (\"Getting File in your Current Directory\", path_project)\n __log(1, 'Gatering Files from current Directory.')\n\n # for i in list_files:\n if file_name in list_files:\n file_path = path_project + '\\\\' + file_name\n __log(1, 'Relevant File Found.')\n return file_path\n else:\n __log(2, 'File Not Found.')\n return -1\n # print (\"File Found\",file_path)","def find_executable(name, paths):\n for path in paths:\n full_path = os.path.join(path, name)\n if os.path.isfile(full_path):\n return full_path\n # If not found, just assume it's in the PATH.\n return name","def find(self, relative_path):\n found = list(self.grep(relative_path, lazy=True))\n if found:\n return found[0]\n\n return None","def find(path, name):\n found = [] # list of found items\n\n def find_recursive(path, name, found): # recursive function to traverse tree and append found items\n path_abs = os.path.abspath(path) # get the absolute path name\n \n try:\n dir_items = os.listdir(path_abs)\n except:\n print(f\"ERROR: Directory {path} not found...\")\n sys.exit(1)\n\n dir_items = os.listdir(path_abs) # list all times in the currrent directory\n\n for item in dir_items: # iterate over the dir list\n full_path = os.path.join(path_abs, item) # get the full path name path + filename/directory\n if os.path.isdir(full_path): # if is a directory\n find_recursive(full_path, name, found) # make recursive call to function\n\n if os.path.isfile(full_path): # if a file\n if item == name: # check for name equality\n found.append(full_path) # if true: add to list\n\n find_recursive(path, name, found) # call recursive function\n\n return found","def which(cmd, mode=os.F_OK | os.X_OK, path=None):\n # Check that a given file can be accessed with the correct mode.\n # Additionally check that `file` is not a directory, as on Windows\n # directories pass the os.access check.\n def _access_check(fn, mode):\n return (os.path.exists(fn) and os.access(fn, mode) and\n not os.path.isdir(fn))\n\n # If we're given a path with a directory part, look it up directly\n # rather than referring to PATH directories. This includes checking\n # relative to the current directory, e.g. ./script\n if os.path.dirname(cmd):\n if _access_check(cmd, mode):\n return cmd\n return None\n\n if path is None:\n path = os.environ.get(\"PATH\", os.defpath)\n if not path:\n return None\n path = path.split(os.pathsep)\n\n # On other platforms you don't have things like PATHEXT to tell you\n # what file suffixes are executable, so just pass on cmd as-is.\n files = [cmd]\n\n seen = set()\n for dir in path:\n normdir = os.path.normcase(dir)\n if normdir not in seen:\n seen.add(normdir)\n for thefile in files:\n name = os.path.join(dir, thefile)\n if _access_check(name, mode):\n return name\n return None","def get_filename(link):\r\n return link[link.rfind(\"/\") + 1:]","def file_exists(self, path: str) -> Optional[GoogleDriveFile]:\n current_file = self.root\n file_name_list = self._normalized_path_list(path)\n normalized_file_path = \"/\".join(file_name_list)\n logging.info(f\"Checking if {normalized_file_path} exists...\")\n last_index = len(file_name_list) - 1\n for index, file_name in enumerate(file_name_list):\n if current_file.file_name != FileName(file_name):\n return None\n # If not the last item in the path, then get the next file in the path and assign as root\n if index < last_index:\n next_file_name = FileName(file_name_list[index + 1])\n next_file = current_file.get_child(next_file_name)\n # If not last item in path and sub-files don't contain the next item, path doesn't exist\n if next_file is None:\n return None\n current_file = next_file\n else:\n return current_file\n raise Exception(\"Not suppose to reach here. Check function file_exists\")","def search_string(command):\n try:\n my_file.search_string(command[1])\n except FileNotFoundError:\n print('No file has been read yet')","def get_file_name(path: str) -> str:\n return os.path.splitext(os.path.basename(path))[0]","def get_file(view: sublime.View, string: str, name: str) -> 'Tuple[str, Optional[str]]':\n\n # if it's an absolute path get it\n if osp.isabs(string):\n return string, None\n\n # if search_mode: \"project\", search only in project\n elif Settings.search_mode == \"project\":\n # Get base project folders\n base_folders = sublime.active_window().folders()\n # if \"recursive\": true, recursively search for the name\n if Settings.recursive:\n ch_rec = check_recursive(base_folders, name)\n if ch_rec:\n base_folder, root = ch_rec\n return osp.join(root, name), base_folder\n return \"\", None\n else:\n # search only in base folders for the relative path\n for base_folder in base_folders:\n file_name = osp.normpath(osp.join(base_folder, string))\n if osp.exists(file_name):\n return file_name, base_folder\n return \"\", None\n # if search_mode: \"file\" join the relative path to the file path\n else:\n return osp.normpath(osp.join(osp.dirname(view.file_name()), string)), None","def file_name(path):\n return os.path.basename(path).split('.')[0]","def which(fname):\n if \"PATH\" not in os.environ or not os.environ[\"PATH\"]:\n path = os.defpath\n else:\n path = os.environ[\"PATH\"]\n\n for p in [fname] + [os.path.join(x, fname) for x in path.split(os.pathsep)]:\n p = os.path.abspath(p)\n if os.access(p, os.X_OK) and not os.path.isdir(p):\n return p\n\n p = sp.Popen(\"locate %s\" % fname, shell=True, stdout=sp.PIPE, stderr=sp.PIPE)\n (stdout, stderr) = p.communicate()\n if not stderr:\n for p in stdout.decode().split(\"\\n\"):\n if (\n (os.path.basename(p) == fname)\n and (os.access(p, os.X_OK))\n and (not os.path.isdir(p))\n ):\n return p","def get_files_for_path(file_ids_tree, path):\n entry = file_ids_tree\n parts = path.split('/')\n for part in parts:\n if part != '':\n try:\n entry = entry[part]\n except KeyError as e:\n files = entry[FILE_MARKER]\n for entry in files:\n if entry[0] == part:\n return entry\n raise e\n\n return entry","def find_file(file_path=None, args=None, locations=DEFAULT_LOCATIONS,\n file_name='weewx.conf'):\n\n # Start by searching args (if available)\n if file_path is None and args:\n for i in range(len(args)):\n if not args[i].startswith('-'):\n file_path = args[i]\n del args[i]\n break\n\n if file_path is None:\n for directory in locations:\n # If this is a relative path, then prepend with the\n # directory this file is in:\n if not directory.startswith('/'):\n directory = os.path.join(os.path.dirname(__file__), directory)\n candidate = os.path.abspath(os.path.join(directory, file_name))\n if os.path.isfile(candidate):\n return candidate\n\n if file_path is None:\n raise IOError(\"Unable to find file '%s'. Tried directories %s\" %\n (file_name, locations))\n elif not os.path.isfile(file_path):\n raise IOError(\"%s is not a file\" % file_path)\n\n return file_path","def path_to_file(fname, dirs):\n for each in dirs:\n path = '/'.join([each, fname])\n if os.path.exists(path):\n return path\n return None","def _FindTemplateFile(self, topdir):\n if topdir.endswith('..'):\n topdir = '/'.join(topdir.split('/')[:-2])\n fnames = os.listdir(topdir)\n for fname in fnames:\n filename = '%s/%s' % (topdir, fname)\n if filename.endswith('.yaml') and not os.path.isdir(filename) and \\\n os.path.exists(filename):\n f = open(filename, 'r')\n magic_code = f.read(22)\n f.close()\n if '#!fmri_file_template' in magic_code:\n return filename\n return None","def find_file(directory, extensions):\n for filename in os.listdir(directory):\n if filename.endswith(extensions):\n return \"{}/{}\".format(directory, filename)\n return None","def get_file_name(path):\n logger.debug('Function Successful: % s',\n 'get_file_name: get_file_name successfully called from local_save', extra=d)\n logger.info('Extracting file name...')\n\n split_path = path.split(\"/\")\n file_name = split_path[len(split_path) - 1]\n\n logger.debug('Returning: %s',\n 'get_file_name: returning the file name', extra=d)\n logger.info('File name extracted')\n\n return file_name","def find_file_by_name(**kwargs):\n return AppServer.service.find_file_by_name(name=kwargs['name'])","def check_file(file: Path):\n if Path(file).is_file() or file == \"\":\n return file\n else:\n files = glob.glob(\"./**/\" + file, recursive=True) # find file\n FILE_NOT_FOUND_MSG = f\"File Not Found: {file}\"\n MULTIPLE_FILE_MSG = f\"Multiple files match '{file}', specify exact path:{files}\"\n\n assert len(files), FILE_NOT_FOUND_MSG # assert file was found\n assert len(files) == 1, MULTIPLE_FILE_MSG # assert unique\n return files[0] # return file","def filename_from_path(filepath: str) -> str:\n return filepath.split(\"/\")[-1]","def find_specific_file_extension_in_dir(dir_path, extension):\r\n return glob.glob(os.path.join(dir_path, r'*{}'.format(extension)))[0].replace('\\\\', '/').split('/')[-1]","def locate_file(self, filename):\n return locate_file(filename, self.observatory)","def _file_in_subdir(self, subdir, filename, check_exists=False):\n filepath = join(self.dir, subdir, filename)\n\n if check_exists and not isfile(filepath) and not isdir(filepath):\n\n # Try the filename as a pattern or regex before failing:\n matches = self._files_in_subdir(subdir,\n pattern='**/*{}*'.format(filename),\n regex=None)\n\n # Don't accept ambiguous patterns!\n if len(matches) == 1:\n return matches[0]\n\n raise FileNotFoundError(filepath)\n\n return filepath","def find_meshfn(lp):\n try:\n trash, ffind = build_meshfn(lp)\n print 'ffind = ', ffind\n print 'found --> ', sorted(glob.glob(ffind))[0]\n meshfn = sorted(glob.glob(ffind))[0][0:-7]\n except IndexError:\n raise RuntimeError('ERROR: Could not find specified meshfn!')\n return meshfn","def qualify_full_filepath(filename, path=None):\n filepath = os.path.join(path or \"\", filename)\n if not os.path.isfile(filepath):\n raise OSError(f\"No available file found at: {filename}.\")\n return filepath","def name_from_path(path):\n return path[0:-3]","def extract_file_name(file_path):\n # ファイルパスからファイル名(拡張子含む)を取り出す\n file_name = file_path.split('/')[-1]\n # 拡張子を取り除く\n return file_name.split('.')[0]","def\textractPathFromPathfilename(self,fullPathFilename):\n\t\treturn(fullPathFilename[0:fullPathFilename.rfind('\\\\')+1])","def find_qualified_name(filename, max_iterations=5):\n filename = os.path.abspath(filename)\n vc_root = find_vc_root(filename, max_iterations)\n _, name = filename.split(f\"{vc_root}/\")\n if name.endswith(\".py\"):\n name = name[:-3]\n return name.replace(\"/\", \".\")"],"string":"[\n \"def search_file(filename, search_path, pathsep=os.pathsep):\\n for path in string.split(search_path, pathsep):\\n candidate = os.path.join(path, filename)\\n if os.path.exists(candidate): return os.path.abspath(candidate)\\n return None\",\n \"def search_file(filename, search_path, pathsep=os.pathsep):\\n for path in string.split(search_path, pathsep):\\n candidate = os.path.join(path, filename)\\n if os.path.exists(candidate): return os.path.abspath(candidate)\\n return None\",\n \"def search_file(filename, search_path):\\n file_path = None\\n for path in search_path:\\n if exists(join(path, filename)):\\n file_path = path\\n break\\n if file_path:\\n return abspath(join(file_path, filename))\\n return None\",\n \"def findInPath(fileName):\\n\\timport posixpath\\n\\tfor pathdir in ([\\\".\\\"]+sys.path):\\n\\t\\tif posixpath.isfile(pathdir+\\\"/\\\"+fileName):\\n\\t\\t\\treturn pathdir+\\\"/\\\"+fileName\",\n \"def find_file(filename):\\n for i in list(_ctx.include_paths) + [ os.path.dirname(_ctx.filename) ]:\\n full_path = os.path.join(i, filename)\\n if os.path.exists(full_path):\\n return full_path\\n return filename # failure gets handled later on\",\n \"def find_file(file_name):\\n if (pathlib.Path(file_name).resolve()):\\n file_name = str(file_name)\\n logging.info(f' found {file_name}.')\\n return file_name\\n else:\\n logging.error(f' no file {file_name} found for processing.')\\n sys.exit()\",\n \"def _findfile(self, path):\\n\\n # Build list of possible local file paths\\n if not self._isurl(path):\\n # Valid local paths\\n filelist = self._possible_names(path)\\n # Paths in self._destpath\\n filelist += self._possible_names(self.abspath(path))\\n else:\\n # Cached URLs in self._destpath\\n filelist = self._possible_names(self.abspath(path))\\n # Remote URLs\\n filelist = filelist + self._possible_names(path)\\n\\n for name in filelist:\\n if self.exists(name):\\n if self._isurl(name):\\n name = self._cache(name)\\n return name\\n return None\",\n \"def find_in_PATH(filename: str):\\n if path.isfile(filename):\\n return path.normpath(filename)\\n\\n os_paths = os.environ['PATH'].split(path.pathsep)\\n for os_path in os_paths:\\n fullpath_file = path.join(os_path, filename)\\n if path.isfile(fullpath_file):\\n return path.normpath(fullpath_file)\\n raise FileNotFoundError(f'could not find {filename}')\",\n \"def find_file(path):\\n return NotImplemented\",\n \"def find(name):\\n\\n if os.path.exists(name):\\n return name\\n\\n path = os.path.dirname(__file__) or '.'\\n filename = os.path.abspath(os.path.join(path,name))\\n if os.path.exists(filename):\\n return filename\\n\\n for d in os.listdir(path):\\n fullpath = os.path.abspath(os.path.join(path,d))\\n if os.path.isdir(fullpath):\\n filename = os.path.abspath(os.path.join(fullpath,name))\\n if os.path.exists(filename):\\n return filename\\n return None\",\n \"def find_in_path(filenames):\\n # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52224\\n from os.path import exists, join, abspath\\n from os import pathsep, environ\\n search_path = environ[\\\"PATH\\\"]\\n paths = search_path.split(pathsep)\\n for path in paths:\\n for filename in filenames:\\n if exists(join(path, filename)):\\n return abspath(join(path, filename))\",\n \"def search_file(file_name, search_path):\\n if os.path.exists(search_path):\\n filenames = os.listdir(search_path)\\n for filename in filenames:\\n if file_name in filenames:\\n return os.path.join(search_path, file_name)\\n return None\",\n \"def _FindPathSpec(self, path, filename):\\n # TODO: determine why this first find is used add comment or remove.\\n # It does not appear to help with making sure path segment separate\\n # is correct.\\n find_spec = file_system_searcher.FindSpec(\\n location=path, case_sensitive=False)\\n path_specs = list(self._searcher.Find(find_specs=[find_spec]))\\n\\n if not path_specs or len(path_specs) != 1:\\n raise IOError(\\n u'Unable to find directory: {0:s}'.format(path))\\n\\n relative_path = self._searcher.GetRelativePath(path_specs[0])\\n if not relative_path:\\n raise IOError(u'Unable to determine relative path of: {0:s}'.format(path))\\n\\n # The path is split in segments to make it path segement separator\\n # independent (and thus platform independent).\\n path_segments = self._searcher.SplitPath(relative_path)\\n path_segments.append(filename)\\n\\n find_spec = file_system_searcher.FindSpec(\\n location=path_segments, case_sensitive=False)\\n path_specs = list(self._searcher.Find(find_specs=[find_spec]))\\n\\n if not path_specs:\\n raise IOError(\\n u'Unable to find file: {0:s} in directory: {1:s}'.format(\\n filename, relative_path))\\n\\n if len(path_specs) != 1:\\n raise IOError((\\n u'Find for file: {0:s} in directory: {1:s} returned {2:d} '\\n u'results.').format(filename, relative_path, len(path_specs)))\\n\\n if not relative_path:\\n raise IOError(\\n u'Missing file: {0:s} in directory: {1:s}'.format(\\n filename, relative_path))\\n\\n return path_specs[0]\",\n \"def search_on_path(filenames):\\n # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52224\\n\\n from os.path import exists, join, abspath\\n from os import pathsep, environ\\n\\n search_path = environ[\\\"PATH\\\"]\\n\\n paths = search_path.split(pathsep)\\n for path in paths:\\n for filename in filenames:\\n if exists(join(path, filename)):\\n return abspath(join(path, filename))\",\n \"def _findfile(self, path):\\n return DataSource._findfile(self, self._fullpath(path))\",\n \"def _find(self, path):\\n try:\\n self.log.debug(\\\"Searching for '%s'\\\" % path)\\n os.stat(path)\\n self.log.debug(\\\" found!\\\")\\n return path\\n except OSError:\\n self.log.debug(\\\" not found!\\\")\\n segs = path.split(os.path.sep)\\n found_parent = os.path.sep\\n assert segs[0] == '' # expect a leading /\\n for i in range(1, len(segs)): # start after leading /\\n try:\\n parent = os.path.sep.join(segs[:i+1])\\n self.log.debug(\\\" searching parent %d %s\\\" % (i, str(parent)))\\n os.stat(parent)\\n self.log.debug(\\\" found\\\")\\n found_parent = parent\\n except OSError:\\n self.log.debug(\\\" NOT found\\\")\\n break\\n\\n # does the found_parent dir contain a differently-cased version of the requested path?\\n candidates = [f for f in os.listdir(found_parent) if f.lower() == segs[i].lower()]\\n self.log.debug(' Candidates: %s' % str(candidates))\\n if candidates:\\n if len(candidates) > 1:\\n self.log.warn('Case ambiguity: %s%s{%s}' % (found_parent, os.path.sep, ','.join(candidates)))\\n segs[i] = candidates[0]\\n path = os.path.sep.join(segs)\\n if i < (len(segs)-1):\\n self.log.debug('recursing')\\n path = self._find(path) # recursively search with the new case-corrected path segment\\n\\n self.log.debug('resolved to [or failed with] path: %s' % path)\\n\\n # returns path unmodified if we were unable to find case-corrected candidates.\\n # expects underlying command implementations to handle file-not-found correctly if so.\\n return path\",\n \"def checkFilePath(self, filename, searchpath=[]):\\n\\t\\tif filename is None:\\n\\t\\t\\treturn None\\n\\t\\telif os.path.isfile(filename):\\n\\t\\t\\treturn filename\\n\\t\\telse:\\n\\t\\t\\t# Append current dir to searchpath and try each in turn\\n\\t\\t\\tsearchpath.append(os.path.dirname(__file__))\\n\\t\\t\\t# print(searchpath)\\n\\t\\t\\tfor folder in searchpath:\\n\\t\\t\\t\\tfilepath = os.path.join(folder, filename)\\n\\t\\t\\t\\tif os.path.isfile(filepath):\\n\\t\\t\\t\\t\\treturn filepath\\n\\n\\t\\t# File not found\\n\\t\\treturn None\",\n \"def Filename(fname):\\n if fname.startswith('##/'):\\n if chroot_path:\\n fname = os.path.join(chroot_path, fname[3:])\\n else:\\n return None\\n\\n # Search for a pathname that exists, and return it if found\\n if fname and not os.path.exists(fname):\\n for path in search_paths:\\n pathname = os.path.join(path, os.path.basename(fname))\\n if os.path.exists(pathname):\\n return pathname\\n\\n # If not found, just return the standard, unchanged path\\n return fname\",\n \"def find_file(path, filename, max_depth=5):\\n for root, dirs, files in os.walk(path):\\n if filename in files:\\n return os.path.join(root, filename)\\n\\n # Don't search past max_depth\\n depth = root[len(path) + 1:].count(os.sep)\\n if depth > max_depth:\\n del dirs[:] # Clear dirs\\n return None\",\n \"def findFile(PATH, PATTERN):\\n\\t#### find all the file located in the PATH corresponding to the PATTERN\\n\\tfindPattern = subprocess.Popen('find {path} -name \\\"{pattern}\\\" 2> /dev/null'.format(path=PATH, pattern=PATTERN), shell=True, stdout=subprocess.PIPE);\\n\\t#### String containing all the path toward the file's name matching with the pattern\\n\\treturn findPattern.stdout.read().decode(\\\"utf-8\\\").strip().split(\\\"\\\\n\\\")\",\n \"def getfilename(path):\\r\\n return path.split('\\\\\\\\').pop().split('/').pop().rsplit('.', 1)[0]\",\n \"def getFilename(path):\\n\\tfrom os.path import split\\n\\tpath = normalizePath(path)\\n\\treturn split(path)[1]\",\n \"def find_in_paths(name, paths):\\n for path in paths:\\n file_ = osp.join(path, name)\\n if osp.exists(file_) and not osp.isdir(file_):\\n abs_file = osp.abspath(file_)\\n if os.access(file_, os.X_OK):\\n return abs_file\",\n \"def findInPath (exe):\\n\\n\\tfor dirname in os.environ['PATH'].split (os.path.pathsep):\\n\\t\\tpossible = os.path.join (dirname, exe)\\n\\t\\tif os.path.isfile (possible):\\n\\t\\t\\treturn possible\\n\\n\\t# Not found\\n\\traise NotFoundInPathException (exe)\",\n \"def SearchPath(name):\\n search_path = os.getenv('PATH', os.defpath).split(os.pathsep)\\n for directory in search_path:\\n if directory:\\n path = os.path.join(directory, name)\\n if os.path.isfile(path) and os.access(path, os.X_OK):\\n return path\\n return None\",\n \"def find_file(filesystem, dirs, filename):\\r\\n for directory in dirs:\\r\\n filepath = path(directory) / filename\\r\\n if filesystem.exists(filepath):\\r\\n return filepath\\r\\n raise ResourceNotFoundError(u\\\"Could not find {0}\\\".format(filename))\",\n \"def findPath(self, name=None, pattern=None, extension=None, ignorePatterns=None,\\n path=None, paths=None):\\n paths = self.findPaths(name, pattern, extension, ignorePatterns, path, paths)\\n if paths: # If anything found, then answer the first one.\\n return paths[0]\\n return None\",\n \"def get_filename(path):\\n return path.split('/')[-1]\",\n \"def find_binary_in_path(filename: str) -> str:\\n if \\\"PATH\\\" not in os.environ:\\n raise PATHNotFoundError\\n for directory in os.environ[\\\"PATH\\\"].split(os.pathsep):\\n binary = os.path.abspath(os.path.join(directory, filename))\\n if os.path.isfile(binary) and os.access(binary, os.X_OK):\\n return binary\\n raise BinaryNotFoundError\",\n \"def find_file_by_name(point,target):\\n launcher_path = \\\"\\\"\\n for (path, dir, files) in os.walk(point):\\n for filename in files:\\n # if target in filename:\\n if filename == target:\\n launcher_path = os.path.join(path, filename)\\n return launcher_path\",\n \"def find_one(path, filenames):\\n for _path in find_all(path, filenames):\\n return _path\\n return ''\",\n \"def _findfile(self,path,label):\\n files=[];filenames=os.listdir(path)\\n for name in filenames:\\n if os.path.splitext(name)[0]==str(label):\\n files.append(name)\\n return files\",\n \"def recursively_find_file(folder, file_name):\\n # TODO: print a hint when not founding file_name\",\n \"def _find_file(self, name, check_dir='c_files'):\\n testdir = os.path.dirname(__file__)\\n name = os.path.join(testdir, check_dir, name)\\n return name\",\n \"def locate_file(fname):\\n out = []\\n if platform._is_win: # pragma: windows\\n out += find_all(fname, None)\\n else:\\n for path in os.environ.get('PATH').split(os.pathsep):\\n if path:\\n out += find_all(fname, path)\\n if not out:\\n return False\\n first = out[0]\\n if len(out) > 1:\\n # pprint.pprint(out)\\n warnings.warn(\\\"More than one (%d) match to %s. Using first match (%s)\\\" % (\\n len(out), fname, first))\\n return first\",\n \"def _find_ref_fname(fname, ref_fname):\\n curr_dir = \\\"\\\"\\n next_dir = os.path.dirname(os.path.abspath(fname))\\n while next_dir != curr_dir:\\n curr_dir = next_dir\\n rcfile = os.path.join(curr_dir, ref_fname)\\n if os.path.exists(rcfile):\\n return rcfile\\n next_dir = os.path.dirname(curr_dir)\\n return \\\"\\\"\",\n \"def _lookupFileName (self,\\n enclosingDirectoryName : String,\\n originalFileName : String) -> String:\\n\\n Logging.trace(\\\">>: directory = %r, file = %r\\\",\\n enclosingDirectoryName, originalFileName)\\n\\n cls = self.__class__\\n result = None\\n separator = OperatingSystem.pathSeparator\\n simpleFileName = OperatingSystem.basename(originalFileName)\\n searchPathList = list(cls._searchPathList)\\n searchPathList.append(enclosingDirectoryName)\\n\\n for directoryName in searchPathList:\\n fileName = iif(directoryName == \\\".\\\", originalFileName,\\n directoryName + separator + simpleFileName)\\n isFound = OperatingSystem.hasFile(fileName)\\n Logging.trace(\\\"--: %r -> found = %r\\\", fileName, isFound)\\n\\n if isFound:\\n result = fileName\\n break\\n\\n Logging.trace(\\\"<<: %r\\\", result)\\n return result\",\n \"def find_file(line, column, *, cwd=None):\\n cwd = cwd or pathlib.Path()\\n path = None\\n for finder in finders:\\n path, lineno = finder(line, column, cwd)\\n if path is not None:\\n break\\n\\n if path is None:\\n return None, None\\n else:\\n return path, lineno\",\n \"def _find_config_file(self) -> str or None:\\n import os\\n\\n for path in self.paths:\\n path = os.path.expanduser(path)\\n for extension in self.file_extensions:\\n for file_name in self.file_names:\\n file_path = os.path.join(path, \\\"{}.{}\\\".format(file_name, extension))\\n if os.path.isfile(file_path):\\n return file_path\\n\\n return None\",\n \"def pathToFileName(self, path):\\n\\t\\t# Find the path, and strip the leading slash.\\n\\t\\tpath =urlparse.urlparse(self.path)[2].lstrip(\\\"/\\\")\\n\\t\\t# Process url escape codes, and normalize the path.\\n\\t\\tpath = os.path.normpath(urllib2.unquote(path))\\n\\t\\t# normpath strips the last slash\\n\\t\\tif os.path.isdir(path):\\n\\t\\t\\treturn path + '/'\\n\\t\\telse:\\n\\t\\t\\treturn path\",\n \"def find_file(filename: str, paths: List[str] = None, extensions=None) -> str:\\n\\n extensions = conf.SEARCH_EXTENSIONS if not extensions else extensions\\n paths = conf.SEARCH_DIRS if not paths else paths\\n\\n if '' not in extensions:\\n extensions += ['']\\n\\n if os.path.isabs(filename):\\n with open(filename, 'r'):\\n return filename\\n\\n for ext in extensions:\\n _fn = [f'{filename}{ext}']\\n if '/' in filename:\\n _fn = list(filename.split('/'))\\n _fn[-1] = f'{_fn[-1]}{ext}'\\n\\n for p in paths:\\n fpath = join(p, *_fn)\\n try:\\n with open(fpath, 'r'):\\n return fpath\\n except FileNotFoundError:\\n continue\\n\\n raise FileNotFoundError(f'File \\\"{filename}\\\" could not be found in any of the given paths.')\",\n \"def get_file_by_name(mod_files: List[PatchedFile], filename: str):\\n for mod in mod_files:\\n if mod.path == filename:\\n return mod\\n return None\",\n \"def find_path(name, path=None, exact=False):\\n if path is None:\\n path = os.environ.get('PATH', os.defpath)\\n if isinstance(path, str):\\n dpaths = path.split(os.pathsep)\\n else:\\n dpaths = path\\n candidates = (join(dpath, name) for dpath in dpaths)\\n if exact:\\n if WIN32: # nocover\\n # on WIN32 allow ``name`` to omit the extension suffix by trying\\n # to match with all possible \\\"valid\\\" suffixes specified by PATHEXT\\n pathext = [''] + os.environ.get('PATHEXT', '').split(os.pathsep)\\n candidates = (p + ext for p in candidates for ext in pathext)\\n candidates = filter(exists, candidates)\\n else:\\n import glob\\n candidates = it.chain.from_iterable(\\n glob.glob(pattern) for pattern in candidates)\\n\\n for candidate in candidates:\\n yield candidate\",\n \"def search(cls, name, lookup=[]):\\r\\n if os.path.isfile(name): return name\\r\\n for spath in lookup:\\r\\n fname = os.path.join(spath, name)\\r\\n if os.path.isfile(fname):\\r\\n return fname\\r\\n for ext in cls.extensions:\\r\\n if os.path.isfile('%s.%s' % (fname, ext)):\\r\\n return '%s.%s' % (fname, ext)\",\n \"def find_asset(path, root=None):\\n if root is None:\\n root = 'z:\\\\\\\\Leif\\\\\\\\Dropbox\\\\\\\\mugen\\\\\\\\testing-build\\\\\\\\'\\n\\n check = ('', 'data', 'stages', 'sound')\\n for folder in (join(root, i) for i in check):\\n candidate = join(folder, path)\\n if exists(candidate):\\n return candidate\\n\\n return \\\"<NO PATH TO FILE>\\\"\",\n \"def search_image(name=None, path=['.']):\\n name = strutils.decode(name)\\n\\n for image_dir in path:\\n if not os.path.isdir(image_dir):\\n continue\\n image_dir = strutils.decode(image_dir)\\n image_path = os.path.join(image_dir, name)\\n if os.path.isfile(image_path):\\n return strutils.encode(image_path)\\n\\n for image_path in list_all_image(image_dir):\\n if not image_name_match(name, image_path):\\n continue\\n return strutils.encode(image_path)\\n return None\",\n \"def search_file(path, f):\\n output = []\\n for root, dirs, files in os.walk(path, topdown=True):\\n for file in files:\\n if file == f:\\n path = os.path.join(root, file)\\n output.append(path)\\n\\n return output\",\n \"def FindFile(seeker):\\n\\n for folder in var.MOD_LOCATION:\\n for file in os.listdir(folder):\\n if file.lower() == seeker.lower():\\n if not folder.endswith((\\\"/\\\", \\\"\\\\\\\\\\\")):\\n folder = folder + \\\"\\\\\\\\\\\"\\n return folder, file\\n\\n if True in [slash in seeker for slash in (\\\"/\\\", \\\"\\\\\\\\\\\")]:\\n return GetFile(seeker) # Full path\\n\\n raise FileNotFoundError(seeker) # Exit out if the mod could not be found\",\n \"def search_existing_file(path):\\n return os.path.isfile(path)\",\n \"def _search_path_to_file(self, directory, binary_name):\\n for root, dirs, files in os.walk(directory):\\n if binary_name in files:\\n return os.path.join(root, binary_name)\\n raise micp_kernel.NoExecutableError\",\n \"def findFoamFile(foamFile, foamCase='.'):\\n # check first if the path is absolute or relative. \\n if len(foamFile.split('/'))==1: \\n foamFiles = getFoamFiles(foamCase)\\n foamFilePath = [elem for elem in foamFiles if elem.endswith('/' + foamFile)]\\n if len(foamFilePath)==0:\\n print('foamFile ' + foamFile + ' could not be found.')\\n foamFilePath =''\\n else:\\n foamFilePath = foamFilePath[0]\\n else:\\n foamFilePath = foamFile\\n return foamFilePath\",\n \"def find_file_in_folders(filename, folders):\\n for folder in folders:\\n folder = os.path.expanduser(folder)\\n full_path = os.path.join(folder, filename)\\n if os.path.exists(full_path):\\n return full_path\\n raise FileNotFoundError(\\\"Did not find file %s!\\\" % filename)\",\n \"def _find_file(config, startswith=False):\\n remote_files = _get_remote_files(config)\\n if startswith:\\n remote_folders = {}\\n for fname, (pid, _) in remote_files.items():\\n remote_folders[os.path.dirname(fname)] = (pid, None)\\n remote_files = remote_folders\\n\\n def glob_match(f1, f2):\\n \\\"\\\"\\\"Check for wildcard glob style matches.\\n \\\"\\\"\\\"\\n if f1.find(\\\"*\\\") >= 0:\\n if fnmatch.fnmatch(f2, \\\"*/%s\\\" % f1):\\n return True\\n\\n def get_file(f):\\n if _is_remote(f):\\n f = _get_id_fname(f)[-1]\\n # handle both bare lookups and project-prefixed\\n if f.find(\\\":\\\") > 0:\\n fproject, f = f.split(\\\":\\\")\\n else:\\n fproject = None\\n # check for exact matches\\n for project, folder in _remote_folders(config):\\n if fproject is None or fproject == project:\\n folder_f = os.path.join(folder, f)\\n if folder_f in remote_files:\\n pid, fid = remote_files[folder_f]\\n return \\\"%s:%s/%s:%s\\\" % (KEY, fid, pid, folder_f)\\n # find any files nested in sub folders or as globs\\n out = []\\n for project, folder in _remote_folders(config):\\n for rfname, (pid, rid) in remote_files.items():\\n if rfname.startswith(folder + \\\"/\\\") and (rfname.endswith(\\\"/\\\" + f) or glob_match(f, rfname)):\\n out.append(\\\"%s:%s/%s:%s\\\" % (KEY, rid, pid, rfname))\\n if len(out) == 1:\\n return out[0]\\n elif len(out) > 1:\\n return out\\n return get_file\",\n \"def find_file(lines, MF=1):\\n v = [l[slices['MF']] for l in lines]\\n n = len(v)\\n cmpstr = '%2s' % MF # search string\\n i0 = v.index(cmpstr) # first occurrence\\n i1 = n - v[::-1].index(cmpstr) # last occurrence\\n return lines[i0: i1]\",\n \"def find_file(folders, path):\\n for name in path[:-1]:\\n folders = [sub for folder in folders for sub in subdirs(folder, name)]\\n return [\\n os.path.join(folder, f)\\n for folder in folders\\n for f in os.listdir(folder)\\n if f.lower() == path[-1]\\n ]\",\n \"def SearchPath(name, path=None):\\n path = path or os.environ['PATH']\\n for dir in path.split(os.pathsep):\\n binpath = os.path.join(dir, name)\\n if os.path.exists(binpath):\\n return os.path.abspath(binpath)\\n return None\",\n \"def _find_by_name_pattern(search_directory, name_pattern, is_file=True):\\n if not os.listdir(search_directory):\\n return None\\n # filter check list\\n choose_list = []\\n if is_file:\\n choose_list += filter(lambda x: os.path.isfile(x), [os.path.join(search_directory, y) for y in os.listdir(search_directory)])\\n else:\\n choose_list += filter(lambda x: os.path.isdir(x), [os.path.join(search_directory, y) for y in os.listdir(search_directory)])\\n # check\\n for sub_name in choose_list:\\n if re.match(name_pattern, os.path.basename(sub_name), re.IGNORECASE):\\n return sub_name\\n return None\",\n \"def find_file(regex):\\n f_list = glob.glob(regex)\\n if len(f_list) == 1:\\n return f_list[0]\\n elif len(f_list) > 1:\\n return f_list\\n else:\\n raise Exception(\\\"[ERROR] There is no valid output file for this job\\\")\",\n \"def get_file_name(path):\\n return os.path.basename(path)\",\n \"def find_template_filename(self, template_name):\\n\\n def next_file():\\n filename = self.path / template_name\\n yield filename\\n try:\\n exts = self.default_file_extensions\\n except AttributeError:\\n return\\n\\n strfilename = str(filename)\\n for ext in exts:\\n yield Path(strfilename + ext)\\n\\n for filename in next_file():\\n if filename.is_file():\\n return filename\",\n \"def find_module_file(base_directory, path):\\n return os.path.join(base_directory, path)\",\n \"def _FindExecutableOnPath(executable, path, pathext):\\n\\n if isinstance(pathext, six.string_types):\\n raise ValueError(\\n \\\"_FindExecutableOnPath(..., pathext='{0}') failed \\\"\\n \\\"because pathext must be an iterable of strings, but got \\\"\\n \\\"a string.\\\".format(pathext)\\n )\\n\\n # Prioritize preferred extension over earlier in path.\\n for ext in pathext:\\n for directory in path.split(os.pathsep):\\n # Windows can have paths quoted.\\n directory = directory.strip('\\\"')\\n full = os.path.normpath(os.path.join(directory, executable) + ext)\\n # On Windows os.access(full, os.X_OK) is always True.\\n if os.path.isfile(full) and os.access(full, os.X_OK):\\n return full\\n return None\",\n \"def get_filename(self):\\n \\n for f in os.listdir(self.get_directory()):\\n if os.path.isfile(os.path.join(self.get_directory(), f)):\\n return f\\n \\n return None\",\n \"def GetInputFilename(fname):\\n if not indir or fname[:1] == '/':\\n return fname\\n for dirname in indir:\\n pathname = os.path.join(dirname, fname)\\n if os.path.exists(pathname):\\n return pathname\\n\\n raise ValueError(\\\"Filename '%s' not found in input path (%s) (cwd='%s')\\\" %\\n (fname, ','.join(indir), os.getcwd()))\",\n \"def auto_file(filename, where='.') -> str:\\n\\n if os.path.isabs(filename):\\n return filename\\n\\n prob = os.path.join(where, filename)\\n if os.path.exists(prob) and os.path.isfile(prob):\\n return prob\\n\\n files = list(glob.iglob(os.path.join(where, '**', filename), recursive=True))\\n if len(files) == 0:\\n raise FileNotFoundError('Given file could not be found with recursive search:' + filename)\\n\\n if len(files) > 1:\\n raise FileNotFoundError('More than one file matches given filename. Please specify it explicitly' + filename)\\n\\n return files[0]\",\n \"def search_files(filename, search_path, pathsep=os.pathsep):\\n clidFiles = []\\n for path in search_path.split(pathsep):\\n candidate = os.path.join(path, filename)\\n if os.path.exists(candidate): clidFiles.append(os.path.abspath(candidate))\\n return clidFiles\",\n \"def locate(pth, fn):\\n if is_listing(pth):\\n for ii in pth:\\n ret = locate(ii, fn)\\n if ret:\\n return ret\\n return None\\n # Some specific directory trees would take too much time to traverse.\\n if pth in (\\\"/lib/modules\\\"): \\n return None\\n pthfn = pth + \\\"/\\\" + fn\\n if os.path.isfile(pthfn):\\n return os.path.normpath(pthfn)\\n try:\\n for ii in os.listdir(pth):\\n iifn = pth + \\\"/\\\" + ii\\n if os.path.isdir(iifn):\\n ret = locate(iifn, fn)\\n if ret:\\n return ret\\n except OSError as ee: # Permission denied or the like.\\n if 13 == ee.errno:\\n return None\\n raise ee\\n return None\",\n \"def __findFileName(self):\\n self.ui.showFindFileByNameDialog()\",\n \"def find_in_app(self, app, path):\\n storage = self.storages.get(app)\\n if storage:\\n # only try to find a file if the source dir actually exists\\n if storage.exists(path):\\n matched_path = storage.path(path)\\n if matched_path:\\n return matched_path\",\n \"def module_path_finder(path, name, recursive=True):\\n path_ = None\\n paths = glob(os.path.join(path, '**', '*.py'), recursive=recursive)\\n for path in paths:\\n file_name = os.path.basename(path)\\n if file_name == name + '.py':\\n path_ = os.path.abspath(path)\\n\\n if path_ is None:\\n raise FileNotFoundError(\\\"module %s not found\\\" % name)\\n\\n return path_\",\n \"def find_full_path(path_to_file):\\r\\n for subdir, dirs, files in os.walk(\\\".\\\"):\\r\\n full = os.path.relpath(os.path.join(subdir, path_to_file))\\r\\n if os.path.exists(full):\\r\\n return full\",\n \"def get_path(file_name):\\n path_project = os.getcwd()\\n list_files = os.listdir(path_project)\\n # print (\\\"Getting File in your Current Directory\\\", path_project)\\n __log(1, 'Gatering Files from current Directory.')\\n\\n # for i in list_files:\\n if file_name in list_files:\\n file_path = path_project + '\\\\\\\\' + file_name\\n __log(1, 'Relevant File Found.')\\n return file_path\\n else:\\n __log(2, 'File Not Found.')\\n return -1\\n # print (\\\"File Found\\\",file_path)\",\n \"def find_executable(name, paths):\\n for path in paths:\\n full_path = os.path.join(path, name)\\n if os.path.isfile(full_path):\\n return full_path\\n # If not found, just assume it's in the PATH.\\n return name\",\n \"def find(self, relative_path):\\n found = list(self.grep(relative_path, lazy=True))\\n if found:\\n return found[0]\\n\\n return None\",\n \"def find(path, name):\\n found = [] # list of found items\\n\\n def find_recursive(path, name, found): # recursive function to traverse tree and append found items\\n path_abs = os.path.abspath(path) # get the absolute path name\\n \\n try:\\n dir_items = os.listdir(path_abs)\\n except:\\n print(f\\\"ERROR: Directory {path} not found...\\\")\\n sys.exit(1)\\n\\n dir_items = os.listdir(path_abs) # list all times in the currrent directory\\n\\n for item in dir_items: # iterate over the dir list\\n full_path = os.path.join(path_abs, item) # get the full path name path + filename/directory\\n if os.path.isdir(full_path): # if is a directory\\n find_recursive(full_path, name, found) # make recursive call to function\\n\\n if os.path.isfile(full_path): # if a file\\n if item == name: # check for name equality\\n found.append(full_path) # if true: add to list\\n\\n find_recursive(path, name, found) # call recursive function\\n\\n return found\",\n \"def which(cmd, mode=os.F_OK | os.X_OK, path=None):\\n # Check that a given file can be accessed with the correct mode.\\n # Additionally check that `file` is not a directory, as on Windows\\n # directories pass the os.access check.\\n def _access_check(fn, mode):\\n return (os.path.exists(fn) and os.access(fn, mode) and\\n not os.path.isdir(fn))\\n\\n # If we're given a path with a directory part, look it up directly\\n # rather than referring to PATH directories. This includes checking\\n # relative to the current directory, e.g. ./script\\n if os.path.dirname(cmd):\\n if _access_check(cmd, mode):\\n return cmd\\n return None\\n\\n if path is None:\\n path = os.environ.get(\\\"PATH\\\", os.defpath)\\n if not path:\\n return None\\n path = path.split(os.pathsep)\\n\\n # On other platforms you don't have things like PATHEXT to tell you\\n # what file suffixes are executable, so just pass on cmd as-is.\\n files = [cmd]\\n\\n seen = set()\\n for dir in path:\\n normdir = os.path.normcase(dir)\\n if normdir not in seen:\\n seen.add(normdir)\\n for thefile in files:\\n name = os.path.join(dir, thefile)\\n if _access_check(name, mode):\\n return name\\n return None\",\n \"def get_filename(link):\\r\\n return link[link.rfind(\\\"/\\\") + 1:]\",\n \"def file_exists(self, path: str) -> Optional[GoogleDriveFile]:\\n current_file = self.root\\n file_name_list = self._normalized_path_list(path)\\n normalized_file_path = \\\"/\\\".join(file_name_list)\\n logging.info(f\\\"Checking if {normalized_file_path} exists...\\\")\\n last_index = len(file_name_list) - 1\\n for index, file_name in enumerate(file_name_list):\\n if current_file.file_name != FileName(file_name):\\n return None\\n # If not the last item in the path, then get the next file in the path and assign as root\\n if index < last_index:\\n next_file_name = FileName(file_name_list[index + 1])\\n next_file = current_file.get_child(next_file_name)\\n # If not last item in path and sub-files don't contain the next item, path doesn't exist\\n if next_file is None:\\n return None\\n current_file = next_file\\n else:\\n return current_file\\n raise Exception(\\\"Not suppose to reach here. Check function file_exists\\\")\",\n \"def search_string(command):\\n try:\\n my_file.search_string(command[1])\\n except FileNotFoundError:\\n print('No file has been read yet')\",\n \"def get_file_name(path: str) -> str:\\n return os.path.splitext(os.path.basename(path))[0]\",\n \"def get_file(view: sublime.View, string: str, name: str) -> 'Tuple[str, Optional[str]]':\\n\\n # if it's an absolute path get it\\n if osp.isabs(string):\\n return string, None\\n\\n # if search_mode: \\\"project\\\", search only in project\\n elif Settings.search_mode == \\\"project\\\":\\n # Get base project folders\\n base_folders = sublime.active_window().folders()\\n # if \\\"recursive\\\": true, recursively search for the name\\n if Settings.recursive:\\n ch_rec = check_recursive(base_folders, name)\\n if ch_rec:\\n base_folder, root = ch_rec\\n return osp.join(root, name), base_folder\\n return \\\"\\\", None\\n else:\\n # search only in base folders for the relative path\\n for base_folder in base_folders:\\n file_name = osp.normpath(osp.join(base_folder, string))\\n if osp.exists(file_name):\\n return file_name, base_folder\\n return \\\"\\\", None\\n # if search_mode: \\\"file\\\" join the relative path to the file path\\n else:\\n return osp.normpath(osp.join(osp.dirname(view.file_name()), string)), None\",\n \"def file_name(path):\\n return os.path.basename(path).split('.')[0]\",\n \"def which(fname):\\n if \\\"PATH\\\" not in os.environ or not os.environ[\\\"PATH\\\"]:\\n path = os.defpath\\n else:\\n path = os.environ[\\\"PATH\\\"]\\n\\n for p in [fname] + [os.path.join(x, fname) for x in path.split(os.pathsep)]:\\n p = os.path.abspath(p)\\n if os.access(p, os.X_OK) and not os.path.isdir(p):\\n return p\\n\\n p = sp.Popen(\\\"locate %s\\\" % fname, shell=True, stdout=sp.PIPE, stderr=sp.PIPE)\\n (stdout, stderr) = p.communicate()\\n if not stderr:\\n for p in stdout.decode().split(\\\"\\\\n\\\"):\\n if (\\n (os.path.basename(p) == fname)\\n and (os.access(p, os.X_OK))\\n and (not os.path.isdir(p))\\n ):\\n return p\",\n \"def get_files_for_path(file_ids_tree, path):\\n entry = file_ids_tree\\n parts = path.split('/')\\n for part in parts:\\n if part != '':\\n try:\\n entry = entry[part]\\n except KeyError as e:\\n files = entry[FILE_MARKER]\\n for entry in files:\\n if entry[0] == part:\\n return entry\\n raise e\\n\\n return entry\",\n \"def find_file(file_path=None, args=None, locations=DEFAULT_LOCATIONS,\\n file_name='weewx.conf'):\\n\\n # Start by searching args (if available)\\n if file_path is None and args:\\n for i in range(len(args)):\\n if not args[i].startswith('-'):\\n file_path = args[i]\\n del args[i]\\n break\\n\\n if file_path is None:\\n for directory in locations:\\n # If this is a relative path, then prepend with the\\n # directory this file is in:\\n if not directory.startswith('/'):\\n directory = os.path.join(os.path.dirname(__file__), directory)\\n candidate = os.path.abspath(os.path.join(directory, file_name))\\n if os.path.isfile(candidate):\\n return candidate\\n\\n if file_path is None:\\n raise IOError(\\\"Unable to find file '%s'. Tried directories %s\\\" %\\n (file_name, locations))\\n elif not os.path.isfile(file_path):\\n raise IOError(\\\"%s is not a file\\\" % file_path)\\n\\n return file_path\",\n \"def path_to_file(fname, dirs):\\n for each in dirs:\\n path = '/'.join([each, fname])\\n if os.path.exists(path):\\n return path\\n return None\",\n \"def _FindTemplateFile(self, topdir):\\n if topdir.endswith('..'):\\n topdir = '/'.join(topdir.split('/')[:-2])\\n fnames = os.listdir(topdir)\\n for fname in fnames:\\n filename = '%s/%s' % (topdir, fname)\\n if filename.endswith('.yaml') and not os.path.isdir(filename) and \\\\\\n os.path.exists(filename):\\n f = open(filename, 'r')\\n magic_code = f.read(22)\\n f.close()\\n if '#!fmri_file_template' in magic_code:\\n return filename\\n return None\",\n \"def find_file(directory, extensions):\\n for filename in os.listdir(directory):\\n if filename.endswith(extensions):\\n return \\\"{}/{}\\\".format(directory, filename)\\n return None\",\n \"def get_file_name(path):\\n logger.debug('Function Successful: % s',\\n 'get_file_name: get_file_name successfully called from local_save', extra=d)\\n logger.info('Extracting file name...')\\n\\n split_path = path.split(\\\"/\\\")\\n file_name = split_path[len(split_path) - 1]\\n\\n logger.debug('Returning: %s',\\n 'get_file_name: returning the file name', extra=d)\\n logger.info('File name extracted')\\n\\n return file_name\",\n \"def find_file_by_name(**kwargs):\\n return AppServer.service.find_file_by_name(name=kwargs['name'])\",\n \"def check_file(file: Path):\\n if Path(file).is_file() or file == \\\"\\\":\\n return file\\n else:\\n files = glob.glob(\\\"./**/\\\" + file, recursive=True) # find file\\n FILE_NOT_FOUND_MSG = f\\\"File Not Found: {file}\\\"\\n MULTIPLE_FILE_MSG = f\\\"Multiple files match '{file}', specify exact path:{files}\\\"\\n\\n assert len(files), FILE_NOT_FOUND_MSG # assert file was found\\n assert len(files) == 1, MULTIPLE_FILE_MSG # assert unique\\n return files[0] # return file\",\n \"def filename_from_path(filepath: str) -> str:\\n return filepath.split(\\\"/\\\")[-1]\",\n \"def find_specific_file_extension_in_dir(dir_path, extension):\\r\\n return glob.glob(os.path.join(dir_path, r'*{}'.format(extension)))[0].replace('\\\\\\\\', '/').split('/')[-1]\",\n \"def locate_file(self, filename):\\n return locate_file(filename, self.observatory)\",\n \"def _file_in_subdir(self, subdir, filename, check_exists=False):\\n filepath = join(self.dir, subdir, filename)\\n\\n if check_exists and not isfile(filepath) and not isdir(filepath):\\n\\n # Try the filename as a pattern or regex before failing:\\n matches = self._files_in_subdir(subdir,\\n pattern='**/*{}*'.format(filename),\\n regex=None)\\n\\n # Don't accept ambiguous patterns!\\n if len(matches) == 1:\\n return matches[0]\\n\\n raise FileNotFoundError(filepath)\\n\\n return filepath\",\n \"def find_meshfn(lp):\\n try:\\n trash, ffind = build_meshfn(lp)\\n print 'ffind = ', ffind\\n print 'found --> ', sorted(glob.glob(ffind))[0]\\n meshfn = sorted(glob.glob(ffind))[0][0:-7]\\n except IndexError:\\n raise RuntimeError('ERROR: Could not find specified meshfn!')\\n return meshfn\",\n \"def qualify_full_filepath(filename, path=None):\\n filepath = os.path.join(path or \\\"\\\", filename)\\n if not os.path.isfile(filepath):\\n raise OSError(f\\\"No available file found at: {filename}.\\\")\\n return filepath\",\n \"def name_from_path(path):\\n return path[0:-3]\",\n \"def extract_file_name(file_path):\\n # ファイルパスからファイル名(拡張子含む)を取り出す\\n file_name = file_path.split('/')[-1]\\n # 拡張子を取り除く\\n return file_name.split('.')[0]\",\n \"def\\textractPathFromPathfilename(self,fullPathFilename):\\n\\t\\treturn(fullPathFilename[0:fullPathFilename.rfind('\\\\\\\\')+1])\",\n \"def find_qualified_name(filename, max_iterations=5):\\n filename = os.path.abspath(filename)\\n vc_root = find_vc_root(filename, max_iterations)\\n _, name = filename.split(f\\\"{vc_root}/\\\")\\n if name.endswith(\\\".py\\\"):\\n name = name[:-3]\\n return name.replace(\\\"/\\\", \\\".\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77612054","0.77612054","0.7716344","0.750982","0.74376416","0.74000573","0.7346764","0.7340276","0.72320473","0.7171325","0.71397066","0.7084991","0.7063053","0.6908678","0.6906146","0.6898922","0.6848443","0.6828708","0.68076605","0.67631036","0.67435795","0.6706911","0.66426307","0.6603381","0.65794027","0.657846","0.6568988","0.65626985","0.64972186","0.6470107","0.64623064","0.6456517","0.6439699","0.643045","0.639283","0.63640964","0.6359211","0.63415444","0.6327939","0.6312753","0.6264591","0.6256148","0.6255039","0.62495506","0.62243384","0.62119734","0.6210423","0.6198238","0.6182848","0.61772096","0.6159053","0.6158459","0.6152626","0.61524355","0.6141317","0.6124502","0.6117323","0.61045927","0.61043257","0.6103829","0.61002016","0.6097941","0.609502","0.6092668","0.60879695","0.60837567","0.60409975","0.60402626","0.60287905","0.6025799","0.6023867","0.60167843","0.6014927","0.599477","0.59912056","0.5987761","0.5985989","0.59724045","0.5966702","0.59572864","0.5957226","0.5956527","0.5956131","0.5955613","0.5951751","0.5950776","0.5943713","0.5942691","0.5939231","0.5933505","0.5929543","0.59251845","0.5922084","0.5919859","0.59196526","0.59157115","0.5906874","0.58991003","0.5874169","0.586991","0.5867669"],"string":"[\n \"0.77612054\",\n \"0.77612054\",\n \"0.7716344\",\n \"0.750982\",\n \"0.74376416\",\n \"0.74000573\",\n \"0.7346764\",\n \"0.7340276\",\n \"0.72320473\",\n \"0.7171325\",\n \"0.71397066\",\n \"0.7084991\",\n \"0.7063053\",\n \"0.6908678\",\n \"0.6906146\",\n \"0.6898922\",\n \"0.6848443\",\n \"0.6828708\",\n \"0.68076605\",\n \"0.67631036\",\n \"0.67435795\",\n \"0.6706911\",\n \"0.66426307\",\n \"0.6603381\",\n \"0.65794027\",\n \"0.657846\",\n \"0.6568988\",\n \"0.65626985\",\n \"0.64972186\",\n \"0.6470107\",\n \"0.64623064\",\n \"0.6456517\",\n \"0.6439699\",\n \"0.643045\",\n \"0.639283\",\n \"0.63640964\",\n \"0.6359211\",\n \"0.63415444\",\n \"0.6327939\",\n \"0.6312753\",\n \"0.6264591\",\n \"0.6256148\",\n \"0.6255039\",\n \"0.62495506\",\n \"0.62243384\",\n \"0.62119734\",\n \"0.6210423\",\n \"0.6198238\",\n \"0.6182848\",\n \"0.61772096\",\n \"0.6159053\",\n \"0.6158459\",\n \"0.6152626\",\n \"0.61524355\",\n \"0.6141317\",\n \"0.6124502\",\n \"0.6117323\",\n \"0.61045927\",\n \"0.61043257\",\n \"0.6103829\",\n \"0.61002016\",\n \"0.6097941\",\n \"0.609502\",\n \"0.6092668\",\n \"0.60879695\",\n \"0.60837567\",\n \"0.60409975\",\n \"0.60402626\",\n \"0.60287905\",\n \"0.6025799\",\n \"0.6023867\",\n \"0.60167843\",\n \"0.6014927\",\n \"0.599477\",\n \"0.59912056\",\n \"0.5987761\",\n \"0.5985989\",\n \"0.59724045\",\n \"0.5966702\",\n \"0.59572864\",\n \"0.5957226\",\n \"0.5956527\",\n \"0.5956131\",\n \"0.5955613\",\n \"0.5951751\",\n \"0.5950776\",\n \"0.5943713\",\n \"0.5942691\",\n \"0.5939231\",\n \"0.5933505\",\n \"0.5929543\",\n \"0.59251845\",\n \"0.5922084\",\n \"0.5919859\",\n \"0.59196526\",\n \"0.59157115\",\n \"0.5906874\",\n \"0.58991003\",\n \"0.5874169\",\n \"0.586991\",\n \"0.5867669\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83197,"cells":{"query":{"kind":"string","value":"Creates an array of images"},"document":{"kind":"string","value":"def create_image_array(files_list):\n im_array = np.array([np.array(cv2.imread(file)) for file in files_list])\n return im_array"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def makearray(self, *args, **kwargs):\n return _image.image_makearray(self, *args, **kwargs)","def gen_image(self, nimage):\n tmp = [0] * nimage\n for i in np.arange(nimage):\n tmp[i] = self.gen_one_image()\n \n return np.array(tmp)","def generate_images(\n n: int = 128, w: int = 32, h: int = 32, c: int = 1, random_seed: int = None\n) -> TYPE_ARRAY:\n return _RNG.randint(0, 256, n * c * w * h).reshape(n, c, w, h)","def getimgs():","def load_images(folder_path, num_images):\n imgs = np.zeros(shape=[num_images, 400, 400, 3])\n for i in range(1, num_images + 1):\n image_name = \"satImage_%.3d\" % i\n image_path = folder_path + image_name + \".png\"\n if os.path.isfile(image_path):\n print('Loading ' + image_path)\n img = mpimg.imread(image_path)\n\n #imgs[i - 1] = np.asarray(img).reshape(400, 400, 3)\n imgs[i - 1] = img.reshape(400, 400, 3)\n else:\n print('File ' + image_path + ' does not exist')\n return imgs","def get_images(self):\n return [self.get_image(i) for i in range(0, self.number_sprites - 1)]","def _extract_images(image_paths):\n\n num_images = len(image_paths)\n data = np.zeros((num_images, _IMAGE_SIZE, _IMAGE_SIZE, _NUM_CHANNELS))\n for i in range(num_images):\n image_path = image_paths[i]\n print('Extracting images from: ', image_path)\n image = imageio.imread(image_path)\n data[i] = image\n\n return data","def create_initial_pictures():\n pictures = []\n\n for i in xrange(0, 9):\n pic = Picture()\n pic = Picture.create_random(pic, 1)\n\n pictures.append(pic)\n\n return pictures","def construct_image(imgs):\n\n # todo fill missing pieces and\n\n if len(imgs) == 0:\n return None\n # taking the first\n w, h = imgs[0][1].size\n img_array = order_2d(imgs)\n x_count = len(img_array[0])\n y_count = len(img_array)\n height = h * y_count\n width = w * x_count\n new_im = Image.new('RGB', (width, height))\n for y in range(y_count):\n for x in range(x_count):\n _, im = img_array[y][x]\n new_im.paste(im, (x * w, y * h))\n return new_im","def load_images(filenames):\n h,w,c = SIZE\n images = np.empty((len(filenames),h,w,c))\n for i,img_path in enumerate(filenames):\n # Base64\n with open(img_path,'rb') as image_file:\n img_base64_encode = base64.b64encode(image_file.read())\n img_base64 = base64.b64decode(img_base64_encode)\n images[i] = np.array(Image.open(io.BytesIO(img_base64)))/255.0 # Reducción en distancia\n return images","def get_images(self, file_path: str) -> Iterable[Image]:\n return []","def newimagefromarray(self, *args, **kwargs):\n return _image.image_newimagefromarray(self, *args, **kwargs)","def image_batch():\n return np.zeros((2, 1, 4, 4))","def img_from_array(array):\n return Image.fromarray(array)","def get_img_array(myzipfile, imgid, shape=(299,299)):\n img_arr = np.zeros(shape=(512, 512, 3), dtype=np.float32)\n img_green = Image.open(myzipfile.open(f'{imgid}_green.png'))\n img_blue = Image.open(myzipfile.open(f'{imgid}_blue.png'))\n img_red = Image.open(myzipfile.open(f'{imgid}_red.png'))\n img_yellow = Image.open(myzipfile.open(f'{imgid}_yellow.png'))\n img_arr[:,:,0] = np.divide(np.array(img_green), 255)\n img_arr[:,:,1] = np.divide(np.array(img_blue), 255)/2 + np.divide(np.array(img_yellow), 255)/2\n img_arr[:,:,2] = np.divide(np.array(img_red), 255)/2 + np.divide(np.array(img_red), 255)/2\n img_arr = cv2.resize(img_arr, shape)\n return img_arr","def get_images(path_list):\n images = []\n labels = []\n names = []\n i = 0\n for path in path_list:\n for fruit_dir_path in glob.glob(path):\n fruit_label = fruit_dir_path.split(\"/\")[-1]\n for image_path in glob.glob(os.path.join(fruit_dir_path, \"*.jpg\")):\n image = cv2.imread(image_path, cv2.IMREAD_COLOR)\n\n image = cv2.resize(image, (45, 45))\n image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n\n images.append(image)\n names.append(fruit_label)\n labels.append(i)\n i += 1\n\n images = np.array(images)\n print(images.shape)\n # add a new dimension here\n with np.nditer(images, op_flags=['readwrite']) as it:\n for x in it:\n x = np.expand_dims(x, axis=0)\n labels = np.array(labels)\n return images, labels, i","def _convert_images(raw):\n # Convert the raw images from the data-files to floating-points.\n #raw_float = np.array(raw, dtype=float) / 255.0\n\n # Reshape the array to 4-dimensions.\n images = raw.reshape([-1, num_channels, img_size, img_size])\n\n # Reorder the indices of the array.\n images = images.transpose([0, 2, 3, 1])\n\n return images","def images(self, first, last, shape, validfirst, validlast):\n size = shape[0] * shape[1] * (1 + last - first)\n array = np.ascontiguousarray(np.zeros(size, dtype=np.int32))\n self.lib.GetImages(ct.c_long(first), ct.c_long(last),\n array.ctypes.data_as(ct.POINTER(ct.c_int32)),\n ct.c_ulong(size), ct.pointer(ct.c_long(validfirst)),\n ct.pointer(ct.c_long(validlast)))\n\n return array.reshape(-1, shape[0], shape[1])","def create_images(dataFpath, width, height, angles=[]):\n\n imgSize = width * height\n\n\n def _resize_n_cast(_img):\n return resize(_img, (width, height)).ravel().reshape(1, imgSize).astype(theano.config.floatX)\n\n\n origImg = 1 - trim_image(imread(dataFpath, as_grey=True), bgValue=255)\n\n straightImg = _resize_n_cast(origImg)\n rotatedImgs = [_resize_n_cast(rotate(origImg, angle)) for angle in angles]\n\n return [straightImg] + rotatedImgs","def make_imgs(img: ndarray, imin: Any = None, imax: Any = None) -> [ndarray]:\n imin = img.min() if imin is None else imin\n imax = img.max() if imax is None else imax\n scaled = np.array(((img - imin) / (imax - imin)) * 255, dtype=int) # img\n if len(img.shape) == 3:\n return [scaled] * 3\n raise ValueError(\"Only accepts 1-channel or 3-channel images\")","def prepare_image_list(path, image_name, i_range):\n DisplayNetwork.display_green(\"[INFO] Loading the images to train the network\")\n positives = []\n file_list = commands.getoutput('ls ./' + path + '/*.jpg | xargs -n 1 basename').split(\"\\n\")\n\n for i in i_range:\n image_name = path + '/' + file_list[i]\n DisplayNetwork.display_yellow(\"[INFO] Loading image\" + image_name)\n\n image_matrix = ImageFunctions.turnImageToGray(image_name) # Load image as gray\n reshaped = np.reshape(image_matrix, 361) # makes 19x19 matrix to 1x361 vector\n positives.append(reshaped.tolist())\n\n return np.array(positives)","def get_images(self) -> Sequence[Optional[np.ndarray]]:\n raise NotImplementedError","def get_imgs(paths_list: list) -> list:\n \n imgs_list = [Image.open(project_path + data_path + paths_list[i]) for i in range(len(paths_list))]\n \n return imgs_list","def create_sequence_of_images(size, source_image, target_image, \n source_triangles_list, target_triangles_list, num_frames):\n # initiate the list of intermediate images\n images_list = []\n # run over the num_frames value to create the intermediate images\n for i in range(0,num_frames):\n # add to the list the current intermediate image create by\n # create_intermediate_image with the current alpha value\n images_list.append(create_intermediate_image(i/(num_frames-1),\n size,source_image,\n target_image,\n source_triangles_list,\n target_triangles_list))\n return images_list","def make_images(self):\n self._images = [tree.to_image() for tree in self.reaction_trees]\n self._update_route_dict(self._images, \"image\")","def read_images(path_list, img_height, img_width):\n\n out = []\n for img_path in path_list:\n # Below line converts to a PIL Python Image Library format\n img = image.load_img(img_path, target_size=(img_height, img_width))\n x = image.img_to_array(img) # Convert a PIL image to a numpy array\n x = np.expand_dims(x, axis=0) # (1, dim1, dim2, channels) Type: float32\n out.append(x.astype('uint8'))\n return np.vstack(out) # Stack the images one below the other (rows)","def __readImages(self, filename):\n print 'Reading images from %s ...' % filename\n images = []\n with open(filename, 'rb') as infile:\n infile.read(4) # ignore magic number\n count = struct.unpack('>i', infile.read(4))[0]\n rows = struct.unpack('>i', infile.read(4))[0]\n columns = struct.unpack('>i', infile.read(4))[0]\n\n for i in xrange(count):\n data = infile.read(rows*columns)\n image = np.fromstring(data, dtype=np.uint8)\n image = image.reshape((rows, columns))\n image = 255 - image # now black digit on white background\n images.append(image)\n return images","def loadImages(loadPath):\n img_array = []\n for filename in glob.glob(loadPath):\n img = cv2.imread(filename)\n height, width, layers = img.shape\n size = (width, height)\n img_array.append(img)\n\n return img_array","def buildImages(files, targets, type):\n images = []\n for file in files:\n targets.append(file)\n with open(file, \"rb\") as f:\n if type == \"Byte\":\n images.append(bytePlot(list(f.read())))\n elif type == \"Markov\":\n images.append(markovPlot(list(f.read())))\n elif type == \"Hilbert\":\n images.append(hilbertPlot(list(f.read())))\n smp.imsave(\"{}.png\".format(file), images[-1])\n return images, targets","def read_images(image_dir, names, image_size=None):\n num_images = len(names)\n image = skimage.io.imread(os.path.join(image_dir, names[0] + '.jpg'))\n dtype = image.dtype;\n if image_size is None:\n image_size = image.shape[0:2]\n\n images = numpy.empty((num_images, image_size[0], image_size[1], 3), dtype=dtype)\n with tqdm.tqdm(total=num_images) as progress:\n for index, name in enumerate(names):\n image = skimage.io.imread(os.path.join(image_dir, name + '.jpg'))\n if image_size is None:\n images[index, :, :, :] = image\n else:\n images[index, :, :, :] = resize_image(image, image_size)\n progress.update(1)\n\n return images","def make_image_list(self):\n image_list = [self.spritesheet_dict['closed'],\n self.spritesheet_dict['opened']]\n\n return image_list","def to_numpy(id:int, samples:list=None):\n\t\t\tsamples = listify(samples)\n\t\t\timages = Dataset.Image.to_pillow(id, samples=samples)\n\t\t\timages = [np.array(img) for img in images]\n\t\t\timages = np.array(images)\n\t\t\treturn images","def generate_array_image(R, G, B, height, width):\n R = R.reshape((height, width))\n G = G.reshape((height, width))\n B = B.reshape((height, width))\n \n return np.moveaxis(np.array([R, G, B]), 0, -1)","def build_mono_image_dataset(self):\n images = [np.expand_dims(company.get_mono_image(),axis = 0) for company in self]\n images = np.vstack(images)\n return images","def images(self):\n if self._images is None:\n self.make_images()\n return self._images","def _iter_images(self):\n for image in self._images:\n yield np.array(image.convert('RGB'))","def _load_images(paths):\n assert isinstance(paths, list)\n _R_MEAN = 123.68\n _G_MEAN = 116.78\n _B_MEAN = 103.94\n\n # allocate memory\n images = np.zeros([len(paths), FLAGS.target_height, FLAGS.target_width, 3],\n dtype=np.float32)\n\n # load all images\n pbar = ProgressBar(max_value=len(paths))\n for i in range(len(paths)):\n img = sio.imread(paths[i])\n\n # resize images\n img = sresize(img, (FLAGS.target_height, FLAGS.target_width, 3),\n mode='constant', preserve_range=True)\n\n # store images\n images[i] = img.astype(np.float32)\n pbar.update(i)\n\n # mean removal\n images -= [_R_MEAN, _G_MEAN, _B_MEAN]\n return images","def tile_images(image_stack):\n assert len(image_stack.shape) == 4\n image_list = [image_stack[i, :, :, :] for i in range(image_stack.shape[0])]\n tiled_images = np.concatenate(image_list, axis=1)\n return tiled_images","def array_from_img(image):\n return np.array(image)","def returnImages(input_data):\r\n if type(input_data) is list:\r\n return [returnImages(element) for element in input_data]\r\n else:\r\n return cv.imread(input_data, 0)","def concat_images(X):\n nc,h,w,_ = X.shape\n X = X.reshape(nc,h,w)\n n = np.ceil(np.sqrt(nc)).astype(\"int8\")\n img = np.zeros((n*w,n*h))\n x = 0\n y = 0\n for example in range(nc):\n img[x*w:(x+1)*w,y*h:(y+1)*h] = X[example]\n y += 1\n if y >= n:\n y = 0\n x += 1\n return img","def load_images(self, image_path):\n X_train = []\n\n # Load all files from the image path using Image.open.\n for i in recursive_list(image_path):\n # Open images as ???\n img = Image.open(i)\n # Convert to NP array.\n img = np.asarray(img)\n # Append them into higher order array.\n if img.shape == (128, 128, 3):\n X_train.append(img)\n\n # return all the images concatenated as a 4D array\n return np.asarray(X_train)","def makeImageFromArray(array):\n if array is None: return None\n cls = globals()[\"Image%s\" % suffixes[str(array.dtype.type)]]\n return cls(array)","def osszefuzes(img_loc):\n files = sorted(glob(img_loc))\n imgs = np.array([imageio.imread(f) for f in files])\n\n return imgs","def numpy_to_pil(images):\n if images.ndim == 3:\n images = images[None, ...]\n images = (images * 255).round().astype(\"uint8\")\n if images.shape[-1] == 1:\n # special case for grayscale (single channel) images\n pil_images = [Image.fromarray(image.squeeze(), mode=\"L\") for image in images]\n else:\n pil_images = [Image.fromarray(image) for image in images]\n\n return pil_images","def resize_images(self, images):\n \n img_list = []\n \n for img in images:\n \n yield np.resize(img, (64, 64, 3))","def load_images(self, image_paths):\n \n fill_list = []\n \n for idx in tqdm(range(len(image_paths))):\n path = image_paths[idx]\n yield cv2.imread(path)","def __call__(self, in_images):\n ret_images = []\n for image in in_images:\n if self.curr_elements < self.max_elements:\n self.images.append(image)\n ret_images.append(image)\n self.curr_elements+=1\n else:\n if np.random.uniform() > 0.5:\n idx = np.random.randint(0, self.curr_elements)\n temp = copy.deepcopy(self.images[idx])\n self.images[idx] = image\n ret_images.append(temp)\n else:\n ret_images.append(image)\n return ret_images","def build_filler_images(self):","def convert_images_to_arrays_train(file_path, df):\n\n lst_imgs = [l for l in df['image']]\n array = []\n for img_name in lst_imgs:\n img = Image.open(file_path + img_name)\n array.append(np.array(img))\n img.close()\n\n return np.array(array)","def get_images(self):\n \n images = []\n for order in self.order_lst:\n o_items = order.get_items()\n images.append(o_items.get_image())\n \n return images","def get_images(self):\n \n return self.img_lst","def create_images_as_numpy(idx, out_dir, model_outs, K):\n masks = model_outs['pis'].exp()\n sub_images = model_outs['x_loc']\n\n images = []\n all_masks = []\n all_subis = []\n for i in range(K):\n images += [masks[i,0] * sub_images[i,0]]\n all_masks += [masks[i,0]]\n all_subis += [sub_images[i,0]]\n\n images = torch.stack(images)\n all_masks = torch.stack(all_masks)\n all_subis = torch.stack(all_subis)\n whole_image = images.sum(0)\n\n all_masks_grid = torchvision.utils.make_grid(all_masks, nrow=K)\n all_subis_grid = torchvision.utils.make_grid(all_subis, nrow=K)\n all_images_grid = torchvision.utils.make_grid(images, nrow=K)\n \n filepath = out_dir / f'whole_image_{idx}'\n np.save(filepath, whole_image.data.cpu().numpy())\n filepath = out_dir / f'all_images_{idx}'\n np.save(filepath, all_images_grid.data.cpu().numpy())\n filepath = out_dir / f'masks_{idx}'\n np.save(filepath, all_masks_grid.data.cpu().numpy())\n filepath = out_dir / f'sub_images_{idx}'\n np.save(filepath, all_subis_grid.data.cpu().numpy())","def process_image(self, image_path):\n\n img = load_img(image_path, target_size=IMAGE_SIZE)\n img_array = img_to_array(img)\n # Create a batch by increase dimensions\n img_array = expand_dims(img_array, 0)\n print(img_array.shape)\n return img_array","def generate_imgs(self, count, threshold, modifier):\n self.build_gan()\n\n\n imgs = []\n for i in range(count):\n score = [0]\n while not(threshold[0] < score[0] < threshold[1]):\n img = self.gene_imgs(1)\n score = self.discriminator.predict(img)\n print(\"Image found: \", score[0])\n imgs.append(img)\n\n imgs = np.asarray(imgs).squeeze()\n imgs = 0.5 * imgs + 0.5\n\n print(imgs.shape)\n for i, img_array in enumerate(imgs):\n path = f\"{self.output_directory}/generated_{threshold[0]}_{threshold[1]}\"\n if not os.path.exists(path):\n os.makedirs(path)\n imsave(path + f\"/{modifier}_{i}.png\", self.pix_array_convert(img_array))","def tile_images(img, img_size=32, rows=4, cols=4, spacing=1):\n images = np.ones([3, rows * (img_size + spacing) - spacing, cols * (img_size + spacing)], dtype=np.float32)\n coords = [(i, j) for i in range(rows) for j in range(cols)]\n\n for (i, j), image in zip(coords, img):\n x = i * (img_size + spacing)\n y = j * (img_size + spacing)\n images[:, x: x+img_size, y:y+img_size] = image\n\n return images","def readImages(imgFolder='img/'):\n #Each image in images is a numpy array of shape 192x168(x1) (heightxwidth)\n #images datatype is a regular numpy list\n filenames = os.listdir(imgFolder)\n if imgFolder == 'img/':\n images = [imageio.imread('img/'+fn+'/image0.jpg')[::,::].astype(np.float32)/255. for fn in filenames]#glob.glob(imgFolder+'*.jpg')]\n else:\n images = [imageio.imread(imgFolder+fn)[::,::].astype(np.float32)/255. for fn in filenames]\n return images","def load_images(filelist):\n # pixel value range 0-255\n if not isinstance(filelist, list):\n im = Image.open(filelist).convert('L')\n return np.array(im).reshape(1, im.size[1], im.size[0], 1)\n data = []\n for file in filelist:\n im = Image.open(file).convert('L')\n data.append(np.array(im).reshape(1, im.size[1], im.size[0], 1))\n return data","def create_images(images_steps, horizon):\n images = []\n\n def _create_images(*image_names):\n _images = []\n\n for image_name in image_names:\n images_steps.create_image(image_name, check=False)\n images_steps.close_notification('success')\n\n image = utils.AttrDict(name=image_name)\n images.append(image)\n _images.append(image)\n\n for image_name in image_names:\n horizon.page_images.table_images.row(\n name=image_name).wait_for_status('Active')\n\n return _images\n\n yield _create_images\n\n if images:\n images_steps.delete_images([image.name for image in images])","def _images(path):\r\n with gzip.open(path) as f:\r\n # First 16 bytes are magic_number, n_imgs, n_rows, n_cols\r\n pixels = np.frombuffer(f.read(), 'B', offset=16)\r\n return pixels.reshape(-1, 784).astype('float32') / 255","def listImages(name_list, path, as_grey=True):\n\timage_list = []\n\n\tfor name in name_list:\n\t\timage = io.imread(path + \"/\" + name + \".jpg\", as_grey=as_grey)\n\t\tif as_grey is True:\n\t\t\timage = resize(image, (200, 200))\n\t\timage_list.append(image)\n\n\treturn image_list","def _create_zl_imgs_given_ids(self, ids: list, subset: str, ann_type: str) -> ZLIMGS:\n assert subset in [\"none\", \"small\", \"train\", \"dev\", \"test\"]\n assert ann_type in [\"none\", \"label\", \"bbox\", \"mask\"]\n\n if subset == 'none':\n ids = []\n elif subset == 'small':\n ### WARNING: the alteration of random seed will effect the sample of \"small\" subset\n ids = self.rnd.sample(ids, len(ids) // 10)\n else:\n pass\n\n zl_imgs = []\n for id in ids:\n zl_img = ZLImage(img_id=id, ann_type=ann_type, dataset_dir=self.dataset_dir)\n zl_imgs.append(zl_img)\n\n return zl_imgs","def image(images):\n return images[0]","def get_images(fish):\n fish_dir = TRAIN_DIR+'{}'.format(fish)\n images = [fish+'/'+im for im in os.listdir(fish_dir)]\n return images","def _arr_to_img(arr, verbose=False):\n return Image.fromarray(arr)","def read_vanhateren_images (n_imgs=5):\n folder_name = r'D:\\VanHateren\\vanhateren_imc' # change this to point to the directory which holds the van hateren data\n # files = listdir(folder_name)\n onlyfiles = [ f for f in listdir(folder_name) if isfile(join(folder_name,f)) ]\n imgs = []\n for i in range(n_imgs):\n filename = join(folder_name, onlyfiles[i])\n with open(filename, 'rb') as handle:\n s = handle.read()\n arr = array.array('H', s)\n arr.byteswap()\n img_i = np.array(arr, dtype='uint16').reshape(1024, 1536)\n imgs.append(img_i) \n return imgs\n #pylab.imshow(img)\n #pylab.show()","def fromarray(self, *args, **kwargs):\n return _image.image_fromarray(self, *args, **kwargs)","def _listOfImagesToNumpy(self, images):\n # build image data array, y_labels\n for i in range(0, len(images)):\n if self.image_size is not None:\n img = images[i].resize(self.image_size)\n else:\n img = images[i]\n img_arr = img_to_array(img)\n if i == 0:\n dims = [len(images)] + list(img_arr.shape)\n X_data = np.zeros(shape=dims)\n X_data[i, :, :, :] = img_arr\n\n return X_data","def splitImages(self):\n imgs = self.img_list\n frames = self.frame_number.value()\n grps = []\n for i in range(0, len(imgs), frames):\n grps.append(imgs[i:i + frames])\n\n return grps","def getImages(self,Project=\"\"):\n #images = [\"image1.jpg\",\"image2.jpg\",\"image3.jpg\"]\n \n os.chdir(self.dataDir)\n images = glob.glob(\"*.png\")\n \n return images","def generate_image(self):\n\t\tcenters = self.generate_centers()\n\t\timg = Image.new('RGB', (self.config.image_size, self.config.image_size), color=(0,0,0))\n\t\tshapes = np.random.randint(2, size=len(centers))\n\t\tdrawer = ImageDraw.Draw(img)\n\t\tr = int(0.05 * self.config.image_size)\n\t\tR = []\n\t\tfor i in range(len(centers)):\n\t\t\tcoor = (centers[i][0] - r , centers[i][1] - r, centers[i][0] + r, centers[i][1] + r)\n\t\t\tif shapes[i] < 0.5:\n\t\t\t\tdrawer.rectangle(coor, fill=COLOR[i])\n\t\t\telse:\n\t\t\t\tdrawer.ellipse(coor, fill=COLOR[i])\n\t\t\tR.append([centers[i], i, shapes[i]])\n\t\treturn np.array(img), R","def create_preset_images(self):\n for f in sorted(self.get_files_from_data()):\n photoInstances = {}\n for preset in self.generator.settings[\"GALLERY_PRESETS\"]:\n preset_dir = \"%s%s%s\" % (self.absolute_output_path,\n os.sep, \n preset[\"name\"])\n photoInstances[preset[\"name\"]] = Photo(self, f, preset_dir, preset)\n \n self.photos.append(photoInstances)","def make_image(file):\n image = cv2.imread(file, 0)\n image = cv2.resize(image, (IMG_SIZE, IMG_SIZE))\n return np.array([np.array(image), np.array([0, 0])])","def load_images(tags_pict):\n img_data_list = []\n for p in tags_pict.index :\n img_path = tags_pict.full_path[p]\n img = load_img(img_path, target_size= inputShape)\n x = img_to_array(img)\n x = np.expand_dims(img, axis=0)\n # pre-process the image using the appropriate function based on the\n # model that has been loaded (i.e., mean subtraction, scaling, etc.)\n x = preprocess_input(x)\n img_data_list.append(x)\n img_data = np.array(img_data_list)\n img_data=np.rollaxis(img_data,1,0)\n img_data=img_data[0]\n return(img_data)","def get_images_online(self, img_names):\n images = []\n errs = []\n for img_name in img_names:\n try:\n path = IMAGES_FOLDER + img_name\n # print(path)\n img = get_image(path, self.img_shape)\n x = image.img_to_array(img)\n x = np.expand_dims(x, axis=0)\n images.append(x)\n except Exception as e:\n # print(path,str(e))\n errs.append(img_name)\n\n return np.vstack(images), errs","def images(self, **kwargs):\n\n raise NotImplementedError","def load_images(self):\n images_list = [os.path.join(self.root, image['file_name'])\n for image in self.data['images']]\n\n if self.shuffle:\n random.shuffle(images_list)\n images_list = images_list[:self.max_samples] if self.max_samples is not None and self.max_samples <= len(\n images_list) else images_list\n\n return images_list","def create_image(images_steps):\n images = []\n\n def _create_image(image_name, *args, **kwgs):\n images_steps.create_image(image_name, *args, **kwgs)\n image = utils.AttrDict(name=image_name)\n images.append(image)\n return image\n\n yield _create_image\n\n for image in images:\n images_steps.delete_image(image.name)","def array2img(array):\n if len(array.shape) == 2:\n return Image.fromarray(np.clip(array, 0, 255).astype('uint8'), mode='L')\n elif len(array.shape) == 3:\n return Image.fromarray(np.clip(array, 0, 255).astype('uint8'), mode='RGB')\n else:\n print('Income array is not at appropriate shape!')","def create_new_images(x):\n \n datagen = ImageDataGenerator(width_shift_range=0.1,\n height_shift_range=0.1,\n shear_range=0.1,\n zoom_range=0.1,\n horizontal_flip=True,\n fill_mode='constant',\n cval=0) \n \n i = 0\n for batch in datagen.flow(x, batch_size=1,\n save_to_dir='data/Histology/new_benign',\n save_prefix='benign',\n save_format='jpeg'):\n i += 1 \n if i > 3:\n break\n \n return 0","def load_images(pool, entries):\n start = time.perf_counter()\n images = pool.map(ski.io.imread, [x.path for x in entries])\n logger.info(\"Loaded %i images:\", len(images))\n util.pprint_log([x.name for x in entries], logger.info)\n logger.info(util.elapsed(start))\n logger.info(\"\\n\")\n return images","def np_make_image_grid(images, nrow, pad=2):\n height, width = images[0].shape[:2]\n ncol = int(np.ceil(len(images) / nrow))\n ncolors = images[0].shape[-1]\n result_imshape = [nrow * (height + pad), ncol * (width + pad), ncolors]\n if len(images[0].shape) == 2: # grayscale image\n ncolors = 1\n result_imshape[-1] = 1\n im_result = np.zeros(result_imshape, dtype=images[0].dtype)\n im_idx = 0\n for row in range(nrow):\n for col in range(ncol):\n if im_idx == len(images):\n break\n im = images[im_idx]\n im = normalize(im)\n im_idx += 1\n im_result[row * (pad + height): (row) * (pad + height) + height,\n col * (pad + width): (col) * (pad + width) + width, :] = im.reshape(height, width, -1)\n if ncolors == 1:\n im_result = im_result[:, :, 0]\n return im_result","def process_batch(self, image_batch):\n images = []\n for image_data in image_batch:\n image_resize = cv2.resize(image_data, (0,0), fx=0.5, fy=0.5) #NOTE\n images.append(image_resize)\n\n return np.array(images)","def generate_images(self, image_idx, is_training, batch_size=16):\n \n # arrays to store our batched data\n images, ages, races, genders = [], [], [], []\n while True:\n for idx in image_idx:\n person = self.df.iloc[idx]\n \n age = person['age']\n race = person['race_id']\n gender = person['gender_id']\n file = person['file']\n \n im = self.preprocess_image(file)\n \n ages.append(age / self.max_age)\n races.append(to_categorical(race, len(dataset_dict['race_id'])))\n genders.append(to_categorical(gender, len(dataset_dict['gender_id'])))\n images.append(im)\n \n # yielding condition\n if len(images) >= batch_size:\n yield np.array(images), [np.array(ages), np.array(races), np.array(genders)]\n images, ages, races, genders = [], [], [], []\n \n if not is_training:\n break","def imageToArray(i):\r\n a=gdalnumeric.numpy.fromstring(i.tostring(),'b')\r\n a.shape=i.im.size[1], i.im.size[0]\r\n return a","def load_images(self,im_paths,imlist,im_index):\n\n\t\timlist_arr = []\n\t\tj = 0\n\t\tfor im_path in im_paths:\n\t\t\tim = None\n\n\t\t\ttry:\n\t\t\t\tim = Image.open(im_path)\n\t\t\t\t#im = imread(im_path)\n\t\t\t\t#print im.shape\n\t\t\texcept Exception, e:\n\t\t\t\tprint e\n\t\t\t\n\t\t\tif im != None:\n\t\t\t\ttry:\n\t\t\t\t\tim_aux = np.array(im,dtype=theano.config.floatX)\n\t\t\t\t\tim_converted = True\n\t\t\t\texcept TypeError, e:\n\t\t\t\t\tim_converted = False\n\t\t\t\t\tprint e\n\t\t\t\t\n\t\t\t\tif im_converted == True:\n\t\t\t\t\ttry:\n\t\t\t\t\t\tif im_aux.shape[2] == 4:\n\t\t\t\t\t\t\tbackground = Image.new(\"RGB\", im.size, (255, 255, 255))\n\t\t\t\t\t\t\tbackground.paste(im, mask=im.split()[3]) # 3 is the alpha channel\n\t\t\t\t\t\t\tim = background\n\t\t\t\t\t\t\tim_aux = np.array(background,dtype=theano.config.floatX)\n\t\t\t\t\texcept Exception, e:\n\t\t\t\t\t\tprint e\n\t\t\t\t\t\n\t\t\t\t\ttry:\n\n\t\t\t\t\t\tif im_aux.shape[2] == 3:\n\t\t\t\t\t\t\tbn_parsed = os.path.basename(im_path).split(\"_\")\n\t\t\t\t\t\t\tim_id = int(bn_parsed[0])\n\t\t\t\t\t\t\t#print im_id\n\t\t\t\t\t\t\t#Ignore potential duplicates\n\t\t\t\t\t\t\t#if im_id not in self.im_index:\n\t\t\t\t\t\t\tif im_id not in im_index:\n\t\t\t\t\t\t\t\tim_aux = self.scale_and_crop_img(im)\n\t\t\t\t\t\t\t\t# This is for multiprocessing\n\t\t\t\t\t\t\t\tim_index.append(im_id)\n\t\t\t\t\t\t\t\timlist.append(np.asarray(im_aux))\n\n\t\t\t\t\t\t\t\t# Uncomment this if you are not using multiprocessing\n\t\t\t\t\t\t\t\t# self.im_index.append(im_id)\n\t\t\t\t\t\t\t\t# self.imlist.append(np.asarray(im_aux))\n\t\t\t\t\t\t\t\t#self.imlist.append(im_aux)\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tprint \"invalid image: {} size:{}\".format(im.filename, im_aux.shape)\n\t\t\n\t\t\t\t\texcept Exception, e:\n\t\t\t\t\t\t#raise e\n\t\t\t\t\t\tprint e\n\t\n\t\t\t# if self.verbose:\n\t\t\t# \tsys.stdout.write(\"\\r Process: {0}/{1}\".format(j, len(im_paths)))\n\t\t\t# \tsys.stdout.flush()\n\n\t\t\tj += 1","def greyscale_images(self, images):\n \n img_list = []\n \n for img in images:\n \n width, heigh, channels = img.shape\n\n \n img = 0.2125*img[:,:,0] + 0.7154*img[:,:,1] + 0.0721*img[:,:,2]\n \n img = img.reshape(width, heigh, 1)\n \n \n # formula obtained from \n # https://stackoverflow.com/questions/12201577/how-can-i-convert-an-rgb-image-into-grayscale-in-python\n yield img","def create_image(self, shapes):\n img = image.IMG()\n img.draw_shapes(shapes)\n img = np.transpose(img.array(), (2, 0, 1))\n return img","def generate(self):\n z_sample = np.random.normal(0, 1,[self.batch_size, self.n_z])\n gen_images = self.sess.run(self.gen_img, feed_dict={self.z: z_sample})\n return gen_images","def make_imgs_list(self, imgs_dir, imgs_list):\n \n empty_list = []\n \n for img in imgs_list:\n \n img_dir = imgs_dir + '/' + img\n \n empty_list.append(img_dir)\n \n return empty_list","def initImages(self):\n pass","def initImages(self):\n pass","def initImages(self):\n pass","def generate_images(self, count):\n # Generate images from the currently loaded model\n noise = np.random.normal(0, 1, (count, self.dimensions_noise))\n return self.generator.predict(noise)","def list_images(self):\n raise NotImplementedError()","def get_images(self, start_at=None, count=None):\n start_at = 0 if start_at is None else start_at\n end_at = len(self.fps) if count is None else start_at+count\n for fp in self.fps[start_at:end_at]:\n try:\n image = ndimage.imread(fp, mode=\"RGB\")\n except IOError as exc:\n image = None\n yield image","def features_to_np_array(self, images):\n \n images = list(images)\n \n images = np.stack(images, axis=0)\n \n return images","def create_sprite_image(images):\n if isinstance(images, list):\n images = np.array(images)\n images = images.reshape([images.shape[0], images.shape[1], images.shape[2]])\n img_h = images.shape[1]\n img_w = images.shape[2]\n n_plots = int(np.ceil(np.sqrt(images.shape[0])))\n \n plt.figure()\n spriteimage = np.ones((img_h * n_plots ,img_w * n_plots))\n \n for i in range(n_plots):\n for j in range(n_plots):\n this_filter = i * n_plots + j\n if this_filter < images.shape[0]:\n this_img = images[this_filter]\n spriteimage[i * img_h:(i + 1) * img_h,\n j * img_w:(j + 1) * img_w] = this_img\n\n plt.savefig('sprite_image')\n\n spriteimage = spriteimage.reshape([1, spriteimage.shape[0], spriteimage.shape[1], 1])\n\n plt.close()\n \n return spriteimage","def load_source_png_images(self, num_slice):\n if self.subject is None:\n print Console.WARNING + 'You need to specify a subject first' + Console.ENDC\n return\n data = [] \n for l in self.locations.LABELS:\n slice_file = self.locations.SOURCE_PNG % (l, num_slice)\n \n #print 'Loading Input Image \\t\\t%s'%slice_file \n slice_data = misc.imread(slice_file) \n data.append(slice_data)\n \n return data #images in the same order as labels","def create_list(self):\n for _ in range(self.count):\n id_ = random.randint(10000, 99999)\n self.ids.append(id_)\n self.img_paths.append(f\"{self.save_path}{self.name}/images/{id_}.png\")\n if hasattr(self, \"masks\"):\n self.masks.append(f\"{self.save_path}{self.name}/masks/{id_}.png\")"],"string":"[\n \"def makearray(self, *args, **kwargs):\\n return _image.image_makearray(self, *args, **kwargs)\",\n \"def gen_image(self, nimage):\\n tmp = [0] * nimage\\n for i in np.arange(nimage):\\n tmp[i] = self.gen_one_image()\\n \\n return np.array(tmp)\",\n \"def generate_images(\\n n: int = 128, w: int = 32, h: int = 32, c: int = 1, random_seed: int = None\\n) -> TYPE_ARRAY:\\n return _RNG.randint(0, 256, n * c * w * h).reshape(n, c, w, h)\",\n \"def getimgs():\",\n \"def load_images(folder_path, num_images):\\n imgs = np.zeros(shape=[num_images, 400, 400, 3])\\n for i in range(1, num_images + 1):\\n image_name = \\\"satImage_%.3d\\\" % i\\n image_path = folder_path + image_name + \\\".png\\\"\\n if os.path.isfile(image_path):\\n print('Loading ' + image_path)\\n img = mpimg.imread(image_path)\\n\\n #imgs[i - 1] = np.asarray(img).reshape(400, 400, 3)\\n imgs[i - 1] = img.reshape(400, 400, 3)\\n else:\\n print('File ' + image_path + ' does not exist')\\n return imgs\",\n \"def get_images(self):\\n return [self.get_image(i) for i in range(0, self.number_sprites - 1)]\",\n \"def _extract_images(image_paths):\\n\\n num_images = len(image_paths)\\n data = np.zeros((num_images, _IMAGE_SIZE, _IMAGE_SIZE, _NUM_CHANNELS))\\n for i in range(num_images):\\n image_path = image_paths[i]\\n print('Extracting images from: ', image_path)\\n image = imageio.imread(image_path)\\n data[i] = image\\n\\n return data\",\n \"def create_initial_pictures():\\n pictures = []\\n\\n for i in xrange(0, 9):\\n pic = Picture()\\n pic = Picture.create_random(pic, 1)\\n\\n pictures.append(pic)\\n\\n return pictures\",\n \"def construct_image(imgs):\\n\\n # todo fill missing pieces and\\n\\n if len(imgs) == 0:\\n return None\\n # taking the first\\n w, h = imgs[0][1].size\\n img_array = order_2d(imgs)\\n x_count = len(img_array[0])\\n y_count = len(img_array)\\n height = h * y_count\\n width = w * x_count\\n new_im = Image.new('RGB', (width, height))\\n for y in range(y_count):\\n for x in range(x_count):\\n _, im = img_array[y][x]\\n new_im.paste(im, (x * w, y * h))\\n return new_im\",\n \"def load_images(filenames):\\n h,w,c = SIZE\\n images = np.empty((len(filenames),h,w,c))\\n for i,img_path in enumerate(filenames):\\n # Base64\\n with open(img_path,'rb') as image_file:\\n img_base64_encode = base64.b64encode(image_file.read())\\n img_base64 = base64.b64decode(img_base64_encode)\\n images[i] = np.array(Image.open(io.BytesIO(img_base64)))/255.0 # Reducción en distancia\\n return images\",\n \"def get_images(self, file_path: str) -> Iterable[Image]:\\n return []\",\n \"def newimagefromarray(self, *args, **kwargs):\\n return _image.image_newimagefromarray(self, *args, **kwargs)\",\n \"def image_batch():\\n return np.zeros((2, 1, 4, 4))\",\n \"def img_from_array(array):\\n return Image.fromarray(array)\",\n \"def get_img_array(myzipfile, imgid, shape=(299,299)):\\n img_arr = np.zeros(shape=(512, 512, 3), dtype=np.float32)\\n img_green = Image.open(myzipfile.open(f'{imgid}_green.png'))\\n img_blue = Image.open(myzipfile.open(f'{imgid}_blue.png'))\\n img_red = Image.open(myzipfile.open(f'{imgid}_red.png'))\\n img_yellow = Image.open(myzipfile.open(f'{imgid}_yellow.png'))\\n img_arr[:,:,0] = np.divide(np.array(img_green), 255)\\n img_arr[:,:,1] = np.divide(np.array(img_blue), 255)/2 + np.divide(np.array(img_yellow), 255)/2\\n img_arr[:,:,2] = np.divide(np.array(img_red), 255)/2 + np.divide(np.array(img_red), 255)/2\\n img_arr = cv2.resize(img_arr, shape)\\n return img_arr\",\n \"def get_images(path_list):\\n images = []\\n labels = []\\n names = []\\n i = 0\\n for path in path_list:\\n for fruit_dir_path in glob.glob(path):\\n fruit_label = fruit_dir_path.split(\\\"/\\\")[-1]\\n for image_path in glob.glob(os.path.join(fruit_dir_path, \\\"*.jpg\\\")):\\n image = cv2.imread(image_path, cv2.IMREAD_COLOR)\\n\\n image = cv2.resize(image, (45, 45))\\n image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\\n\\n images.append(image)\\n names.append(fruit_label)\\n labels.append(i)\\n i += 1\\n\\n images = np.array(images)\\n print(images.shape)\\n # add a new dimension here\\n with np.nditer(images, op_flags=['readwrite']) as it:\\n for x in it:\\n x = np.expand_dims(x, axis=0)\\n labels = np.array(labels)\\n return images, labels, i\",\n \"def _convert_images(raw):\\n # Convert the raw images from the data-files to floating-points.\\n #raw_float = np.array(raw, dtype=float) / 255.0\\n\\n # Reshape the array to 4-dimensions.\\n images = raw.reshape([-1, num_channels, img_size, img_size])\\n\\n # Reorder the indices of the array.\\n images = images.transpose([0, 2, 3, 1])\\n\\n return images\",\n \"def images(self, first, last, shape, validfirst, validlast):\\n size = shape[0] * shape[1] * (1 + last - first)\\n array = np.ascontiguousarray(np.zeros(size, dtype=np.int32))\\n self.lib.GetImages(ct.c_long(first), ct.c_long(last),\\n array.ctypes.data_as(ct.POINTER(ct.c_int32)),\\n ct.c_ulong(size), ct.pointer(ct.c_long(validfirst)),\\n ct.pointer(ct.c_long(validlast)))\\n\\n return array.reshape(-1, shape[0], shape[1])\",\n \"def create_images(dataFpath, width, height, angles=[]):\\n\\n imgSize = width * height\\n\\n\\n def _resize_n_cast(_img):\\n return resize(_img, (width, height)).ravel().reshape(1, imgSize).astype(theano.config.floatX)\\n\\n\\n origImg = 1 - trim_image(imread(dataFpath, as_grey=True), bgValue=255)\\n\\n straightImg = _resize_n_cast(origImg)\\n rotatedImgs = [_resize_n_cast(rotate(origImg, angle)) for angle in angles]\\n\\n return [straightImg] + rotatedImgs\",\n \"def make_imgs(img: ndarray, imin: Any = None, imax: Any = None) -> [ndarray]:\\n imin = img.min() if imin is None else imin\\n imax = img.max() if imax is None else imax\\n scaled = np.array(((img - imin) / (imax - imin)) * 255, dtype=int) # img\\n if len(img.shape) == 3:\\n return [scaled] * 3\\n raise ValueError(\\\"Only accepts 1-channel or 3-channel images\\\")\",\n \"def prepare_image_list(path, image_name, i_range):\\n DisplayNetwork.display_green(\\\"[INFO] Loading the images to train the network\\\")\\n positives = []\\n file_list = commands.getoutput('ls ./' + path + '/*.jpg | xargs -n 1 basename').split(\\\"\\\\n\\\")\\n\\n for i in i_range:\\n image_name = path + '/' + file_list[i]\\n DisplayNetwork.display_yellow(\\\"[INFO] Loading image\\\" + image_name)\\n\\n image_matrix = ImageFunctions.turnImageToGray(image_name) # Load image as gray\\n reshaped = np.reshape(image_matrix, 361) # makes 19x19 matrix to 1x361 vector\\n positives.append(reshaped.tolist())\\n\\n return np.array(positives)\",\n \"def get_images(self) -> Sequence[Optional[np.ndarray]]:\\n raise NotImplementedError\",\n \"def get_imgs(paths_list: list) -> list:\\n \\n imgs_list = [Image.open(project_path + data_path + paths_list[i]) for i in range(len(paths_list))]\\n \\n return imgs_list\",\n \"def create_sequence_of_images(size, source_image, target_image, \\n source_triangles_list, target_triangles_list, num_frames):\\n # initiate the list of intermediate images\\n images_list = []\\n # run over the num_frames value to create the intermediate images\\n for i in range(0,num_frames):\\n # add to the list the current intermediate image create by\\n # create_intermediate_image with the current alpha value\\n images_list.append(create_intermediate_image(i/(num_frames-1),\\n size,source_image,\\n target_image,\\n source_triangles_list,\\n target_triangles_list))\\n return images_list\",\n \"def make_images(self):\\n self._images = [tree.to_image() for tree in self.reaction_trees]\\n self._update_route_dict(self._images, \\\"image\\\")\",\n \"def read_images(path_list, img_height, img_width):\\n\\n out = []\\n for img_path in path_list:\\n # Below line converts to a PIL Python Image Library format\\n img = image.load_img(img_path, target_size=(img_height, img_width))\\n x = image.img_to_array(img) # Convert a PIL image to a numpy array\\n x = np.expand_dims(x, axis=0) # (1, dim1, dim2, channels) Type: float32\\n out.append(x.astype('uint8'))\\n return np.vstack(out) # Stack the images one below the other (rows)\",\n \"def __readImages(self, filename):\\n print 'Reading images from %s ...' % filename\\n images = []\\n with open(filename, 'rb') as infile:\\n infile.read(4) # ignore magic number\\n count = struct.unpack('>i', infile.read(4))[0]\\n rows = struct.unpack('>i', infile.read(4))[0]\\n columns = struct.unpack('>i', infile.read(4))[0]\\n\\n for i in xrange(count):\\n data = infile.read(rows*columns)\\n image = np.fromstring(data, dtype=np.uint8)\\n image = image.reshape((rows, columns))\\n image = 255 - image # now black digit on white background\\n images.append(image)\\n return images\",\n \"def loadImages(loadPath):\\n img_array = []\\n for filename in glob.glob(loadPath):\\n img = cv2.imread(filename)\\n height, width, layers = img.shape\\n size = (width, height)\\n img_array.append(img)\\n\\n return img_array\",\n \"def buildImages(files, targets, type):\\n images = []\\n for file in files:\\n targets.append(file)\\n with open(file, \\\"rb\\\") as f:\\n if type == \\\"Byte\\\":\\n images.append(bytePlot(list(f.read())))\\n elif type == \\\"Markov\\\":\\n images.append(markovPlot(list(f.read())))\\n elif type == \\\"Hilbert\\\":\\n images.append(hilbertPlot(list(f.read())))\\n smp.imsave(\\\"{}.png\\\".format(file), images[-1])\\n return images, targets\",\n \"def read_images(image_dir, names, image_size=None):\\n num_images = len(names)\\n image = skimage.io.imread(os.path.join(image_dir, names[0] + '.jpg'))\\n dtype = image.dtype;\\n if image_size is None:\\n image_size = image.shape[0:2]\\n\\n images = numpy.empty((num_images, image_size[0], image_size[1], 3), dtype=dtype)\\n with tqdm.tqdm(total=num_images) as progress:\\n for index, name in enumerate(names):\\n image = skimage.io.imread(os.path.join(image_dir, name + '.jpg'))\\n if image_size is None:\\n images[index, :, :, :] = image\\n else:\\n images[index, :, :, :] = resize_image(image, image_size)\\n progress.update(1)\\n\\n return images\",\n \"def make_image_list(self):\\n image_list = [self.spritesheet_dict['closed'],\\n self.spritesheet_dict['opened']]\\n\\n return image_list\",\n \"def to_numpy(id:int, samples:list=None):\\n\\t\\t\\tsamples = listify(samples)\\n\\t\\t\\timages = Dataset.Image.to_pillow(id, samples=samples)\\n\\t\\t\\timages = [np.array(img) for img in images]\\n\\t\\t\\timages = np.array(images)\\n\\t\\t\\treturn images\",\n \"def generate_array_image(R, G, B, height, width):\\n R = R.reshape((height, width))\\n G = G.reshape((height, width))\\n B = B.reshape((height, width))\\n \\n return np.moveaxis(np.array([R, G, B]), 0, -1)\",\n \"def build_mono_image_dataset(self):\\n images = [np.expand_dims(company.get_mono_image(),axis = 0) for company in self]\\n images = np.vstack(images)\\n return images\",\n \"def images(self):\\n if self._images is None:\\n self.make_images()\\n return self._images\",\n \"def _iter_images(self):\\n for image in self._images:\\n yield np.array(image.convert('RGB'))\",\n \"def _load_images(paths):\\n assert isinstance(paths, list)\\n _R_MEAN = 123.68\\n _G_MEAN = 116.78\\n _B_MEAN = 103.94\\n\\n # allocate memory\\n images = np.zeros([len(paths), FLAGS.target_height, FLAGS.target_width, 3],\\n dtype=np.float32)\\n\\n # load all images\\n pbar = ProgressBar(max_value=len(paths))\\n for i in range(len(paths)):\\n img = sio.imread(paths[i])\\n\\n # resize images\\n img = sresize(img, (FLAGS.target_height, FLAGS.target_width, 3),\\n mode='constant', preserve_range=True)\\n\\n # store images\\n images[i] = img.astype(np.float32)\\n pbar.update(i)\\n\\n # mean removal\\n images -= [_R_MEAN, _G_MEAN, _B_MEAN]\\n return images\",\n \"def tile_images(image_stack):\\n assert len(image_stack.shape) == 4\\n image_list = [image_stack[i, :, :, :] for i in range(image_stack.shape[0])]\\n tiled_images = np.concatenate(image_list, axis=1)\\n return tiled_images\",\n \"def array_from_img(image):\\n return np.array(image)\",\n \"def returnImages(input_data):\\r\\n if type(input_data) is list:\\r\\n return [returnImages(element) for element in input_data]\\r\\n else:\\r\\n return cv.imread(input_data, 0)\",\n \"def concat_images(X):\\n nc,h,w,_ = X.shape\\n X = X.reshape(nc,h,w)\\n n = np.ceil(np.sqrt(nc)).astype(\\\"int8\\\")\\n img = np.zeros((n*w,n*h))\\n x = 0\\n y = 0\\n for example in range(nc):\\n img[x*w:(x+1)*w,y*h:(y+1)*h] = X[example]\\n y += 1\\n if y >= n:\\n y = 0\\n x += 1\\n return img\",\n \"def load_images(self, image_path):\\n X_train = []\\n\\n # Load all files from the image path using Image.open.\\n for i in recursive_list(image_path):\\n # Open images as ???\\n img = Image.open(i)\\n # Convert to NP array.\\n img = np.asarray(img)\\n # Append them into higher order array.\\n if img.shape == (128, 128, 3):\\n X_train.append(img)\\n\\n # return all the images concatenated as a 4D array\\n return np.asarray(X_train)\",\n \"def makeImageFromArray(array):\\n if array is None: return None\\n cls = globals()[\\\"Image%s\\\" % suffixes[str(array.dtype.type)]]\\n return cls(array)\",\n \"def osszefuzes(img_loc):\\n files = sorted(glob(img_loc))\\n imgs = np.array([imageio.imread(f) for f in files])\\n\\n return imgs\",\n \"def numpy_to_pil(images):\\n if images.ndim == 3:\\n images = images[None, ...]\\n images = (images * 255).round().astype(\\\"uint8\\\")\\n if images.shape[-1] == 1:\\n # special case for grayscale (single channel) images\\n pil_images = [Image.fromarray(image.squeeze(), mode=\\\"L\\\") for image in images]\\n else:\\n pil_images = [Image.fromarray(image) for image in images]\\n\\n return pil_images\",\n \"def resize_images(self, images):\\n \\n img_list = []\\n \\n for img in images:\\n \\n yield np.resize(img, (64, 64, 3))\",\n \"def load_images(self, image_paths):\\n \\n fill_list = []\\n \\n for idx in tqdm(range(len(image_paths))):\\n path = image_paths[idx]\\n yield cv2.imread(path)\",\n \"def __call__(self, in_images):\\n ret_images = []\\n for image in in_images:\\n if self.curr_elements < self.max_elements:\\n self.images.append(image)\\n ret_images.append(image)\\n self.curr_elements+=1\\n else:\\n if np.random.uniform() > 0.5:\\n idx = np.random.randint(0, self.curr_elements)\\n temp = copy.deepcopy(self.images[idx])\\n self.images[idx] = image\\n ret_images.append(temp)\\n else:\\n ret_images.append(image)\\n return ret_images\",\n \"def build_filler_images(self):\",\n \"def convert_images_to_arrays_train(file_path, df):\\n\\n lst_imgs = [l for l in df['image']]\\n array = []\\n for img_name in lst_imgs:\\n img = Image.open(file_path + img_name)\\n array.append(np.array(img))\\n img.close()\\n\\n return np.array(array)\",\n \"def get_images(self):\\n \\n images = []\\n for order in self.order_lst:\\n o_items = order.get_items()\\n images.append(o_items.get_image())\\n \\n return images\",\n \"def get_images(self):\\n \\n return self.img_lst\",\n \"def create_images_as_numpy(idx, out_dir, model_outs, K):\\n masks = model_outs['pis'].exp()\\n sub_images = model_outs['x_loc']\\n\\n images = []\\n all_masks = []\\n all_subis = []\\n for i in range(K):\\n images += [masks[i,0] * sub_images[i,0]]\\n all_masks += [masks[i,0]]\\n all_subis += [sub_images[i,0]]\\n\\n images = torch.stack(images)\\n all_masks = torch.stack(all_masks)\\n all_subis = torch.stack(all_subis)\\n whole_image = images.sum(0)\\n\\n all_masks_grid = torchvision.utils.make_grid(all_masks, nrow=K)\\n all_subis_grid = torchvision.utils.make_grid(all_subis, nrow=K)\\n all_images_grid = torchvision.utils.make_grid(images, nrow=K)\\n \\n filepath = out_dir / f'whole_image_{idx}'\\n np.save(filepath, whole_image.data.cpu().numpy())\\n filepath = out_dir / f'all_images_{idx}'\\n np.save(filepath, all_images_grid.data.cpu().numpy())\\n filepath = out_dir / f'masks_{idx}'\\n np.save(filepath, all_masks_grid.data.cpu().numpy())\\n filepath = out_dir / f'sub_images_{idx}'\\n np.save(filepath, all_subis_grid.data.cpu().numpy())\",\n \"def process_image(self, image_path):\\n\\n img = load_img(image_path, target_size=IMAGE_SIZE)\\n img_array = img_to_array(img)\\n # Create a batch by increase dimensions\\n img_array = expand_dims(img_array, 0)\\n print(img_array.shape)\\n return img_array\",\n \"def generate_imgs(self, count, threshold, modifier):\\n self.build_gan()\\n\\n\\n imgs = []\\n for i in range(count):\\n score = [0]\\n while not(threshold[0] < score[0] < threshold[1]):\\n img = self.gene_imgs(1)\\n score = self.discriminator.predict(img)\\n print(\\\"Image found: \\\", score[0])\\n imgs.append(img)\\n\\n imgs = np.asarray(imgs).squeeze()\\n imgs = 0.5 * imgs + 0.5\\n\\n print(imgs.shape)\\n for i, img_array in enumerate(imgs):\\n path = f\\\"{self.output_directory}/generated_{threshold[0]}_{threshold[1]}\\\"\\n if not os.path.exists(path):\\n os.makedirs(path)\\n imsave(path + f\\\"/{modifier}_{i}.png\\\", self.pix_array_convert(img_array))\",\n \"def tile_images(img, img_size=32, rows=4, cols=4, spacing=1):\\n images = np.ones([3, rows * (img_size + spacing) - spacing, cols * (img_size + spacing)], dtype=np.float32)\\n coords = [(i, j) for i in range(rows) for j in range(cols)]\\n\\n for (i, j), image in zip(coords, img):\\n x = i * (img_size + spacing)\\n y = j * (img_size + spacing)\\n images[:, x: x+img_size, y:y+img_size] = image\\n\\n return images\",\n \"def readImages(imgFolder='img/'):\\n #Each image in images is a numpy array of shape 192x168(x1) (heightxwidth)\\n #images datatype is a regular numpy list\\n filenames = os.listdir(imgFolder)\\n if imgFolder == 'img/':\\n images = [imageio.imread('img/'+fn+'/image0.jpg')[::,::].astype(np.float32)/255. for fn in filenames]#glob.glob(imgFolder+'*.jpg')]\\n else:\\n images = [imageio.imread(imgFolder+fn)[::,::].astype(np.float32)/255. for fn in filenames]\\n return images\",\n \"def load_images(filelist):\\n # pixel value range 0-255\\n if not isinstance(filelist, list):\\n im = Image.open(filelist).convert('L')\\n return np.array(im).reshape(1, im.size[1], im.size[0], 1)\\n data = []\\n for file in filelist:\\n im = Image.open(file).convert('L')\\n data.append(np.array(im).reshape(1, im.size[1], im.size[0], 1))\\n return data\",\n \"def create_images(images_steps, horizon):\\n images = []\\n\\n def _create_images(*image_names):\\n _images = []\\n\\n for image_name in image_names:\\n images_steps.create_image(image_name, check=False)\\n images_steps.close_notification('success')\\n\\n image = utils.AttrDict(name=image_name)\\n images.append(image)\\n _images.append(image)\\n\\n for image_name in image_names:\\n horizon.page_images.table_images.row(\\n name=image_name).wait_for_status('Active')\\n\\n return _images\\n\\n yield _create_images\\n\\n if images:\\n images_steps.delete_images([image.name for image in images])\",\n \"def _images(path):\\r\\n with gzip.open(path) as f:\\r\\n # First 16 bytes are magic_number, n_imgs, n_rows, n_cols\\r\\n pixels = np.frombuffer(f.read(), 'B', offset=16)\\r\\n return pixels.reshape(-1, 784).astype('float32') / 255\",\n \"def listImages(name_list, path, as_grey=True):\\n\\timage_list = []\\n\\n\\tfor name in name_list:\\n\\t\\timage = io.imread(path + \\\"/\\\" + name + \\\".jpg\\\", as_grey=as_grey)\\n\\t\\tif as_grey is True:\\n\\t\\t\\timage = resize(image, (200, 200))\\n\\t\\timage_list.append(image)\\n\\n\\treturn image_list\",\n \"def _create_zl_imgs_given_ids(self, ids: list, subset: str, ann_type: str) -> ZLIMGS:\\n assert subset in [\\\"none\\\", \\\"small\\\", \\\"train\\\", \\\"dev\\\", \\\"test\\\"]\\n assert ann_type in [\\\"none\\\", \\\"label\\\", \\\"bbox\\\", \\\"mask\\\"]\\n\\n if subset == 'none':\\n ids = []\\n elif subset == 'small':\\n ### WARNING: the alteration of random seed will effect the sample of \\\"small\\\" subset\\n ids = self.rnd.sample(ids, len(ids) // 10)\\n else:\\n pass\\n\\n zl_imgs = []\\n for id in ids:\\n zl_img = ZLImage(img_id=id, ann_type=ann_type, dataset_dir=self.dataset_dir)\\n zl_imgs.append(zl_img)\\n\\n return zl_imgs\",\n \"def image(images):\\n return images[0]\",\n \"def get_images(fish):\\n fish_dir = TRAIN_DIR+'{}'.format(fish)\\n images = [fish+'/'+im for im in os.listdir(fish_dir)]\\n return images\",\n \"def _arr_to_img(arr, verbose=False):\\n return Image.fromarray(arr)\",\n \"def read_vanhateren_images (n_imgs=5):\\n folder_name = r'D:\\\\VanHateren\\\\vanhateren_imc' # change this to point to the directory which holds the van hateren data\\n # files = listdir(folder_name)\\n onlyfiles = [ f for f in listdir(folder_name) if isfile(join(folder_name,f)) ]\\n imgs = []\\n for i in range(n_imgs):\\n filename = join(folder_name, onlyfiles[i])\\n with open(filename, 'rb') as handle:\\n s = handle.read()\\n arr = array.array('H', s)\\n arr.byteswap()\\n img_i = np.array(arr, dtype='uint16').reshape(1024, 1536)\\n imgs.append(img_i) \\n return imgs\\n #pylab.imshow(img)\\n #pylab.show()\",\n \"def fromarray(self, *args, **kwargs):\\n return _image.image_fromarray(self, *args, **kwargs)\",\n \"def _listOfImagesToNumpy(self, images):\\n # build image data array, y_labels\\n for i in range(0, len(images)):\\n if self.image_size is not None:\\n img = images[i].resize(self.image_size)\\n else:\\n img = images[i]\\n img_arr = img_to_array(img)\\n if i == 0:\\n dims = [len(images)] + list(img_arr.shape)\\n X_data = np.zeros(shape=dims)\\n X_data[i, :, :, :] = img_arr\\n\\n return X_data\",\n \"def splitImages(self):\\n imgs = self.img_list\\n frames = self.frame_number.value()\\n grps = []\\n for i in range(0, len(imgs), frames):\\n grps.append(imgs[i:i + frames])\\n\\n return grps\",\n \"def getImages(self,Project=\\\"\\\"):\\n #images = [\\\"image1.jpg\\\",\\\"image2.jpg\\\",\\\"image3.jpg\\\"]\\n \\n os.chdir(self.dataDir)\\n images = glob.glob(\\\"*.png\\\")\\n \\n return images\",\n \"def generate_image(self):\\n\\t\\tcenters = self.generate_centers()\\n\\t\\timg = Image.new('RGB', (self.config.image_size, self.config.image_size), color=(0,0,0))\\n\\t\\tshapes = np.random.randint(2, size=len(centers))\\n\\t\\tdrawer = ImageDraw.Draw(img)\\n\\t\\tr = int(0.05 * self.config.image_size)\\n\\t\\tR = []\\n\\t\\tfor i in range(len(centers)):\\n\\t\\t\\tcoor = (centers[i][0] - r , centers[i][1] - r, centers[i][0] + r, centers[i][1] + r)\\n\\t\\t\\tif shapes[i] < 0.5:\\n\\t\\t\\t\\tdrawer.rectangle(coor, fill=COLOR[i])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdrawer.ellipse(coor, fill=COLOR[i])\\n\\t\\t\\tR.append([centers[i], i, shapes[i]])\\n\\t\\treturn np.array(img), R\",\n \"def create_preset_images(self):\\n for f in sorted(self.get_files_from_data()):\\n photoInstances = {}\\n for preset in self.generator.settings[\\\"GALLERY_PRESETS\\\"]:\\n preset_dir = \\\"%s%s%s\\\" % (self.absolute_output_path,\\n os.sep, \\n preset[\\\"name\\\"])\\n photoInstances[preset[\\\"name\\\"]] = Photo(self, f, preset_dir, preset)\\n \\n self.photos.append(photoInstances)\",\n \"def make_image(file):\\n image = cv2.imread(file, 0)\\n image = cv2.resize(image, (IMG_SIZE, IMG_SIZE))\\n return np.array([np.array(image), np.array([0, 0])])\",\n \"def load_images(tags_pict):\\n img_data_list = []\\n for p in tags_pict.index :\\n img_path = tags_pict.full_path[p]\\n img = load_img(img_path, target_size= inputShape)\\n x = img_to_array(img)\\n x = np.expand_dims(img, axis=0)\\n # pre-process the image using the appropriate function based on the\\n # model that has been loaded (i.e., mean subtraction, scaling, etc.)\\n x = preprocess_input(x)\\n img_data_list.append(x)\\n img_data = np.array(img_data_list)\\n img_data=np.rollaxis(img_data,1,0)\\n img_data=img_data[0]\\n return(img_data)\",\n \"def get_images_online(self, img_names):\\n images = []\\n errs = []\\n for img_name in img_names:\\n try:\\n path = IMAGES_FOLDER + img_name\\n # print(path)\\n img = get_image(path, self.img_shape)\\n x = image.img_to_array(img)\\n x = np.expand_dims(x, axis=0)\\n images.append(x)\\n except Exception as e:\\n # print(path,str(e))\\n errs.append(img_name)\\n\\n return np.vstack(images), errs\",\n \"def images(self, **kwargs):\\n\\n raise NotImplementedError\",\n \"def load_images(self):\\n images_list = [os.path.join(self.root, image['file_name'])\\n for image in self.data['images']]\\n\\n if self.shuffle:\\n random.shuffle(images_list)\\n images_list = images_list[:self.max_samples] if self.max_samples is not None and self.max_samples <= len(\\n images_list) else images_list\\n\\n return images_list\",\n \"def create_image(images_steps):\\n images = []\\n\\n def _create_image(image_name, *args, **kwgs):\\n images_steps.create_image(image_name, *args, **kwgs)\\n image = utils.AttrDict(name=image_name)\\n images.append(image)\\n return image\\n\\n yield _create_image\\n\\n for image in images:\\n images_steps.delete_image(image.name)\",\n \"def array2img(array):\\n if len(array.shape) == 2:\\n return Image.fromarray(np.clip(array, 0, 255).astype('uint8'), mode='L')\\n elif len(array.shape) == 3:\\n return Image.fromarray(np.clip(array, 0, 255).astype('uint8'), mode='RGB')\\n else:\\n print('Income array is not at appropriate shape!')\",\n \"def create_new_images(x):\\n \\n datagen = ImageDataGenerator(width_shift_range=0.1,\\n height_shift_range=0.1,\\n shear_range=0.1,\\n zoom_range=0.1,\\n horizontal_flip=True,\\n fill_mode='constant',\\n cval=0) \\n \\n i = 0\\n for batch in datagen.flow(x, batch_size=1,\\n save_to_dir='data/Histology/new_benign',\\n save_prefix='benign',\\n save_format='jpeg'):\\n i += 1 \\n if i > 3:\\n break\\n \\n return 0\",\n \"def load_images(pool, entries):\\n start = time.perf_counter()\\n images = pool.map(ski.io.imread, [x.path for x in entries])\\n logger.info(\\\"Loaded %i images:\\\", len(images))\\n util.pprint_log([x.name for x in entries], logger.info)\\n logger.info(util.elapsed(start))\\n logger.info(\\\"\\\\n\\\")\\n return images\",\n \"def np_make_image_grid(images, nrow, pad=2):\\n height, width = images[0].shape[:2]\\n ncol = int(np.ceil(len(images) / nrow))\\n ncolors = images[0].shape[-1]\\n result_imshape = [nrow * (height + pad), ncol * (width + pad), ncolors]\\n if len(images[0].shape) == 2: # grayscale image\\n ncolors = 1\\n result_imshape[-1] = 1\\n im_result = np.zeros(result_imshape, dtype=images[0].dtype)\\n im_idx = 0\\n for row in range(nrow):\\n for col in range(ncol):\\n if im_idx == len(images):\\n break\\n im = images[im_idx]\\n im = normalize(im)\\n im_idx += 1\\n im_result[row * (pad + height): (row) * (pad + height) + height,\\n col * (pad + width): (col) * (pad + width) + width, :] = im.reshape(height, width, -1)\\n if ncolors == 1:\\n im_result = im_result[:, :, 0]\\n return im_result\",\n \"def process_batch(self, image_batch):\\n images = []\\n for image_data in image_batch:\\n image_resize = cv2.resize(image_data, (0,0), fx=0.5, fy=0.5) #NOTE\\n images.append(image_resize)\\n\\n return np.array(images)\",\n \"def generate_images(self, image_idx, is_training, batch_size=16):\\n \\n # arrays to store our batched data\\n images, ages, races, genders = [], [], [], []\\n while True:\\n for idx in image_idx:\\n person = self.df.iloc[idx]\\n \\n age = person['age']\\n race = person['race_id']\\n gender = person['gender_id']\\n file = person['file']\\n \\n im = self.preprocess_image(file)\\n \\n ages.append(age / self.max_age)\\n races.append(to_categorical(race, len(dataset_dict['race_id'])))\\n genders.append(to_categorical(gender, len(dataset_dict['gender_id'])))\\n images.append(im)\\n \\n # yielding condition\\n if len(images) >= batch_size:\\n yield np.array(images), [np.array(ages), np.array(races), np.array(genders)]\\n images, ages, races, genders = [], [], [], []\\n \\n if not is_training:\\n break\",\n \"def imageToArray(i):\\r\\n a=gdalnumeric.numpy.fromstring(i.tostring(),'b')\\r\\n a.shape=i.im.size[1], i.im.size[0]\\r\\n return a\",\n \"def load_images(self,im_paths,imlist,im_index):\\n\\n\\t\\timlist_arr = []\\n\\t\\tj = 0\\n\\t\\tfor im_path in im_paths:\\n\\t\\t\\tim = None\\n\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tim = Image.open(im_path)\\n\\t\\t\\t\\t#im = imread(im_path)\\n\\t\\t\\t\\t#print im.shape\\n\\t\\t\\texcept Exception, e:\\n\\t\\t\\t\\tprint e\\n\\t\\t\\t\\n\\t\\t\\tif im != None:\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tim_aux = np.array(im,dtype=theano.config.floatX)\\n\\t\\t\\t\\t\\tim_converted = True\\n\\t\\t\\t\\texcept TypeError, e:\\n\\t\\t\\t\\t\\tim_converted = False\\n\\t\\t\\t\\t\\tprint e\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif im_converted == True:\\n\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\tif im_aux.shape[2] == 4:\\n\\t\\t\\t\\t\\t\\t\\tbackground = Image.new(\\\"RGB\\\", im.size, (255, 255, 255))\\n\\t\\t\\t\\t\\t\\t\\tbackground.paste(im, mask=im.split()[3]) # 3 is the alpha channel\\n\\t\\t\\t\\t\\t\\t\\tim = background\\n\\t\\t\\t\\t\\t\\t\\tim_aux = np.array(background,dtype=theano.config.floatX)\\n\\t\\t\\t\\t\\texcept Exception, e:\\n\\t\\t\\t\\t\\t\\tprint e\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\ttry:\\n\\n\\t\\t\\t\\t\\t\\tif im_aux.shape[2] == 3:\\n\\t\\t\\t\\t\\t\\t\\tbn_parsed = os.path.basename(im_path).split(\\\"_\\\")\\n\\t\\t\\t\\t\\t\\t\\tim_id = int(bn_parsed[0])\\n\\t\\t\\t\\t\\t\\t\\t#print im_id\\n\\t\\t\\t\\t\\t\\t\\t#Ignore potential duplicates\\n\\t\\t\\t\\t\\t\\t\\t#if im_id not in self.im_index:\\n\\t\\t\\t\\t\\t\\t\\tif im_id not in im_index:\\n\\t\\t\\t\\t\\t\\t\\t\\tim_aux = self.scale_and_crop_img(im)\\n\\t\\t\\t\\t\\t\\t\\t\\t# This is for multiprocessing\\n\\t\\t\\t\\t\\t\\t\\t\\tim_index.append(im_id)\\n\\t\\t\\t\\t\\t\\t\\t\\timlist.append(np.asarray(im_aux))\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# Uncomment this if you are not using multiprocessing\\n\\t\\t\\t\\t\\t\\t\\t\\t# self.im_index.append(im_id)\\n\\t\\t\\t\\t\\t\\t\\t\\t# self.imlist.append(np.asarray(im_aux))\\n\\t\\t\\t\\t\\t\\t\\t\\t#self.imlist.append(im_aux)\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tprint \\\"invalid image: {} size:{}\\\".format(im.filename, im_aux.shape)\\n\\t\\t\\n\\t\\t\\t\\t\\texcept Exception, e:\\n\\t\\t\\t\\t\\t\\t#raise e\\n\\t\\t\\t\\t\\t\\tprint e\\n\\t\\n\\t\\t\\t# if self.verbose:\\n\\t\\t\\t# \\tsys.stdout.write(\\\"\\\\r Process: {0}/{1}\\\".format(j, len(im_paths)))\\n\\t\\t\\t# \\tsys.stdout.flush()\\n\\n\\t\\t\\tj += 1\",\n \"def greyscale_images(self, images):\\n \\n img_list = []\\n \\n for img in images:\\n \\n width, heigh, channels = img.shape\\n\\n \\n img = 0.2125*img[:,:,0] + 0.7154*img[:,:,1] + 0.0721*img[:,:,2]\\n \\n img = img.reshape(width, heigh, 1)\\n \\n \\n # formula obtained from \\n # https://stackoverflow.com/questions/12201577/how-can-i-convert-an-rgb-image-into-grayscale-in-python\\n yield img\",\n \"def create_image(self, shapes):\\n img = image.IMG()\\n img.draw_shapes(shapes)\\n img = np.transpose(img.array(), (2, 0, 1))\\n return img\",\n \"def generate(self):\\n z_sample = np.random.normal(0, 1,[self.batch_size, self.n_z])\\n gen_images = self.sess.run(self.gen_img, feed_dict={self.z: z_sample})\\n return gen_images\",\n \"def make_imgs_list(self, imgs_dir, imgs_list):\\n \\n empty_list = []\\n \\n for img in imgs_list:\\n \\n img_dir = imgs_dir + '/' + img\\n \\n empty_list.append(img_dir)\\n \\n return empty_list\",\n \"def initImages(self):\\n pass\",\n \"def initImages(self):\\n pass\",\n \"def initImages(self):\\n pass\",\n \"def generate_images(self, count):\\n # Generate images from the currently loaded model\\n noise = np.random.normal(0, 1, (count, self.dimensions_noise))\\n return self.generator.predict(noise)\",\n \"def list_images(self):\\n raise NotImplementedError()\",\n \"def get_images(self, start_at=None, count=None):\\n start_at = 0 if start_at is None else start_at\\n end_at = len(self.fps) if count is None else start_at+count\\n for fp in self.fps[start_at:end_at]:\\n try:\\n image = ndimage.imread(fp, mode=\\\"RGB\\\")\\n except IOError as exc:\\n image = None\\n yield image\",\n \"def features_to_np_array(self, images):\\n \\n images = list(images)\\n \\n images = np.stack(images, axis=0)\\n \\n return images\",\n \"def create_sprite_image(images):\\n if isinstance(images, list):\\n images = np.array(images)\\n images = images.reshape([images.shape[0], images.shape[1], images.shape[2]])\\n img_h = images.shape[1]\\n img_w = images.shape[2]\\n n_plots = int(np.ceil(np.sqrt(images.shape[0])))\\n \\n plt.figure()\\n spriteimage = np.ones((img_h * n_plots ,img_w * n_plots))\\n \\n for i in range(n_plots):\\n for j in range(n_plots):\\n this_filter = i * n_plots + j\\n if this_filter < images.shape[0]:\\n this_img = images[this_filter]\\n spriteimage[i * img_h:(i + 1) * img_h,\\n j * img_w:(j + 1) * img_w] = this_img\\n\\n plt.savefig('sprite_image')\\n\\n spriteimage = spriteimage.reshape([1, spriteimage.shape[0], spriteimage.shape[1], 1])\\n\\n plt.close()\\n \\n return spriteimage\",\n \"def load_source_png_images(self, num_slice):\\n if self.subject is None:\\n print Console.WARNING + 'You need to specify a subject first' + Console.ENDC\\n return\\n data = [] \\n for l in self.locations.LABELS:\\n slice_file = self.locations.SOURCE_PNG % (l, num_slice)\\n \\n #print 'Loading Input Image \\\\t\\\\t%s'%slice_file \\n slice_data = misc.imread(slice_file) \\n data.append(slice_data)\\n \\n return data #images in the same order as labels\",\n \"def create_list(self):\\n for _ in range(self.count):\\n id_ = random.randint(10000, 99999)\\n self.ids.append(id_)\\n self.img_paths.append(f\\\"{self.save_path}{self.name}/images/{id_}.png\\\")\\n if hasattr(self, \\\"masks\\\"):\\n self.masks.append(f\\\"{self.save_path}{self.name}/masks/{id_}.png\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.727521","0.7118611","0.7073577","0.70057833","0.69419736","0.689666","0.68892497","0.68005633","0.6778553","0.67391485","0.67278343","0.67162925","0.6715371","0.66987485","0.6670579","0.6658773","0.6611052","0.6609227","0.65959245","0.6590915","0.65489405","0.6537354","0.65196246","0.64843327","0.6482033","0.6478459","0.6475101","0.64678365","0.6460564","0.6441173","0.6431398","0.64285624","0.6415656","0.64121884","0.63975036","0.6389326","0.63797843","0.6378052","0.63684624","0.6368157","0.63653994","0.63643205","0.6363343","0.6356421","0.63536656","0.6346507","0.632865","0.6322629","0.63224655","0.6317702","0.63009703","0.6297121","0.62958765","0.62877053","0.6277332","0.62737423","0.6266119","0.6223255","0.6221477","0.62183946","0.62129176","0.6207688","0.6202416","0.6192582","0.6191297","0.6188718","0.61816806","0.6180443","0.6171315","0.61646134","0.6159012","0.61502284","0.6141455","0.6138206","0.6133962","0.61309475","0.6126167","0.6119104","0.6116934","0.6109058","0.6103837","0.6097874","0.6096542","0.60887927","0.6085514","0.6082947","0.60808897","0.60797584","0.60766923","0.60572064","0.6053348","0.6053348","0.6053348","0.6051813","0.60497725","0.6047084","0.60420156","0.6041317","0.60385346","0.60385025"],"string":"[\n \"0.727521\",\n \"0.7118611\",\n \"0.7073577\",\n \"0.70057833\",\n \"0.69419736\",\n \"0.689666\",\n \"0.68892497\",\n \"0.68005633\",\n \"0.6778553\",\n \"0.67391485\",\n \"0.67278343\",\n \"0.67162925\",\n \"0.6715371\",\n \"0.66987485\",\n \"0.6670579\",\n \"0.6658773\",\n \"0.6611052\",\n \"0.6609227\",\n \"0.65959245\",\n \"0.6590915\",\n \"0.65489405\",\n \"0.6537354\",\n \"0.65196246\",\n \"0.64843327\",\n \"0.6482033\",\n \"0.6478459\",\n \"0.6475101\",\n \"0.64678365\",\n \"0.6460564\",\n \"0.6441173\",\n \"0.6431398\",\n \"0.64285624\",\n \"0.6415656\",\n \"0.64121884\",\n \"0.63975036\",\n \"0.6389326\",\n \"0.63797843\",\n \"0.6378052\",\n \"0.63684624\",\n \"0.6368157\",\n \"0.63653994\",\n \"0.63643205\",\n \"0.6363343\",\n \"0.6356421\",\n \"0.63536656\",\n \"0.6346507\",\n \"0.632865\",\n \"0.6322629\",\n \"0.63224655\",\n \"0.6317702\",\n \"0.63009703\",\n \"0.6297121\",\n \"0.62958765\",\n \"0.62877053\",\n \"0.6277332\",\n \"0.62737423\",\n \"0.6266119\",\n \"0.6223255\",\n \"0.6221477\",\n \"0.62183946\",\n \"0.62129176\",\n \"0.6207688\",\n \"0.6202416\",\n \"0.6192582\",\n \"0.6191297\",\n \"0.6188718\",\n \"0.61816806\",\n \"0.6180443\",\n \"0.6171315\",\n \"0.61646134\",\n \"0.6159012\",\n \"0.61502284\",\n \"0.6141455\",\n \"0.6138206\",\n \"0.6133962\",\n \"0.61309475\",\n \"0.6126167\",\n \"0.6119104\",\n \"0.6116934\",\n \"0.6109058\",\n \"0.6103837\",\n \"0.6097874\",\n \"0.6096542\",\n \"0.60887927\",\n \"0.6085514\",\n \"0.6082947\",\n \"0.60808897\",\n \"0.60797584\",\n \"0.60766923\",\n \"0.60572064\",\n \"0.6053348\",\n \"0.6053348\",\n \"0.6053348\",\n \"0.6051813\",\n \"0.60497725\",\n \"0.6047084\",\n \"0.60420156\",\n \"0.6041317\",\n \"0.60385346\",\n \"0.60385025\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7637464"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83198,"cells":{"query":{"kind":"string","value":"Creates an array of labels"},"document":{"kind":"string","value":"def create_label_array(files_list):\n lab_array = np.array([np.array(turn_age_into_vector(find_age(file))) for file in files_list])\n return lab_array"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def labels_array(self):\n return _build_label_vector_rows(\n [[(label, 1)] for label in self.labels], self.training_labels)[1:].T","def generate_labels(n_samples):\n return np.ones([n_samples, 1]), np.zeros([n_samples, 1])","def create_label_array(el):\n num_digits = len(el) # first element of array holds the count\n labels_array = np.ones([MAX_LABELS+1], dtype=int) * 10\n labels_array[0] = num_digits\n for n in range(num_digits):\n if el[n] == 10: el[n] = 0 # reassign 0 as 10 for one-hot encoding\n labels_array[n+1] = el[n]\n return labels_array","def create_label_array(el):\n num_digits = len(el) # first element of array holds the count\n labels_array = np.ones([MAX_LABELS+1], dtype=int) * 10\n labels_array[0] = num_digits\n for n in range(num_digits):\n if el[n] == 10: el[n] = 0 # reassign 0 as 10 for one-hot encoding\n labels_array[n+1] = el[n]\n return labels_array","def get_labels(self):\n return []","def generate_labels():\n label_set = set([])\n for data in load_data():\n label = data.split(' ', 1)[0]\n label_set.add(label)\n labels = list(label_set)\n labels.sort()\n return labels","def labels(self) -> ndarray:\n return self._labels","def labels_(self) -> DNDarray:\n return self._labels","def generate_labels(pics):\r\n return []","def array2(self):\r\n profbox(whoami())\r\n # research\r\n inputLabelID = self.__needleLabelSelector.currentNode().GetID()\r\n labelnode = slicer.mrmlScene.GetNodeByID(inputLabelID)\r\n i = labelnode.GetImageData()\r\n shape = list(i.GetDimensions())\r\n shape.reverse()\r\n a = vtk.util.numpy_support.vtk_to_numpy(i.GetPointData().GetScalars()).reshape(shape)\r\n labels = []\r\n val = [[0, 0, 0] for i in range(a.max() + 1)]\r\n for i in xrange(2, a.max() + 1):\r\n w = numpy.transpose(numpy.where(a == i))\r\n # labels.append(w.mean(axis=0))\r\n val[i] = [0, 0, 0]\r\n val[i][0] = w[int(round(w.shape[0] / 2))][2]\r\n val[i][1] = w[int(round(w.shape[0] / 2))][1]\r\n val[i][2] = w[int(round(w.shape[0] / 2))][0]\r\n if val[i] not in self.previousValues:\r\n labels.append(val[i])\r\n self.previousValues.append(val[i])\r\n return labels","def create_labels(graphs : List[SpatialGraph] ) -> np.ndarray:\n if not graphs: # None or empty\n return np.array([])\n\n N = graphs[0].num_nodes\n p = graphs[0].dim\n n_batch = len(graphs)\n\n labels = np.zeros((n_batch, N, p))\n \n for i in range(n_batch):\n labels[i,:,:] = graphs[i].get_coords()\n\n return labels","def return_histogram_labels():\n return list(labels)","def load_data_labels(datasets):\n # Split by words\n x_text = datasets['data']\n x_text = [clean_str(sent) for sent in x_text]\n # Generate labels\n labels = [0, 1, 2, 3, 4]\n print(len(x_text))\n for i in range(len(x_text)):\n label = [0 for j in datasets['target_names']] \n label[datasets['target'][i]] = labels[i]\n labels.append(label)\n y = np.array(labels)\n return [x_text, y]","def encode_labels(self, lilabs):\n\n y = []\n for lab in lilabs:\n y.append([1 if l in lab else 0 for l in self.labels])\n\n return np.array(y, dtype=float)","def array2(self):\n print \"array2\"\n msgbox(whoami())\n #research\n inputLabelID = self.__needleLabelSelector.currentNode().GetID()\n labelnode=slicer.mrmlScene.GetNodeByID(inputLabelID)\n i = labelnode.GetImageData()\n shape = list(i.GetDimensions())\n shape.reverse()\n a = vtk.util.numpy_support.vtk_to_numpy(i.GetPointData().GetScalars()).reshape(shape)\n labels=[]\n val=[[0,0,0] for i in range(a.max()+1)]\n for i in xrange(2,a.max()+1):\n w =numpy.transpose(numpy.where(a==i))\n # labels.append(w.mean(axis=0))\n val[i]=[0,0,0]\n val[i][0]=w[int(round(w.shape[0]/2))][2]\n val[i][1]=w[int(round(w.shape[0]/2))][1]\n val[i][2]=w[int(round(w.shape[0]/2))][0]\n if val[i] not in self.previousValues:\n labels.append(val[i])\n self.previousValues.append(val[i])\n return labels","def get_labels(self) -> np.ndarray:\n if self.i - 1 >= self.k:\n logging.error(\"No more training iterations!!\")\n return np.array([])\n _, test = self.indexes[self.i - 1]\n return self.labels.take(test, axis=-1)","def get_labels(self):\r\n return [\"X\", \"O\", \"B-a\", \"I-a\", \"B-b\", \"I-b\", \"B-c\", \"I-c\", \"S-a\", \"S-b\", \"S-c\", \"[CLS]\", \"[SEP]\"]","def _get_labels(self, ind):\n pass","def make_labels(self, ilines):\n\n llist = []\n for lind, lstr in enumerate(ilines):\n # get label and value list\n rv, label, vals = self.get_label_vals(lstr)\n if rv < 1: continue\n\n nvals = len(vals)\n\n # label = self.find_parent_label(label)\n\n if self.verb > 2: print('++ label: %s, %d val(s)' % (label, nvals))\n\n llist.append(label)\n self.maxcounts[label] = nvals\n self.subjcounts[label] = 0\n\n if not UTIL.vals_are_unique(llist):\n print('** warning: labels are not unique, will use only last values')\n llist = UTIL.get_unique_sublist(llist)\n\n return 0, llist","def labels(self):\n return self._labels","def load_data_labels(datasets):\n # Split by words\n x_text = datasets['data']\n x_text = [clean_str(sent) for sent in x_text]\n # Generate labels\n labels = []\n for i in range(len(x_text)):\n label = [0 for j in datasets['target_names']]\n #print('target={}, i={}'.format(datasets['target'], i))\n label[datasets['target'][i]] = 1\n labels.append(label)\n y = np.array(labels)\n return [x_text, y]","def provide_label(self):\r\n return [(k, tuple([1] + list(v.shape[1:]))) for k, v in self.label]","def get_labels(self) -> np.ndarray:\n return self._dataset.get_labels()[self._ids]","def convertLabels(self, labels):\n counter = 0\n numericLabels = []\n for label in labels:\n if label not in self.labelDict:\n self.labelDict[label] = counter\n self.backwards_conversion[counter] = label\n counter += 1\n numericLabels += [self.labelDict[label]]\n return np.array(numericLabels)","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError","def provide_label(self):\n return [(k, v.shape) for k, v in self.label]","def get_labels(self):\n return [\"A轮\", \"B轮\",\"C轮\",\"天使轮\",\"战略融资\"]","def generate_patch_labels(batch_size : int, patch_shape : int, label : int = 1) -> np.ndarray:\n labels = np.full(shape=(batch_size, patch_shape, patch_shape, 1), fill_value=label)\n return labels","def get_labels(self):\n\t\traise NotImplementedError()","def get_labels(self) -> np.array:\n nb_samples = len(self.list_IDs)\n M = np.empty((nb_samples, *self.dim[:-1], 3))\n\n for i, ID in enumerate(self.list_IDs):\n M[i,] = np.load(self.mask_data_path + ID, allow_pickle=True)\n\n return M","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def __get_ohe_label__(self, label_idx) -> List[int]:\n\n label = [0] * self.n_classes\n label[label_idx] = 1\n\n return label","def encode_labels(labels, nclass=5):\n y = np.zeros((len(labels), nclass)).astype('float32')\n for j, yj in enumerate(labels):\n for i in range(nclass):\n if i+1 == np.floor(yj) + 1:\n y[j, i] = yj - np.floor(yj)\n if i+1 == np.floor(yj):\n y[j, i] = np.floor(yj) - yj + 1\n return y","def get_predefined_labels(self):\n raise NotImplementedError","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def encode_labels(labels, nclass=5):\n Y = np.zeros((len(labels), nclass)).astype('float32')\n for j, y in enumerate(labels):\n for i in range(nclass):\n if i+1 == np.floor(y) + 1:\n Y[j,i] = y - np.floor(y)\n if i+1 == np.floor(y):\n Y[j,i] = np.floor(y) - y + 1\n return Y","def create_TargetLabel(dataset):\n label_Array = dataset['close_-1_r'].shift(-1)\n label_Array = label_Array.apply(lambda x:1 if x>0.0000 else 0)\n return label_Array","def get_labels(self) -> List[str]:\n raise NotImplementedError()","def get_labels(self):\n return [token.label for token in self.tokens]","def getLabels(self):\n return self.numToLabel","def get_labels(self):\n return self.labels[1:]","def get_labels(self) -> List[str]:\n return self.labels","def labels_to_labels(class_labels, num_classes =4):\n levels = []\n for label in class_labels:\n levels_from_label = label_to_levels(int(label), num_classes=num_classes)\n levels.append(levels_from_label)\n return torch.stack(levels).cuda()","def preprocess_labels(label, number_slices):\n labels = [[] for i in range(np.array(label).shape[0])]\n\n for j in range(np.array(label).shape[0]):\n if type(label) is not np.ndarray:\n for i in range(number_slices):\n labels[j].append(np.array(Image.open(label[0][i]), dtype=np.uint8))\n\n label = np.array(labels[0])\n label = label.transpose((1, 2, 0))\n max_mask = np.max(label) * 0.5\n label = np.greater(label, max_mask)\n label = np.expand_dims(label, axis=0)\n\n return label","def compute_labels(pos, neg):\n labels = np.zeros(len(pos) + len(neg), dtype=np.int8)\n labels[:len(pos)] = 1\n labels[len(pos):] = 0\n return labels","def labels(self) -> list:\n return self._labels","def load_labels(labels_dir, trial_name):\n labels_path = labels_dir + trial_name + \".txt\"\n raw_labels_data = np.genfromtxt(labels_path, dtype=np.int,\n converters=LABELS_CONVERTERS,\n usecols=LABELS_USECOLS)\n #print(\"rawlabelsdata: \", raw_labels_data)\n #print(get_first_frame(labels_path))\n frames = np.arange(get_first_frame(labels_path), get_last_frame(labels_path)+1, dtype=np.int)\n #print(\"frames: \", frames)\n #print(frames.shape)\n #labels = np.zeros(frames.shape, dtype=np.int)\n labels1 = []\n #print(labels)\n for start, end, label in raw_labels_data:\n #mask = (frames >= start) & (frames <= end)\n #print(start)\n #print(end)\n i = start\n while(i<end):\n if(i%6 == 0):\n labels1.append(label)\n i = i+1\n\n #labels[mask] = label\n #print(\"labels[mask]: \",labels[mask])\n labels1 = np.array(labels1)\n #print(labels1)\n labels_data = labels1.reshape(-1,1)\n #print(labels1.shape)\n #print(\"labels: \", labels_data)\n \n return labels_data","def labels(self):\n return self._get_labels(self.label_vector)","def make_fixed_labels(self):\n fixed_labels = []\n for dim in range(self.opt.c_dim):\n t = [0] * self.opt.c_dim\n t[dim] = 1\n t = torch.FloatTensor(t).expand([self.opt.batch_size, self.opt.c_dim])\n fixed_labels.append(t)\n return fixed_labels","def encode_ST_labels(labels):\n return np.array([1 if sentiment == 'bullish' else 0 for sentiment in labels])","def labels(self) -> List[str]:\n\n return list(self.t0.keys())","def get_labels(self):\n return self.labels","def get_labels(self):\r\n return None","def compute_labels(pos, neg):\n labels = np.zeros(len(pos) + len(neg))\n labels[:len(pos)] = 1.0\n labels[len(pos):] = 0.0\n return labels","def getLabels(self):\n labels = np.empty(self.numSites, dtype=np.intc)\n _cgco.gcoGetLabels(self.handle, labels)\n return labels","def list_of_labels(self):\n L = np.unique(self.box_label)\n return np.union1d(L, self.geom.list_of_elements_labels())","def createLabels(edge):\n k = removeLabel(edge)\n return k + \"_L\", k + \"_R\"","def get_encoded_labels(self, keys):\n to_return = []\n for key in keys:\n to_return.append(self.attr_map[key])\n # need to transform to N arrays, as KERAS requires all labels for one output/attribute\n # in single array, so for 5 attributes and bulk 1024, it will be 5 arrays of length\n # 10240\n return [np.array(tmp_arr) for tmp_arr in zip(*to_return)]","def provide_label(self):\n return [(k, tuple([self.batch_size] + list(v.shape[1:]))) for k, v in self._label]","def label_data(data):\n if data == 'cat': return [1, 0]\n elif data == 'dog': return [0, 1]","def labels2Vec(labels):\r\n global dict_words_n_vectors\r\n\r\n for i in range(len(labels)):\r\n if labels[i] in dict_words_n_vectors:\r\n labels[i] = dict_words_n_vectors[labels[i]]\r\n else:\r\n labels[i] = np.zeros(300)\r\n return np.array(labels, dtype=\"float32\")","def labels(self):\n return self.label2cc.keys()","def build_label_vocab(labels: Iterable[str]):\n labels_set = set()\n for l in labels:\n labels_set.add(l)\n label_list = sorted(list(labels_set))\n return label_list","def createSetsFromLabels(self):\n \n self.tots = [0]*self.n\n for i in range(self.n):\n self.sets.append([])\n for i in range(self.nPoints):\n self.sets[self.labels[i]].append(i)\n self.tots[self.labels[i]] += 1","def labels(self):\n return self.label(self.p_y_given_x)","def labels_all(self):\n return self._labels_all","def get_labels(info):\n return info.features[\"labels\"].names","def get_labels(info):\n return info.features[\"labels\"].names","def get_labels():\n return {\"contradiction\": 0, \"neutral\": 1, \"entailment\": 2}","def _extract_labels(srcs):\n # Tuples are already labels.\n if type(srcs) == type(()):\n return list(srcs)\n return []","def labels(self, points):\n\n assert(self.final_clusters is not None)\n\n labels = np.array([self.classify_point(point) for point in points])\n \n return labels","def labels(self):\n return self._labels","def labels(self):\n return self._labels","def labels(self):\n return self._labels"],"string":"[\n \"def labels_array(self):\\n return _build_label_vector_rows(\\n [[(label, 1)] for label in self.labels], self.training_labels)[1:].T\",\n \"def generate_labels(n_samples):\\n return np.ones([n_samples, 1]), np.zeros([n_samples, 1])\",\n \"def create_label_array(el):\\n num_digits = len(el) # first element of array holds the count\\n labels_array = np.ones([MAX_LABELS+1], dtype=int) * 10\\n labels_array[0] = num_digits\\n for n in range(num_digits):\\n if el[n] == 10: el[n] = 0 # reassign 0 as 10 for one-hot encoding\\n labels_array[n+1] = el[n]\\n return labels_array\",\n \"def create_label_array(el):\\n num_digits = len(el) # first element of array holds the count\\n labels_array = np.ones([MAX_LABELS+1], dtype=int) * 10\\n labels_array[0] = num_digits\\n for n in range(num_digits):\\n if el[n] == 10: el[n] = 0 # reassign 0 as 10 for one-hot encoding\\n labels_array[n+1] = el[n]\\n return labels_array\",\n \"def get_labels(self):\\n return []\",\n \"def generate_labels():\\n label_set = set([])\\n for data in load_data():\\n label = data.split(' ', 1)[0]\\n label_set.add(label)\\n labels = list(label_set)\\n labels.sort()\\n return labels\",\n \"def labels(self) -> ndarray:\\n return self._labels\",\n \"def labels_(self) -> DNDarray:\\n return self._labels\",\n \"def generate_labels(pics):\\r\\n return []\",\n \"def array2(self):\\r\\n profbox(whoami())\\r\\n # research\\r\\n inputLabelID = self.__needleLabelSelector.currentNode().GetID()\\r\\n labelnode = slicer.mrmlScene.GetNodeByID(inputLabelID)\\r\\n i = labelnode.GetImageData()\\r\\n shape = list(i.GetDimensions())\\r\\n shape.reverse()\\r\\n a = vtk.util.numpy_support.vtk_to_numpy(i.GetPointData().GetScalars()).reshape(shape)\\r\\n labels = []\\r\\n val = [[0, 0, 0] for i in range(a.max() + 1)]\\r\\n for i in xrange(2, a.max() + 1):\\r\\n w = numpy.transpose(numpy.where(a == i))\\r\\n # labels.append(w.mean(axis=0))\\r\\n val[i] = [0, 0, 0]\\r\\n val[i][0] = w[int(round(w.shape[0] / 2))][2]\\r\\n val[i][1] = w[int(round(w.shape[0] / 2))][1]\\r\\n val[i][2] = w[int(round(w.shape[0] / 2))][0]\\r\\n if val[i] not in self.previousValues:\\r\\n labels.append(val[i])\\r\\n self.previousValues.append(val[i])\\r\\n return labels\",\n \"def create_labels(graphs : List[SpatialGraph] ) -> np.ndarray:\\n if not graphs: # None or empty\\n return np.array([])\\n\\n N = graphs[0].num_nodes\\n p = graphs[0].dim\\n n_batch = len(graphs)\\n\\n labels = np.zeros((n_batch, N, p))\\n \\n for i in range(n_batch):\\n labels[i,:,:] = graphs[i].get_coords()\\n\\n return labels\",\n \"def return_histogram_labels():\\n return list(labels)\",\n \"def load_data_labels(datasets):\\n # Split by words\\n x_text = datasets['data']\\n x_text = [clean_str(sent) for sent in x_text]\\n # Generate labels\\n labels = [0, 1, 2, 3, 4]\\n print(len(x_text))\\n for i in range(len(x_text)):\\n label = [0 for j in datasets['target_names']] \\n label[datasets['target'][i]] = labels[i]\\n labels.append(label)\\n y = np.array(labels)\\n return [x_text, y]\",\n \"def encode_labels(self, lilabs):\\n\\n y = []\\n for lab in lilabs:\\n y.append([1 if l in lab else 0 for l in self.labels])\\n\\n return np.array(y, dtype=float)\",\n \"def array2(self):\\n print \\\"array2\\\"\\n msgbox(whoami())\\n #research\\n inputLabelID = self.__needleLabelSelector.currentNode().GetID()\\n labelnode=slicer.mrmlScene.GetNodeByID(inputLabelID)\\n i = labelnode.GetImageData()\\n shape = list(i.GetDimensions())\\n shape.reverse()\\n a = vtk.util.numpy_support.vtk_to_numpy(i.GetPointData().GetScalars()).reshape(shape)\\n labels=[]\\n val=[[0,0,0] for i in range(a.max()+1)]\\n for i in xrange(2,a.max()+1):\\n w =numpy.transpose(numpy.where(a==i))\\n # labels.append(w.mean(axis=0))\\n val[i]=[0,0,0]\\n val[i][0]=w[int(round(w.shape[0]/2))][2]\\n val[i][1]=w[int(round(w.shape[0]/2))][1]\\n val[i][2]=w[int(round(w.shape[0]/2))][0]\\n if val[i] not in self.previousValues:\\n labels.append(val[i])\\n self.previousValues.append(val[i])\\n return labels\",\n \"def get_labels(self) -> np.ndarray:\\n if self.i - 1 >= self.k:\\n logging.error(\\\"No more training iterations!!\\\")\\n return np.array([])\\n _, test = self.indexes[self.i - 1]\\n return self.labels.take(test, axis=-1)\",\n \"def get_labels(self):\\r\\n return [\\\"X\\\", \\\"O\\\", \\\"B-a\\\", \\\"I-a\\\", \\\"B-b\\\", \\\"I-b\\\", \\\"B-c\\\", \\\"I-c\\\", \\\"S-a\\\", \\\"S-b\\\", \\\"S-c\\\", \\\"[CLS]\\\", \\\"[SEP]\\\"]\",\n \"def _get_labels(self, ind):\\n pass\",\n \"def make_labels(self, ilines):\\n\\n llist = []\\n for lind, lstr in enumerate(ilines):\\n # get label and value list\\n rv, label, vals = self.get_label_vals(lstr)\\n if rv < 1: continue\\n\\n nvals = len(vals)\\n\\n # label = self.find_parent_label(label)\\n\\n if self.verb > 2: print('++ label: %s, %d val(s)' % (label, nvals))\\n\\n llist.append(label)\\n self.maxcounts[label] = nvals\\n self.subjcounts[label] = 0\\n\\n if not UTIL.vals_are_unique(llist):\\n print('** warning: labels are not unique, will use only last values')\\n llist = UTIL.get_unique_sublist(llist)\\n\\n return 0, llist\",\n \"def labels(self):\\n return self._labels\",\n \"def load_data_labels(datasets):\\n # Split by words\\n x_text = datasets['data']\\n x_text = [clean_str(sent) for sent in x_text]\\n # Generate labels\\n labels = []\\n for i in range(len(x_text)):\\n label = [0 for j in datasets['target_names']]\\n #print('target={}, i={}'.format(datasets['target'], i))\\n label[datasets['target'][i]] = 1\\n labels.append(label)\\n y = np.array(labels)\\n return [x_text, y]\",\n \"def provide_label(self):\\r\\n return [(k, tuple([1] + list(v.shape[1:]))) for k, v in self.label]\",\n \"def get_labels(self) -> np.ndarray:\\n return self._dataset.get_labels()[self._ids]\",\n \"def convertLabels(self, labels):\\n counter = 0\\n numericLabels = []\\n for label in labels:\\n if label not in self.labelDict:\\n self.labelDict[label] = counter\\n self.backwards_conversion[counter] = label\\n counter += 1\\n numericLabels += [self.labelDict[label]]\\n return np.array(numericLabels)\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError\",\n \"def provide_label(self):\\n return [(k, v.shape) for k, v in self.label]\",\n \"def get_labels(self):\\n return [\\\"A轮\\\", \\\"B轮\\\",\\\"C轮\\\",\\\"天使轮\\\",\\\"战略融资\\\"]\",\n \"def generate_patch_labels(batch_size : int, patch_shape : int, label : int = 1) -> np.ndarray:\\n labels = np.full(shape=(batch_size, patch_shape, patch_shape, 1), fill_value=label)\\n return labels\",\n \"def get_labels(self):\\n\\t\\traise NotImplementedError()\",\n \"def get_labels(self) -> np.array:\\n nb_samples = len(self.list_IDs)\\n M = np.empty((nb_samples, *self.dim[:-1], 3))\\n\\n for i, ID in enumerate(self.list_IDs):\\n M[i,] = np.load(self.mask_data_path + ID, allow_pickle=True)\\n\\n return M\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def __get_ohe_label__(self, label_idx) -> List[int]:\\n\\n label = [0] * self.n_classes\\n label[label_idx] = 1\\n\\n return label\",\n \"def encode_labels(labels, nclass=5):\\n y = np.zeros((len(labels), nclass)).astype('float32')\\n for j, yj in enumerate(labels):\\n for i in range(nclass):\\n if i+1 == np.floor(yj) + 1:\\n y[j, i] = yj - np.floor(yj)\\n if i+1 == np.floor(yj):\\n y[j, i] = np.floor(yj) - yj + 1\\n return y\",\n \"def get_predefined_labels(self):\\n raise NotImplementedError\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def encode_labels(labels, nclass=5):\\n Y = np.zeros((len(labels), nclass)).astype('float32')\\n for j, y in enumerate(labels):\\n for i in range(nclass):\\n if i+1 == np.floor(y) + 1:\\n Y[j,i] = y - np.floor(y)\\n if i+1 == np.floor(y):\\n Y[j,i] = np.floor(y) - y + 1\\n return Y\",\n \"def create_TargetLabel(dataset):\\n label_Array = dataset['close_-1_r'].shift(-1)\\n label_Array = label_Array.apply(lambda x:1 if x>0.0000 else 0)\\n return label_Array\",\n \"def get_labels(self) -> List[str]:\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n return [token.label for token in self.tokens]\",\n \"def getLabels(self):\\n return self.numToLabel\",\n \"def get_labels(self):\\n return self.labels[1:]\",\n \"def get_labels(self) -> List[str]:\\n return self.labels\",\n \"def labels_to_labels(class_labels, num_classes =4):\\n levels = []\\n for label in class_labels:\\n levels_from_label = label_to_levels(int(label), num_classes=num_classes)\\n levels.append(levels_from_label)\\n return torch.stack(levels).cuda()\",\n \"def preprocess_labels(label, number_slices):\\n labels = [[] for i in range(np.array(label).shape[0])]\\n\\n for j in range(np.array(label).shape[0]):\\n if type(label) is not np.ndarray:\\n for i in range(number_slices):\\n labels[j].append(np.array(Image.open(label[0][i]), dtype=np.uint8))\\n\\n label = np.array(labels[0])\\n label = label.transpose((1, 2, 0))\\n max_mask = np.max(label) * 0.5\\n label = np.greater(label, max_mask)\\n label = np.expand_dims(label, axis=0)\\n\\n return label\",\n \"def compute_labels(pos, neg):\\n labels = np.zeros(len(pos) + len(neg), dtype=np.int8)\\n labels[:len(pos)] = 1\\n labels[len(pos):] = 0\\n return labels\",\n \"def labels(self) -> list:\\n return self._labels\",\n \"def load_labels(labels_dir, trial_name):\\n labels_path = labels_dir + trial_name + \\\".txt\\\"\\n raw_labels_data = np.genfromtxt(labels_path, dtype=np.int,\\n converters=LABELS_CONVERTERS,\\n usecols=LABELS_USECOLS)\\n #print(\\\"rawlabelsdata: \\\", raw_labels_data)\\n #print(get_first_frame(labels_path))\\n frames = np.arange(get_first_frame(labels_path), get_last_frame(labels_path)+1, dtype=np.int)\\n #print(\\\"frames: \\\", frames)\\n #print(frames.shape)\\n #labels = np.zeros(frames.shape, dtype=np.int)\\n labels1 = []\\n #print(labels)\\n for start, end, label in raw_labels_data:\\n #mask = (frames >= start) & (frames <= end)\\n #print(start)\\n #print(end)\\n i = start\\n while(i<end):\\n if(i%6 == 0):\\n labels1.append(label)\\n i = i+1\\n\\n #labels[mask] = label\\n #print(\\\"labels[mask]: \\\",labels[mask])\\n labels1 = np.array(labels1)\\n #print(labels1)\\n labels_data = labels1.reshape(-1,1)\\n #print(labels1.shape)\\n #print(\\\"labels: \\\", labels_data)\\n \\n return labels_data\",\n \"def labels(self):\\n return self._get_labels(self.label_vector)\",\n \"def make_fixed_labels(self):\\n fixed_labels = []\\n for dim in range(self.opt.c_dim):\\n t = [0] * self.opt.c_dim\\n t[dim] = 1\\n t = torch.FloatTensor(t).expand([self.opt.batch_size, self.opt.c_dim])\\n fixed_labels.append(t)\\n return fixed_labels\",\n \"def encode_ST_labels(labels):\\n return np.array([1 if sentiment == 'bullish' else 0 for sentiment in labels])\",\n \"def labels(self) -> List[str]:\\n\\n return list(self.t0.keys())\",\n \"def get_labels(self):\\n return self.labels\",\n \"def get_labels(self):\\r\\n return None\",\n \"def compute_labels(pos, neg):\\n labels = np.zeros(len(pos) + len(neg))\\n labels[:len(pos)] = 1.0\\n labels[len(pos):] = 0.0\\n return labels\",\n \"def getLabels(self):\\n labels = np.empty(self.numSites, dtype=np.intc)\\n _cgco.gcoGetLabels(self.handle, labels)\\n return labels\",\n \"def list_of_labels(self):\\n L = np.unique(self.box_label)\\n return np.union1d(L, self.geom.list_of_elements_labels())\",\n \"def createLabels(edge):\\n k = removeLabel(edge)\\n return k + \\\"_L\\\", k + \\\"_R\\\"\",\n \"def get_encoded_labels(self, keys):\\n to_return = []\\n for key in keys:\\n to_return.append(self.attr_map[key])\\n # need to transform to N arrays, as KERAS requires all labels for one output/attribute\\n # in single array, so for 5 attributes and bulk 1024, it will be 5 arrays of length\\n # 10240\\n return [np.array(tmp_arr) for tmp_arr in zip(*to_return)]\",\n \"def provide_label(self):\\n return [(k, tuple([self.batch_size] + list(v.shape[1:]))) for k, v in self._label]\",\n \"def label_data(data):\\n if data == 'cat': return [1, 0]\\n elif data == 'dog': return [0, 1]\",\n \"def labels2Vec(labels):\\r\\n global dict_words_n_vectors\\r\\n\\r\\n for i in range(len(labels)):\\r\\n if labels[i] in dict_words_n_vectors:\\r\\n labels[i] = dict_words_n_vectors[labels[i]]\\r\\n else:\\r\\n labels[i] = np.zeros(300)\\r\\n return np.array(labels, dtype=\\\"float32\\\")\",\n \"def labels(self):\\n return self.label2cc.keys()\",\n \"def build_label_vocab(labels: Iterable[str]):\\n labels_set = set()\\n for l in labels:\\n labels_set.add(l)\\n label_list = sorted(list(labels_set))\\n return label_list\",\n \"def createSetsFromLabels(self):\\n \\n self.tots = [0]*self.n\\n for i in range(self.n):\\n self.sets.append([])\\n for i in range(self.nPoints):\\n self.sets[self.labels[i]].append(i)\\n self.tots[self.labels[i]] += 1\",\n \"def labels(self):\\n return self.label(self.p_y_given_x)\",\n \"def labels_all(self):\\n return self._labels_all\",\n \"def get_labels(info):\\n return info.features[\\\"labels\\\"].names\",\n \"def get_labels(info):\\n return info.features[\\\"labels\\\"].names\",\n \"def get_labels():\\n return {\\\"contradiction\\\": 0, \\\"neutral\\\": 1, \\\"entailment\\\": 2}\",\n \"def _extract_labels(srcs):\\n # Tuples are already labels.\\n if type(srcs) == type(()):\\n return list(srcs)\\n return []\",\n \"def labels(self, points):\\n\\n assert(self.final_clusters is not None)\\n\\n labels = np.array([self.classify_point(point) for point in points])\\n \\n return labels\",\n \"def labels(self):\\n return self._labels\",\n \"def labels(self):\\n return self._labels\",\n \"def labels(self):\\n return self._labels\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8269726","0.76015544","0.7565441","0.7565441","0.7460371","0.73777056","0.73232925","0.7319245","0.72369486","0.7219482","0.7186704","0.716197","0.71618766","0.71541744","0.7145023","0.7082937","0.70737344","0.70646393","0.70617527","0.70523167","0.70516545","0.70495164","0.70165366","0.70097685","0.7003893","0.69742566","0.6964868","0.6952881","0.69328785","0.69140744","0.6899432","0.6888569","0.6888569","0.6888569","0.6851743","0.6851174","0.6827769","0.6826182","0.6826182","0.6826182","0.6826182","0.6826182","0.6826182","0.6826182","0.6826182","0.6826182","0.6826182","0.6826182","0.6826182","0.6826182","0.6826182","0.6826182","0.6826182","0.68237853","0.68237853","0.68237853","0.68237853","0.68237853","0.68237853","0.68237853","0.68237853","0.68225807","0.68129426","0.67895544","0.6772489","0.67644227","0.6760693","0.67599","0.67568666","0.6730981","0.67169416","0.67073256","0.67027813","0.6682468","0.6675969","0.6675655","0.66723573","0.6663921","0.66492724","0.66461885","0.664494","0.66208684","0.6602751","0.6600904","0.66005826","0.65986246","0.6596026","0.65940154","0.6574182","0.6570113","0.6568915","0.65654236","0.65650046","0.65650046","0.65612453","0.65560025","0.65306145","0.65295255","0.65295255","0.65295255"],"string":"[\n \"0.8269726\",\n \"0.76015544\",\n \"0.7565441\",\n \"0.7565441\",\n \"0.7460371\",\n \"0.73777056\",\n \"0.73232925\",\n \"0.7319245\",\n \"0.72369486\",\n \"0.7219482\",\n \"0.7186704\",\n \"0.716197\",\n \"0.71618766\",\n \"0.71541744\",\n \"0.7145023\",\n \"0.7082937\",\n \"0.70737344\",\n \"0.70646393\",\n \"0.70617527\",\n \"0.70523167\",\n \"0.70516545\",\n \"0.70495164\",\n \"0.70165366\",\n \"0.70097685\",\n \"0.7003893\",\n \"0.69742566\",\n \"0.6964868\",\n \"0.6952881\",\n \"0.69328785\",\n \"0.69140744\",\n \"0.6899432\",\n \"0.6888569\",\n \"0.6888569\",\n \"0.6888569\",\n \"0.6851743\",\n \"0.6851174\",\n \"0.6827769\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.6826182\",\n \"0.68237853\",\n \"0.68237853\",\n \"0.68237853\",\n \"0.68237853\",\n \"0.68237853\",\n \"0.68237853\",\n \"0.68237853\",\n \"0.68237853\",\n \"0.68225807\",\n \"0.68129426\",\n \"0.67895544\",\n \"0.6772489\",\n \"0.67644227\",\n \"0.6760693\",\n \"0.67599\",\n \"0.67568666\",\n \"0.6730981\",\n \"0.67169416\",\n \"0.67073256\",\n \"0.67027813\",\n \"0.6682468\",\n \"0.6675969\",\n \"0.6675655\",\n \"0.66723573\",\n \"0.6663921\",\n \"0.66492724\",\n \"0.66461885\",\n \"0.664494\",\n \"0.66208684\",\n \"0.6602751\",\n \"0.6600904\",\n \"0.66005826\",\n \"0.65986246\",\n \"0.6596026\",\n \"0.65940154\",\n \"0.6574182\",\n \"0.6570113\",\n \"0.6568915\",\n \"0.65654236\",\n \"0.65650046\",\n \"0.65650046\",\n \"0.65612453\",\n \"0.65560025\",\n \"0.65306145\",\n \"0.65295255\",\n \"0.65295255\",\n \"0.65295255\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74500805"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":83199,"cells":{"query":{"kind":"string","value":"Saves an array under the name 'filename'"},"document":{"kind":"string","value":"def save_array(array, filename):\n np.save(filename, array)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def quick_save_array(data, file_name, delimiter=',', ):\n data.tofile(file_name, sep=delimiter)","def write_csv_file(array, filename):\n\tnp.savetxt(filename, array, delimiter=\",\")","def save_array(self, name: str, array: np.ndarray):\r\n np.savetxt(self._path_for_csv(name), array, delimiter=\",\")","def save(self, filename):\n\t\tnp.savetxt(filename, self.V)\n\t\treturn","def save2file(lis, path):\r\n np.save(path, np.array(lis))","def save(self, path_to_save):\n for item in self.data_array:\n item.save(path_to_save+item.file_name)","def save(file, arr, allow_pickle=True, fix_imports=True):\n\n return numpy.save(file, array_create.array(arr, bohrium=False), allow_pickle, fix_imports)","def save_to_file(samps, filename, save_as_numpy):\n with open(filename, 'wb') as out_file:\n if save_as_numpy:\n np.save(out_file, samps, allow_pickle=False, fix_imports=False)\n else:\n samps.tofile(out_file)","def save(self, filename):\n pass","def store(self, filename):","def save_to_array(arr_name, arr_object):\n return np.save(arr_name, arr_object)","def save(self, filename):\n np.savetxt(\n filename,\n np.array([np.array(list(e)) for e in self]),\n fmt=\"%.03f\",\n delimiter=\"\\t\",\n )","def pickle(array, file):\r\n\timport cPickle\r\n\tfo = open(file,'wb')\r\n\tcPickle.dump(array,fo)\r\n\tfo.close()","def store(obj, filename, suffix = ''):\n # It is a numpy array\n if type(obj) == np.ndarray:\n path,f = writefile(filename, obj_id='numpy_objs', suffix=suffix)\n json.dump(obj, fp=f, cls=NumpyEncoder,\n separators=(',', ':'), sort_keys=True, indent=4)\n print '> saved with JSON to {}'.format(path)\n else:\n path, f = writefile(filename, obj_id='other_objs', suffix=suffix)\n pickle.dump(obj, file=f)\n print '> saved with dill (pickled) to {}'.format(path)\n return path","def save(self, filename = 'array_zest', path = '/home/eric/dev/insitu/data/zs_recovery/'):\n filename = filename# + '_Lx_' + str(self.Lx) + 'm_Ly_' + str(self.Ly) + 'm'\n self.path_filename = path + filename + '.pkl'\n f = open(self.path_filename, 'wb')\n pickle.dump(self.__dict__, f, 2)\n f.close()","def write_output(arr, filename):\n print('Started writing the output..')\n f = open(filename, 'w')\n for a in arr:\n f.write(str(a) + '\\n')\n f.close()\n print('Done!, Open the file to see the approved loans.')","def save_lists_to_file(filename, elev_list, dist_list):\n import numpy as np\n\n np.save(file=filename,arr=np.array([elev_list, dist_list]))","def save_file(self, filename):\n if self.t3data:\n np.savetxt(filename, self.t3data)\n else:\n self.export_to_ascii()","def save_data(data, filename, save_path):\n if not os.path.exists(save_path):\n os.mkdir(save_path)\n np.save(os.path.join(save_path, filename), data)","def array_to_file(filename, a):\n a = normalize_array(a)\n i = Image.fromarray(a.astype('uint8'))\n return i.save(filename)","def save(self, filename):\n \n raise NotImplementedError(\"not implemented!\")","def save(self, filename):\n np.savez(temp_dir + '/' + filename + '.npz', chip_ids=self.chip_ids, core_ids=self.core_ids, cx_ids=self.cx_ids)","def save_array_as(arr, loc=None):\n if loc is None:\n root = tk.Tk()\n root.loc = filedialog.asksaveasfilename(initialdir=\"/\",\n title=\"Save as\",\n filetypes=((\"npy files\", \"*.npy\"),\n (\"all files\", \"*.*\"))\n )\n np.save(root.loc, arr)\n root.destroy()\n else:\n np.save(loc, arr)","def save(data, filename):\r\n with open(filename, 'wb') as fp:\r\n pickle.dump(data, fp)","def save(self, path_to_save):\n data_to_save = []\n for item in self.data_array:\n if isinstance(item, Result):\n data_to_save.append(item.get())\n\n np.savetxt(path_to_save+'.txt', data_to_save, fmt='%5s', delimiter=',')","def save(self, filename=\"\"):\n if len(filename) == 0:\n filename = self.filename\n self.quotes_list.save(filename)","def save_npy(self, array: np.ndarray, name: str):\n tf.gfile.MkDir(str(self.info.npy_path))\n file_name = name + \".npy\"\n np.save(str(self.info.npy_path / file_name), array)","def save(self, filename):\n pass","def writeList2File(filename, array, overwrite=False, separator=';'):\n mode = 'a'\n if overwrite:\n mode = 'w'\n file = open(filename, mode)\n file.write(separator.join(map(str,array)) + '\\n')","def save(self, filename):\n np.savez(temp_dir + '/' + filename + '.npz', core_ids=self.core_ids, cx_ids=self.cx_ids)","def output_file(newarray, filename):\n np.savetxt(filename + \"_formatted.txt\", newarray, delimiter=\" \", fmt=\"%s\")","def save_file(data, filename):\n with open(filename, \"w\") as outfile:\n json.dump(data, outfile)","def save(self, filename):\n raise NotImplementedError","def save_dataset_as_numpy(dataloader, file_path, key=\"original\", message=\"\"):\n\n print(message)\n array_to_save = compose_array_from_dataloader(dataloader, key=key)\n with open(file_path, \"wb\") as file:\n np.save(file, array_to_save)","def dataToJson(self,dataArray, filename):\n try:\n jsondata = simplejson.dumps(dataArray, indent=4, skipkeys=True, sort_keys=True)\n fd = open(\"./data/\" + filename, 'w')\n fd.write(jsondata)\n fd.close()\n print (\"data written to the file succesfully\")\n except:\n print ('ERROR writing', filename)\n pass","def save_to_file(filename: str, sequence: List[Sample]):\n\n with open(get_path() + \"/sequence/\" + filename, \"ab+\") as file:\n for sample in sequence:\n pickle.dump(sample, file, pickle.HIGHEST_PROTOCOL)","def outputPulses(self,filename):\n np.save(filename,self.getData())\n return","def save(self, filename):\n data = {\"sizes\": self.sizes,\n \"weights\": [w.tolist() for w in self.weights],\n \"biases\": [b.tolist() for b in self.biases]}\n f = open(filename, \"w\")\n json.dump(data, f)\n f.close()","def savealist(alist, filename):\n out = open(filename, \"w\")\n for i in alist:\n out.write(str(i) + \"\\n\") # if i is numeric\n out.close()","def savefile(filename, data):\n with open(filename, \"w\", encoding=\"utf-8\") as file:\n output = dumps(data, ensure_ascii=False, sort_keys=True, indent=2)\n file.write(output)","def save_to_array(x, y):\n\n with open(settings.data(\"x.npy\"), \"wb\") as file:\n np.save(file, x)\n\n with open(settings.data(\"y.npy\"), \"wb\") as file:\n np.save(file, y)","def save(self, filename, type='CSV'):\n # Convenient form for saving:\n save = np.ndarray(shape=(self.Pbrem.shape[0]+1, self.Pbrem.shape[1]), dtype=np.float)\n save[0,:] = self.time\n save[1:,:] = self.Pbrem\n\n if type == 'CSV':\n with open(filename, 'wb') as file:\n np.savetxt(file, save, delimiter=',', header='Time,Total,Fuel,Shell\\n')\n\n elif type == 'pickle':\n with open(filename, 'wb') as file:\n pickle.dump(save, file)","def save(self, directory):\n for field in self.save_fields:\n np.save(pjoin(directory, field+'.npy'), self.__dict__[field])","def save_data(data: typing.List[typing.Dict], filename: str):\n now = datetime.datetime.now().strftime(\"%Y-%m-%d_%H-%M-%S\")\n with open(f\"{filename}-{now}.json\", \"w\") as f:\n f.write(json.dumps(data))","def save(data, file, compression=0):\n f = file if isinstance(file, bob.io.base.HDF5File) else bob.io.base.HDF5File(file, 'w')\n if hasattr(data, 'save'):\n data.save(f)\n else:\n f.set(\"array\", data, compression=compression)","def save_enu(self, filename):\n x, y, z = self.get_coords_enu()\n coords = np.vstack([x, y, z]).T\n np.savetxt(filename, coords, fmt=b'%.12e')","def save(self, filename):\n Util.savePickle(self.V, filename + self.ext, overwrite=True)\n return filename + self.ext","def dump_npy(filename: str, obj, **kwargs):\n return np.save(filename, obj)","def save(self, fname):\n pass","def save_data(self, f): \n if not self.sampling:\n self.convert_to_array()\n np.save(f, self.reads)","def save_obsarray_to_pickle(self, obs_array, dest_dir):\n if not os.path.exists(dest_dir):\n os.makedirs(dest_dir)\n dump_array = obs_array\n pkl_name = 'batch' + str(len(os.listdir(dest_dir)))\n dump_path = os.path.join(dest_dir, pkl_name)\n self.pickledump(dump_array, dump_path)\n return pkl_name","def _save(self, data: np.ndarray) -> None:\n ...","def save_arrays_to_folder(arrays, folder_path):\n # Check if the folder exists and create it if necessary\n path = Path(folder_path)\n path.mkdir(parents=True, exist_ok=True)\n\n # Loop over the arrays and save them to the folder with numbered filenames\n for i, arr in enumerate(arrays):\n filename = f\"coords{str(i + 1).zfill(4)}.npy\"\n filepath = path / filename\n np.save(filepath, arr)","def save_list(lines, filename):\n data = '\\n'.join(lines)\n file = open(filename, 'w')\n file.write(data)\n file.close()","def ArraytoFile(_array):\n\tfile = open('sort1.txt', 'w')\n\tfor line in _array:\n\t\tfile.write(line+\"\\n\")\n\tfile.close()","def save(self, filename):\n with open(filename, \"w\") as f:\n m = {\n \"order\": self.order,\n \"pad\": self.pad,\n \"records\": {str(k): v for k, v in self.records.items()}\n }\n json.dump(m, f)","def save_array_as_image(arr, filename):\n arr = arr.copy().clip(0, 255).astype('uint8')\n im = Image.fromarray(arr)\n im.save(filename)","def savez(file, *args, **kwds):\n\n ary_list = []\n for a in args:\n ary_list.append(array_create.array(a, bohrium=False))\n return numpy.savez(file, *ary_list, **kwds)","def save_to_file(filename, pairs):\n logger.info('save to file...')\n\n fname = filename + FILE_EXT\n mode = 'a' if os.path.isfile(fname) else 'w'\n logger.debug('mode is: ' + mode)\n\n with open(fname, mode) as f:\n for pair in pairs:\n f.write(format_pair(pair))","def save(self, file, name):\n np.savetxt(os.path.join(file, name), self.matrix, fmt='%f')","def save_data(self, filename, coordinates=True):\n\n if not coordinates:\n savetxt(self.wpath+filename, self.dataset, delimiter=',', fmt='%.18e,%.18e,%d,%s')\n else:\n print self.wpath+filename\n savetxt(self.wpath+filename, self.getDataCoordinates(), delimiter=',', fmt='%.18e,%.18e')","def save(self, filename):\n o = open(filename, 'w')\n o.write(self.write())\n o.close()","def save(self, filename):\n data = {\"sizes\": self.sizes,\n \"weights\": [w.tolist() for w in self.weights],\n \"biases\": [b.tolist() for b in self.biases],\n \"cost\": str(self.cost.__name__)}\n f = open(filename, \"w\")\n json.dump(data, f)\n f.close()","def save_as(self, filename):\n raise NotImplementedError(\n \"Saving ring buffers to other formats is not yet implemented.\")\n\n if filename[-3:] == 'zip':\n pass # TODO\n elif filename[-2:] == 'h5':\n pass # TODO\n elif filename[-4:] == 'fits':\n pass # TODO\n elif filename[-3:] == 'npz':\n self.save_as_numpy(filename)","def save(self, file):\n boulders = []\n elephants = []\n rhinos = []\n for i in range(5):\n for j in range(5):\n if self[i][j]!= 0:\n piece = self[i][j]\n L = []\n if not isinstance(self[i][j], Boulder):\n L.append(self[i][j].direction[0])\n L.append(self[i][j].direction[1])\n if piece.species == \"Elephant\":\n elephants.append(\"(\" + str(i) + \",\" + str(j)+ \") : np.array([\"+str(L[0])+ \",\" + str(L[1])+\"])\")\n elif piece.species == \"Rhinoceros\":\n rhinos.append(\"(\"+str(i)+\",\" +str(j)+ \") : np.array([\"+str(L[0]) + \",\" + str(L[1])+\"])\")\n elif isinstance(piece, Boulder):\n boulders.append(\"(\" + str(i) + \",\" + str(j) + \")\")\n file.write(\"# King of Siam GameFile \\n\\nplayer_turn {\\n \" + self.playerTurn + \"\\n}\\n\\n\")\n file.write(\"Boulder {\")\n for k in range(len(boulders)):\n file.write(\"\\n \" + boulders[k] + \";\")\n file.write(\"\\n}\\n\\nElephant {\")\n for elt in elephants:\n file.write(\"\\n \" + elt + \";\")\n file.write(\"\\n}\\n\\nRhinoceros {\")\n for elt in rhinos:\n file.write(\"\\n \" + elt + \";\")\n file.write(\"\\n}\")\n\n file.close()","def toFile(self,fid):\n stack = []\n for w,b in self.stack:\n w.copy_to_host()\n b.copy_to_host()\n stack.append([w.numpy_array,b.numpy_array])\n\tpickle.dump(stack,fid)","def save(filename, mat):\n if not isinstance(mat, np.ndarray):\n raise ValueError('for now, we can only save numpy arrays')\n return sio.savemat(filename, {'data': mat}, appendmat=False)","def save(self, filename: str):\n if os.path.isfile(filename):\n raise FileExistsError(\"Target file exists\")\n\n with open(filename, \"wb\") as binary_writer:\n pickle.dump([self.gene_sets, self.gene_set_size, self.gene_set_names,\n self.interactors, self.n_curated, self.n_interactors],\n binary_writer)","def save(self, filename):\n import json\n\n json = json.dumps(self.joint_limits)\n with open(filename, 'w') as f:\n f.write(json)","def save_memory(self, filename):\n \n\n with open(filename + '/obses.npy', 'wb') as f:\n np.save(f, self.obses)\n \n with open(filename + '/actions.npy', 'wb') as f:\n np.save(f, self.actions)\n\n with open(filename + '/next_obses.npy', 'wb') as f:\n np.save(f, self.next_obses)\n \n with open(filename + '/rewards.npy', 'wb') as f:\n np.save(f, self.rewards)\n \n with open(filename + '/not_dones.npy', 'wb') as f:\n np.save(f, self.not_dones)\n \n with open(filename + '/not_dones_no_max.npy', 'wb') as f:\n np.save(f, self.not_dones_no_max)\n\n with open(filename + '/index.txt', 'w') as f:\n f.write(\"{}\".format(self.idx))\n\n print(\"save buffer to {}\".format(filename))","def on_save_arrays_action(self):\n if self.mesh:\n name = QFileDialog.getSaveFileName(self.parent(), filter=\"*.cfma\")\n if name != ('', ''):\n mesh = self.mesh\n mesh.return_boundary_elements = True\n coords, edof, dofs, bdofs, elementmarkers, boundary_elements = mesh.create()\n cfu.save_arrays(coords, edof, dofs, bdofs, elementmarkers, boundary_elements, self.marker_dict,\n name[0])","def save(self, filename):\n pickle.dump(self, open(filename + '.p', 'wb'), 2)","def save_data(data, filename='data.txt'):\n with open(filename, 'w', encoding=\"utf-8\") as file:\n for item in data:\n print(item, file=file)","def dump(filename, data):\n _savez(filename, [], data, True, allow_pickle=False)","def save_to_file(cls, list_objs):\n filename = cls.__name__ + \".json\"\n with open(filename, \"w\") as f:\n if list_objs is None:\n f.write(\"[]\")\n else:\n d = [x.to_dictionary() for x in list_objs]\n f.write(Base.to_json_string(d))","def _write_files_(self, arrs, filepath):\n\t\t# If there's a dot in the filepath prepend the filepath\n\t\tif '.' in filepath:\n\t\t\tfilename, ext = gen_io.remove_file_extension(filepath)\n\t\t\tarrs = {f\"{filename}_{key}.{ext}\": arrs[key] for key in arrs}\n\t\t\tprint(arrs.keys())\n\t\t\n\t\t# Else just assume it's a folder\n\t\telse:\n\t\t\tif not os.path.isdir(filepath):\n\t\t\t\tos.makedirs(filepath)\n\n\t\t\tarrs = {f\"{filepath}/{key}.npy\": arrs[key] for key in arrs}\n\n\t\t# Now write the files.\n\t\tfor key in arrs:\n\t\t\tfilepath = gen_io.create_unique_filepath(key)\n\t\t\tnp.save(key, arrs[key])","def save_data(data, file_name):\r\n file = open(file_name, \"w\")\r\n file.write(data + \"\\n\")\r\n file.close()","def saveFile(self, filename=\"UQModelTest.json\"):\n sd = self.saveDict()\n with open(filename, \"w\") as f:\n json.dump(sd, f, indent=2)","def store (input, filename) :\n cout = open (filename, 'w')\n pickle.dump (input, cout)\n cout.close ()","def save_data(data, filename=None):\n filename = filename or OUTPUT_FILE\n common.open_and_write_file(filename, data, as_json=True)\n print(\"Saved file: {}.\".format(filename))","def saveData(self,filename=None,ext='npy',ascii=False):\n if filename is None:\n filename = self.filename\n filename = \".\".join(filename.split(\".\")[:-1])+\".\"+ext\n if self.verbose:\n print(\"Saving: %s\" % filename)\n if ascii:\n shape = self.shape(squeeze=False)\n nsubint = self.getNsubint()\n npol = self.getNpol()\n nchan = self.getNchan()\n nbin = self.getNbin()\n output = \"\"\n if shape[0] == 1 and shape[1] == 1 and shape[2] == 1:\n np.savetxt(filename,self.getData())\n return\n elif ((shape[0] == 1 and shape[1] == 1) or\n (shape[0] == 1 and shape[2] == 1) or\n (shape[1] == 1 and shape[2] == 1)):\n np.savetxt(filename,self.getData())\n return\n for i in xrange(nsubint):\n for j in xrange(npol):\n for k in xrange(nchan):\n for l in xrange(nbin):\n output += \"%i %i %i %i %.18e\\n\" % (i,j,k,l,self.data[i,j,k,l])\n\n FILE = open(filename,'w')\n FILE.write(output)\n FILE.close()\n else:\n np.save(filename,self.getData())\n return","def numpy_2_file(narray, file, path=OUTPUT_PATH, sep=',' ):\n file_path = path + file\n narrayc = numpy.copy(narray)\n numpy.place(narrayc,numpy.logical_or(narrayc==-1,narrayc==-2), 2)\n dataset = numpy.copy(narrayc).astype(str)\n numpy.place(dataset,dataset=='2', '*')\n d=numpy.atleast_2d(dataset)\n numpy.savetxt(file_path, d, delimiter=sep, fmt='%s')\n return","def save_arrays_to_npz(data: Union[dict, list], file_path: str):\n arrays = list(data.values()) if isinstance(data, dict) else data\n if not all([isinstance(arrays[i], np.ndarray) for i in range(len(arrays))]):\n raise ValueError(\"Incorrect data arrays\")\n\n if os.path.dirname(file_path):\n os.makedirs(os.path.dirname(file_path), exist_ok=True)\n file_path += \".npz\" if \".npz\" != file_path[-4:] else \"\"\n\n if isinstance(data, dict):\n np.savez(file=file_path, **data)\n else:\n args = {str(i): arrays[i] for i in range(len(arrays))}\n np.savez(file=file_path, **args)","def save_feature(ndarray, feature_name, out_path, x, y, new_labels, filename=None):\n # this is kind-of standard\n filename = filename or FeatureExtractor.get_file_name(x, feature_name)\n np.save(out_path / filename, ndarray)\n new_labels.append([filename, y])\n print('info: {} transformed and saved!'.format(filename))\n return filename","def np_save_bak(file, arr, num_bak=5):\n for i in range(num_bak, 0, -1):\n old = _bak_name(file, i-1)\n if os.path.isfile(old):\n os.rename(old, _bak_name(file, i))\n np.save(file, arr)","def saver(filename = None):\n save(self, filename)","def save_data_to_file(file_name, list_of_product_objects):\r\n try:\r\n objF = open(file_name, \"w\")\r\n for row in list_of_product_objects:\r\n objF.write(str(row[0]) + \",\" + str(row[1]) + \"\\n\")\r\n objF.close()\r\n except IOError:\r\n print(\"Unable to locate file\")","def saveToFile(self, filename: str):\n with open(filename, 'w') as file:\n serialized = self.serialize()\n file.write(json.dumps(serialized, indent=4))\n self.print('saving to ', filename, ' was successful')\n\n self.has_been_modified = False","def save_movies(self, filename):\n out_file = open('{}'.format(filename), 'w')\n for movie in self.movies:\n out_file.write(\"{}\\n\".format(movie))\n out_file.close()","def writeArray(fname,arr):\n fh = open(fname,'w')\n fh.write('%d\\n' % arr.shape[0])\n fh.write('%d\\n' % arr.shape[1])\n for x in range(arr.shape[0]):\n for y in range(arr.shape[1]):\n if arr.dtype == np.complex:\n fh.write('%.7e %.7e\\n' % (arr[x,y].real, arr[x,y].imag))\n else:\n fh.write('%.7e\\n' % (arr[x,y]))\n fh.close()","def save_to_file(cls, list_objs):\n namefile = cls.__name__ + \".json\"\n rep_list = []\n if list_objs is not None and list_objs != []:\n for item in list_objs:\n repre = cls.to_dictionary(item)\n # rep_list.append(cls.to_json_string(repre))\n rep_list.append(repre)\n\n with open(namefile, \"w\", encoding=\"UTF-8\") as f:\n # json.dump(rep_list, f)\n f.write(cls.to_json_string(rep_list))","def write_file(file_name, table):\r\n \r\n savectr=len(table)\r\n try:\r\n with open (file_name, 'wb') as objFile:\r\n pickle.dump(table,objFile) #pickle my 2D list\r\n print ('{} CD(s) saved into {}.\\n'.format(savectr,file_name))\r\n except PermissionError as e:\r\n print('Not enough rights to create/modify ' + file_name + '.') #if unable pickle data due to permission issues\r\n print ()\r\n print (e, e.__doc__, sep='\\n')\r\n print ()\r\n except IOError as e:\r\n print ('I/O error({0}): {1}'.format(e.errno,e.strerror))#if unable to pickle data due to IO errors such as disk space issues\r\n print ()\r\n print (e, e.__doc__, sep='\\n')\r\n print ()\r\n except pickle.PickleError as e:\r\n print ('Unable to write data into ' + file_name + '.') #if unable to pickle 2D list, exception handling for pickling errors\r\n print ()\r\n print (e, e.__doc__, sep='\\n')\r\n print ()","def save_to_file(cls, list_objs):\n filename = cls.__name__ + \".json\"\n new_list = []\n with open(filename, \"w\") as fp:\n if list_objs is None:\n fp.write(\"[]\")\n else:\n for objs in list_objs:\n new_list.append(cls.to_dictionary(objs))\n fp.write(cls.to_json_string(new_list))","def save(self, filename):\n content = self.to_dict()\n with open(filename, 'w') as f:\n json.dump(content, f)","def save(self):\n\n if (self._save != '0'):\n p = self._save+self._path[-3:-1]+'_'+str(self._qn)+'.dat'\n np.savetxt(p, self._gf)\n else:\n sys.exit(\"Wrong path to save\")","def save_to_file(cls, list_objs):\n filename = cls.__name__\n dictt = []\n if list_objs:\n for i in list_objs:\n dictt.append(cls.to_dictionary(i))\n\n with open(filename + \".json\", \"w\") as myfile:\n myfile.write(cls.to_json_string(dictt))","def save(self, filename):\n with open(filename, 'wb') as f:\n pickle.dump({'wi': self.W_input_to_hidden, 'wo': self.W_hidden_to_output}, f)","def save(self, filename):\n with open(filename, 'w') as f:\n pickle.dump((self.components, self.mean), f)","def write_data_to_file(pos, fps, data_file):\n xs = []\n for x,y in pos:\n xs.append(x)\n with open(data_file,'wb') as f:\n np.save(f,pos)\n np.save(f,xs)\n np.save(f,fps)","def save_data(filename, data):\n logger.info('Writing data into file')\n with open(filename, 'w', encoding='utf-8') as f:\n json.dump(data, f, ensure_ascii=False, indent=JSON_INDENT)\n\n logger.info('Done writing data into file')"],"string":"[\n \"def quick_save_array(data, file_name, delimiter=',', ):\\n data.tofile(file_name, sep=delimiter)\",\n \"def write_csv_file(array, filename):\\n\\tnp.savetxt(filename, array, delimiter=\\\",\\\")\",\n \"def save_array(self, name: str, array: np.ndarray):\\r\\n np.savetxt(self._path_for_csv(name), array, delimiter=\\\",\\\")\",\n \"def save(self, filename):\\n\\t\\tnp.savetxt(filename, self.V)\\n\\t\\treturn\",\n \"def save2file(lis, path):\\r\\n np.save(path, np.array(lis))\",\n \"def save(self, path_to_save):\\n for item in self.data_array:\\n item.save(path_to_save+item.file_name)\",\n \"def save(file, arr, allow_pickle=True, fix_imports=True):\\n\\n return numpy.save(file, array_create.array(arr, bohrium=False), allow_pickle, fix_imports)\",\n \"def save_to_file(samps, filename, save_as_numpy):\\n with open(filename, 'wb') as out_file:\\n if save_as_numpy:\\n np.save(out_file, samps, allow_pickle=False, fix_imports=False)\\n else:\\n samps.tofile(out_file)\",\n \"def save(self, filename):\\n pass\",\n \"def store(self, filename):\",\n \"def save_to_array(arr_name, arr_object):\\n return np.save(arr_name, arr_object)\",\n \"def save(self, filename):\\n np.savetxt(\\n filename,\\n np.array([np.array(list(e)) for e in self]),\\n fmt=\\\"%.03f\\\",\\n delimiter=\\\"\\\\t\\\",\\n )\",\n \"def pickle(array, file):\\r\\n\\timport cPickle\\r\\n\\tfo = open(file,'wb')\\r\\n\\tcPickle.dump(array,fo)\\r\\n\\tfo.close()\",\n \"def store(obj, filename, suffix = ''):\\n # It is a numpy array\\n if type(obj) == np.ndarray:\\n path,f = writefile(filename, obj_id='numpy_objs', suffix=suffix)\\n json.dump(obj, fp=f, cls=NumpyEncoder,\\n separators=(',', ':'), sort_keys=True, indent=4)\\n print '> saved with JSON to {}'.format(path)\\n else:\\n path, f = writefile(filename, obj_id='other_objs', suffix=suffix)\\n pickle.dump(obj, file=f)\\n print '> saved with dill (pickled) to {}'.format(path)\\n return path\",\n \"def save(self, filename = 'array_zest', path = '/home/eric/dev/insitu/data/zs_recovery/'):\\n filename = filename# + '_Lx_' + str(self.Lx) + 'm_Ly_' + str(self.Ly) + 'm'\\n self.path_filename = path + filename + '.pkl'\\n f = open(self.path_filename, 'wb')\\n pickle.dump(self.__dict__, f, 2)\\n f.close()\",\n \"def write_output(arr, filename):\\n print('Started writing the output..')\\n f = open(filename, 'w')\\n for a in arr:\\n f.write(str(a) + '\\\\n')\\n f.close()\\n print('Done!, Open the file to see the approved loans.')\",\n \"def save_lists_to_file(filename, elev_list, dist_list):\\n import numpy as np\\n\\n np.save(file=filename,arr=np.array([elev_list, dist_list]))\",\n \"def save_file(self, filename):\\n if self.t3data:\\n np.savetxt(filename, self.t3data)\\n else:\\n self.export_to_ascii()\",\n \"def save_data(data, filename, save_path):\\n if not os.path.exists(save_path):\\n os.mkdir(save_path)\\n np.save(os.path.join(save_path, filename), data)\",\n \"def array_to_file(filename, a):\\n a = normalize_array(a)\\n i = Image.fromarray(a.astype('uint8'))\\n return i.save(filename)\",\n \"def save(self, filename):\\n \\n raise NotImplementedError(\\\"not implemented!\\\")\",\n \"def save(self, filename):\\n np.savez(temp_dir + '/' + filename + '.npz', chip_ids=self.chip_ids, core_ids=self.core_ids, cx_ids=self.cx_ids)\",\n \"def save_array_as(arr, loc=None):\\n if loc is None:\\n root = tk.Tk()\\n root.loc = filedialog.asksaveasfilename(initialdir=\\\"/\\\",\\n title=\\\"Save as\\\",\\n filetypes=((\\\"npy files\\\", \\\"*.npy\\\"),\\n (\\\"all files\\\", \\\"*.*\\\"))\\n )\\n np.save(root.loc, arr)\\n root.destroy()\\n else:\\n np.save(loc, arr)\",\n \"def save(data, filename):\\r\\n with open(filename, 'wb') as fp:\\r\\n pickle.dump(data, fp)\",\n \"def save(self, path_to_save):\\n data_to_save = []\\n for item in self.data_array:\\n if isinstance(item, Result):\\n data_to_save.append(item.get())\\n\\n np.savetxt(path_to_save+'.txt', data_to_save, fmt='%5s', delimiter=',')\",\n \"def save(self, filename=\\\"\\\"):\\n if len(filename) == 0:\\n filename = self.filename\\n self.quotes_list.save(filename)\",\n \"def save_npy(self, array: np.ndarray, name: str):\\n tf.gfile.MkDir(str(self.info.npy_path))\\n file_name = name + \\\".npy\\\"\\n np.save(str(self.info.npy_path / file_name), array)\",\n \"def save(self, filename):\\n pass\",\n \"def writeList2File(filename, array, overwrite=False, separator=';'):\\n mode = 'a'\\n if overwrite:\\n mode = 'w'\\n file = open(filename, mode)\\n file.write(separator.join(map(str,array)) + '\\\\n')\",\n \"def save(self, filename):\\n np.savez(temp_dir + '/' + filename + '.npz', core_ids=self.core_ids, cx_ids=self.cx_ids)\",\n \"def output_file(newarray, filename):\\n np.savetxt(filename + \\\"_formatted.txt\\\", newarray, delimiter=\\\" \\\", fmt=\\\"%s\\\")\",\n \"def save_file(data, filename):\\n with open(filename, \\\"w\\\") as outfile:\\n json.dump(data, outfile)\",\n \"def save(self, filename):\\n raise NotImplementedError\",\n \"def save_dataset_as_numpy(dataloader, file_path, key=\\\"original\\\", message=\\\"\\\"):\\n\\n print(message)\\n array_to_save = compose_array_from_dataloader(dataloader, key=key)\\n with open(file_path, \\\"wb\\\") as file:\\n np.save(file, array_to_save)\",\n \"def dataToJson(self,dataArray, filename):\\n try:\\n jsondata = simplejson.dumps(dataArray, indent=4, skipkeys=True, sort_keys=True)\\n fd = open(\\\"./data/\\\" + filename, 'w')\\n fd.write(jsondata)\\n fd.close()\\n print (\\\"data written to the file succesfully\\\")\\n except:\\n print ('ERROR writing', filename)\\n pass\",\n \"def save_to_file(filename: str, sequence: List[Sample]):\\n\\n with open(get_path() + \\\"/sequence/\\\" + filename, \\\"ab+\\\") as file:\\n for sample in sequence:\\n pickle.dump(sample, file, pickle.HIGHEST_PROTOCOL)\",\n \"def outputPulses(self,filename):\\n np.save(filename,self.getData())\\n return\",\n \"def save(self, filename):\\n data = {\\\"sizes\\\": self.sizes,\\n \\\"weights\\\": [w.tolist() for w in self.weights],\\n \\\"biases\\\": [b.tolist() for b in self.biases]}\\n f = open(filename, \\\"w\\\")\\n json.dump(data, f)\\n f.close()\",\n \"def savealist(alist, filename):\\n out = open(filename, \\\"w\\\")\\n for i in alist:\\n out.write(str(i) + \\\"\\\\n\\\") # if i is numeric\\n out.close()\",\n \"def savefile(filename, data):\\n with open(filename, \\\"w\\\", encoding=\\\"utf-8\\\") as file:\\n output = dumps(data, ensure_ascii=False, sort_keys=True, indent=2)\\n file.write(output)\",\n \"def save_to_array(x, y):\\n\\n with open(settings.data(\\\"x.npy\\\"), \\\"wb\\\") as file:\\n np.save(file, x)\\n\\n with open(settings.data(\\\"y.npy\\\"), \\\"wb\\\") as file:\\n np.save(file, y)\",\n \"def save(self, filename, type='CSV'):\\n # Convenient form for saving:\\n save = np.ndarray(shape=(self.Pbrem.shape[0]+1, self.Pbrem.shape[1]), dtype=np.float)\\n save[0,:] = self.time\\n save[1:,:] = self.Pbrem\\n\\n if type == 'CSV':\\n with open(filename, 'wb') as file:\\n np.savetxt(file, save, delimiter=',', header='Time,Total,Fuel,Shell\\\\n')\\n\\n elif type == 'pickle':\\n with open(filename, 'wb') as file:\\n pickle.dump(save, file)\",\n \"def save(self, directory):\\n for field in self.save_fields:\\n np.save(pjoin(directory, field+'.npy'), self.__dict__[field])\",\n \"def save_data(data: typing.List[typing.Dict], filename: str):\\n now = datetime.datetime.now().strftime(\\\"%Y-%m-%d_%H-%M-%S\\\")\\n with open(f\\\"{filename}-{now}.json\\\", \\\"w\\\") as f:\\n f.write(json.dumps(data))\",\n \"def save(data, file, compression=0):\\n f = file if isinstance(file, bob.io.base.HDF5File) else bob.io.base.HDF5File(file, 'w')\\n if hasattr(data, 'save'):\\n data.save(f)\\n else:\\n f.set(\\\"array\\\", data, compression=compression)\",\n \"def save_enu(self, filename):\\n x, y, z = self.get_coords_enu()\\n coords = np.vstack([x, y, z]).T\\n np.savetxt(filename, coords, fmt=b'%.12e')\",\n \"def save(self, filename):\\n Util.savePickle(self.V, filename + self.ext, overwrite=True)\\n return filename + self.ext\",\n \"def dump_npy(filename: str, obj, **kwargs):\\n return np.save(filename, obj)\",\n \"def save(self, fname):\\n pass\",\n \"def save_data(self, f): \\n if not self.sampling:\\n self.convert_to_array()\\n np.save(f, self.reads)\",\n \"def save_obsarray_to_pickle(self, obs_array, dest_dir):\\n if not os.path.exists(dest_dir):\\n os.makedirs(dest_dir)\\n dump_array = obs_array\\n pkl_name = 'batch' + str(len(os.listdir(dest_dir)))\\n dump_path = os.path.join(dest_dir, pkl_name)\\n self.pickledump(dump_array, dump_path)\\n return pkl_name\",\n \"def _save(self, data: np.ndarray) -> None:\\n ...\",\n \"def save_arrays_to_folder(arrays, folder_path):\\n # Check if the folder exists and create it if necessary\\n path = Path(folder_path)\\n path.mkdir(parents=True, exist_ok=True)\\n\\n # Loop over the arrays and save them to the folder with numbered filenames\\n for i, arr in enumerate(arrays):\\n filename = f\\\"coords{str(i + 1).zfill(4)}.npy\\\"\\n filepath = path / filename\\n np.save(filepath, arr)\",\n \"def save_list(lines, filename):\\n data = '\\\\n'.join(lines)\\n file = open(filename, 'w')\\n file.write(data)\\n file.close()\",\n \"def ArraytoFile(_array):\\n\\tfile = open('sort1.txt', 'w')\\n\\tfor line in _array:\\n\\t\\tfile.write(line+\\\"\\\\n\\\")\\n\\tfile.close()\",\n \"def save(self, filename):\\n with open(filename, \\\"w\\\") as f:\\n m = {\\n \\\"order\\\": self.order,\\n \\\"pad\\\": self.pad,\\n \\\"records\\\": {str(k): v for k, v in self.records.items()}\\n }\\n json.dump(m, f)\",\n \"def save_array_as_image(arr, filename):\\n arr = arr.copy().clip(0, 255).astype('uint8')\\n im = Image.fromarray(arr)\\n im.save(filename)\",\n \"def savez(file, *args, **kwds):\\n\\n ary_list = []\\n for a in args:\\n ary_list.append(array_create.array(a, bohrium=False))\\n return numpy.savez(file, *ary_list, **kwds)\",\n \"def save_to_file(filename, pairs):\\n logger.info('save to file...')\\n\\n fname = filename + FILE_EXT\\n mode = 'a' if os.path.isfile(fname) else 'w'\\n logger.debug('mode is: ' + mode)\\n\\n with open(fname, mode) as f:\\n for pair in pairs:\\n f.write(format_pair(pair))\",\n \"def save(self, file, name):\\n np.savetxt(os.path.join(file, name), self.matrix, fmt='%f')\",\n \"def save_data(self, filename, coordinates=True):\\n\\n if not coordinates:\\n savetxt(self.wpath+filename, self.dataset, delimiter=',', fmt='%.18e,%.18e,%d,%s')\\n else:\\n print self.wpath+filename\\n savetxt(self.wpath+filename, self.getDataCoordinates(), delimiter=',', fmt='%.18e,%.18e')\",\n \"def save(self, filename):\\n o = open(filename, 'w')\\n o.write(self.write())\\n o.close()\",\n \"def save(self, filename):\\n data = {\\\"sizes\\\": self.sizes,\\n \\\"weights\\\": [w.tolist() for w in self.weights],\\n \\\"biases\\\": [b.tolist() for b in self.biases],\\n \\\"cost\\\": str(self.cost.__name__)}\\n f = open(filename, \\\"w\\\")\\n json.dump(data, f)\\n f.close()\",\n \"def save_as(self, filename):\\n raise NotImplementedError(\\n \\\"Saving ring buffers to other formats is not yet implemented.\\\")\\n\\n if filename[-3:] == 'zip':\\n pass # TODO\\n elif filename[-2:] == 'h5':\\n pass # TODO\\n elif filename[-4:] == 'fits':\\n pass # TODO\\n elif filename[-3:] == 'npz':\\n self.save_as_numpy(filename)\",\n \"def save(self, file):\\n boulders = []\\n elephants = []\\n rhinos = []\\n for i in range(5):\\n for j in range(5):\\n if self[i][j]!= 0:\\n piece = self[i][j]\\n L = []\\n if not isinstance(self[i][j], Boulder):\\n L.append(self[i][j].direction[0])\\n L.append(self[i][j].direction[1])\\n if piece.species == \\\"Elephant\\\":\\n elephants.append(\\\"(\\\" + str(i) + \\\",\\\" + str(j)+ \\\") : np.array([\\\"+str(L[0])+ \\\",\\\" + str(L[1])+\\\"])\\\")\\n elif piece.species == \\\"Rhinoceros\\\":\\n rhinos.append(\\\"(\\\"+str(i)+\\\",\\\" +str(j)+ \\\") : np.array([\\\"+str(L[0]) + \\\",\\\" + str(L[1])+\\\"])\\\")\\n elif isinstance(piece, Boulder):\\n boulders.append(\\\"(\\\" + str(i) + \\\",\\\" + str(j) + \\\")\\\")\\n file.write(\\\"# King of Siam GameFile \\\\n\\\\nplayer_turn {\\\\n \\\" + self.playerTurn + \\\"\\\\n}\\\\n\\\\n\\\")\\n file.write(\\\"Boulder {\\\")\\n for k in range(len(boulders)):\\n file.write(\\\"\\\\n \\\" + boulders[k] + \\\";\\\")\\n file.write(\\\"\\\\n}\\\\n\\\\nElephant {\\\")\\n for elt in elephants:\\n file.write(\\\"\\\\n \\\" + elt + \\\";\\\")\\n file.write(\\\"\\\\n}\\\\n\\\\nRhinoceros {\\\")\\n for elt in rhinos:\\n file.write(\\\"\\\\n \\\" + elt + \\\";\\\")\\n file.write(\\\"\\\\n}\\\")\\n\\n file.close()\",\n \"def toFile(self,fid):\\n stack = []\\n for w,b in self.stack:\\n w.copy_to_host()\\n b.copy_to_host()\\n stack.append([w.numpy_array,b.numpy_array])\\n\\tpickle.dump(stack,fid)\",\n \"def save(filename, mat):\\n if not isinstance(mat, np.ndarray):\\n raise ValueError('for now, we can only save numpy arrays')\\n return sio.savemat(filename, {'data': mat}, appendmat=False)\",\n \"def save(self, filename: str):\\n if os.path.isfile(filename):\\n raise FileExistsError(\\\"Target file exists\\\")\\n\\n with open(filename, \\\"wb\\\") as binary_writer:\\n pickle.dump([self.gene_sets, self.gene_set_size, self.gene_set_names,\\n self.interactors, self.n_curated, self.n_interactors],\\n binary_writer)\",\n \"def save(self, filename):\\n import json\\n\\n json = json.dumps(self.joint_limits)\\n with open(filename, 'w') as f:\\n f.write(json)\",\n \"def save_memory(self, filename):\\n \\n\\n with open(filename + '/obses.npy', 'wb') as f:\\n np.save(f, self.obses)\\n \\n with open(filename + '/actions.npy', 'wb') as f:\\n np.save(f, self.actions)\\n\\n with open(filename + '/next_obses.npy', 'wb') as f:\\n np.save(f, self.next_obses)\\n \\n with open(filename + '/rewards.npy', 'wb') as f:\\n np.save(f, self.rewards)\\n \\n with open(filename + '/not_dones.npy', 'wb') as f:\\n np.save(f, self.not_dones)\\n \\n with open(filename + '/not_dones_no_max.npy', 'wb') as f:\\n np.save(f, self.not_dones_no_max)\\n\\n with open(filename + '/index.txt', 'w') as f:\\n f.write(\\\"{}\\\".format(self.idx))\\n\\n print(\\\"save buffer to {}\\\".format(filename))\",\n \"def on_save_arrays_action(self):\\n if self.mesh:\\n name = QFileDialog.getSaveFileName(self.parent(), filter=\\\"*.cfma\\\")\\n if name != ('', ''):\\n mesh = self.mesh\\n mesh.return_boundary_elements = True\\n coords, edof, dofs, bdofs, elementmarkers, boundary_elements = mesh.create()\\n cfu.save_arrays(coords, edof, dofs, bdofs, elementmarkers, boundary_elements, self.marker_dict,\\n name[0])\",\n \"def save(self, filename):\\n pickle.dump(self, open(filename + '.p', 'wb'), 2)\",\n \"def save_data(data, filename='data.txt'):\\n with open(filename, 'w', encoding=\\\"utf-8\\\") as file:\\n for item in data:\\n print(item, file=file)\",\n \"def dump(filename, data):\\n _savez(filename, [], data, True, allow_pickle=False)\",\n \"def save_to_file(cls, list_objs):\\n filename = cls.__name__ + \\\".json\\\"\\n with open(filename, \\\"w\\\") as f:\\n if list_objs is None:\\n f.write(\\\"[]\\\")\\n else:\\n d = [x.to_dictionary() for x in list_objs]\\n f.write(Base.to_json_string(d))\",\n \"def _write_files_(self, arrs, filepath):\\n\\t\\t# If there's a dot in the filepath prepend the filepath\\n\\t\\tif '.' in filepath:\\n\\t\\t\\tfilename, ext = gen_io.remove_file_extension(filepath)\\n\\t\\t\\tarrs = {f\\\"{filename}_{key}.{ext}\\\": arrs[key] for key in arrs}\\n\\t\\t\\tprint(arrs.keys())\\n\\t\\t\\n\\t\\t# Else just assume it's a folder\\n\\t\\telse:\\n\\t\\t\\tif not os.path.isdir(filepath):\\n\\t\\t\\t\\tos.makedirs(filepath)\\n\\n\\t\\t\\tarrs = {f\\\"{filepath}/{key}.npy\\\": arrs[key] for key in arrs}\\n\\n\\t\\t# Now write the files.\\n\\t\\tfor key in arrs:\\n\\t\\t\\tfilepath = gen_io.create_unique_filepath(key)\\n\\t\\t\\tnp.save(key, arrs[key])\",\n \"def save_data(data, file_name):\\r\\n file = open(file_name, \\\"w\\\")\\r\\n file.write(data + \\\"\\\\n\\\")\\r\\n file.close()\",\n \"def saveFile(self, filename=\\\"UQModelTest.json\\\"):\\n sd = self.saveDict()\\n with open(filename, \\\"w\\\") as f:\\n json.dump(sd, f, indent=2)\",\n \"def store (input, filename) :\\n cout = open (filename, 'w')\\n pickle.dump (input, cout)\\n cout.close ()\",\n \"def save_data(data, filename=None):\\n filename = filename or OUTPUT_FILE\\n common.open_and_write_file(filename, data, as_json=True)\\n print(\\\"Saved file: {}.\\\".format(filename))\",\n \"def saveData(self,filename=None,ext='npy',ascii=False):\\n if filename is None:\\n filename = self.filename\\n filename = \\\".\\\".join(filename.split(\\\".\\\")[:-1])+\\\".\\\"+ext\\n if self.verbose:\\n print(\\\"Saving: %s\\\" % filename)\\n if ascii:\\n shape = self.shape(squeeze=False)\\n nsubint = self.getNsubint()\\n npol = self.getNpol()\\n nchan = self.getNchan()\\n nbin = self.getNbin()\\n output = \\\"\\\"\\n if shape[0] == 1 and shape[1] == 1 and shape[2] == 1:\\n np.savetxt(filename,self.getData())\\n return\\n elif ((shape[0] == 1 and shape[1] == 1) or\\n (shape[0] == 1 and shape[2] == 1) or\\n (shape[1] == 1 and shape[2] == 1)):\\n np.savetxt(filename,self.getData())\\n return\\n for i in xrange(nsubint):\\n for j in xrange(npol):\\n for k in xrange(nchan):\\n for l in xrange(nbin):\\n output += \\\"%i %i %i %i %.18e\\\\n\\\" % (i,j,k,l,self.data[i,j,k,l])\\n\\n FILE = open(filename,'w')\\n FILE.write(output)\\n FILE.close()\\n else:\\n np.save(filename,self.getData())\\n return\",\n \"def numpy_2_file(narray, file, path=OUTPUT_PATH, sep=',' ):\\n file_path = path + file\\n narrayc = numpy.copy(narray)\\n numpy.place(narrayc,numpy.logical_or(narrayc==-1,narrayc==-2), 2)\\n dataset = numpy.copy(narrayc).astype(str)\\n numpy.place(dataset,dataset=='2', '*')\\n d=numpy.atleast_2d(dataset)\\n numpy.savetxt(file_path, d, delimiter=sep, fmt='%s')\\n return\",\n \"def save_arrays_to_npz(data: Union[dict, list], file_path: str):\\n arrays = list(data.values()) if isinstance(data, dict) else data\\n if not all([isinstance(arrays[i], np.ndarray) for i in range(len(arrays))]):\\n raise ValueError(\\\"Incorrect data arrays\\\")\\n\\n if os.path.dirname(file_path):\\n os.makedirs(os.path.dirname(file_path), exist_ok=True)\\n file_path += \\\".npz\\\" if \\\".npz\\\" != file_path[-4:] else \\\"\\\"\\n\\n if isinstance(data, dict):\\n np.savez(file=file_path, **data)\\n else:\\n args = {str(i): arrays[i] for i in range(len(arrays))}\\n np.savez(file=file_path, **args)\",\n \"def save_feature(ndarray, feature_name, out_path, x, y, new_labels, filename=None):\\n # this is kind-of standard\\n filename = filename or FeatureExtractor.get_file_name(x, feature_name)\\n np.save(out_path / filename, ndarray)\\n new_labels.append([filename, y])\\n print('info: {} transformed and saved!'.format(filename))\\n return filename\",\n \"def np_save_bak(file, arr, num_bak=5):\\n for i in range(num_bak, 0, -1):\\n old = _bak_name(file, i-1)\\n if os.path.isfile(old):\\n os.rename(old, _bak_name(file, i))\\n np.save(file, arr)\",\n \"def saver(filename = None):\\n save(self, filename)\",\n \"def save_data_to_file(file_name, list_of_product_objects):\\r\\n try:\\r\\n objF = open(file_name, \\\"w\\\")\\r\\n for row in list_of_product_objects:\\r\\n objF.write(str(row[0]) + \\\",\\\" + str(row[1]) + \\\"\\\\n\\\")\\r\\n objF.close()\\r\\n except IOError:\\r\\n print(\\\"Unable to locate file\\\")\",\n \"def saveToFile(self, filename: str):\\n with open(filename, 'w') as file:\\n serialized = self.serialize()\\n file.write(json.dumps(serialized, indent=4))\\n self.print('saving to ', filename, ' was successful')\\n\\n self.has_been_modified = False\",\n \"def save_movies(self, filename):\\n out_file = open('{}'.format(filename), 'w')\\n for movie in self.movies:\\n out_file.write(\\\"{}\\\\n\\\".format(movie))\\n out_file.close()\",\n \"def writeArray(fname,arr):\\n fh = open(fname,'w')\\n fh.write('%d\\\\n' % arr.shape[0])\\n fh.write('%d\\\\n' % arr.shape[1])\\n for x in range(arr.shape[0]):\\n for y in range(arr.shape[1]):\\n if arr.dtype == np.complex:\\n fh.write('%.7e %.7e\\\\n' % (arr[x,y].real, arr[x,y].imag))\\n else:\\n fh.write('%.7e\\\\n' % (arr[x,y]))\\n fh.close()\",\n \"def save_to_file(cls, list_objs):\\n namefile = cls.__name__ + \\\".json\\\"\\n rep_list = []\\n if list_objs is not None and list_objs != []:\\n for item in list_objs:\\n repre = cls.to_dictionary(item)\\n # rep_list.append(cls.to_json_string(repre))\\n rep_list.append(repre)\\n\\n with open(namefile, \\\"w\\\", encoding=\\\"UTF-8\\\") as f:\\n # json.dump(rep_list, f)\\n f.write(cls.to_json_string(rep_list))\",\n \"def write_file(file_name, table):\\r\\n \\r\\n savectr=len(table)\\r\\n try:\\r\\n with open (file_name, 'wb') as objFile:\\r\\n pickle.dump(table,objFile) #pickle my 2D list\\r\\n print ('{} CD(s) saved into {}.\\\\n'.format(savectr,file_name))\\r\\n except PermissionError as e:\\r\\n print('Not enough rights to create/modify ' + file_name + '.') #if unable pickle data due to permission issues\\r\\n print ()\\r\\n print (e, e.__doc__, sep='\\\\n')\\r\\n print ()\\r\\n except IOError as e:\\r\\n print ('I/O error({0}): {1}'.format(e.errno,e.strerror))#if unable to pickle data due to IO errors such as disk space issues\\r\\n print ()\\r\\n print (e, e.__doc__, sep='\\\\n')\\r\\n print ()\\r\\n except pickle.PickleError as e:\\r\\n print ('Unable to write data into ' + file_name + '.') #if unable to pickle 2D list, exception handling for pickling errors\\r\\n print ()\\r\\n print (e, e.__doc__, sep='\\\\n')\\r\\n print ()\",\n \"def save_to_file(cls, list_objs):\\n filename = cls.__name__ + \\\".json\\\"\\n new_list = []\\n with open(filename, \\\"w\\\") as fp:\\n if list_objs is None:\\n fp.write(\\\"[]\\\")\\n else:\\n for objs in list_objs:\\n new_list.append(cls.to_dictionary(objs))\\n fp.write(cls.to_json_string(new_list))\",\n \"def save(self, filename):\\n content = self.to_dict()\\n with open(filename, 'w') as f:\\n json.dump(content, f)\",\n \"def save(self):\\n\\n if (self._save != '0'):\\n p = self._save+self._path[-3:-1]+'_'+str(self._qn)+'.dat'\\n np.savetxt(p, self._gf)\\n else:\\n sys.exit(\\\"Wrong path to save\\\")\",\n \"def save_to_file(cls, list_objs):\\n filename = cls.__name__\\n dictt = []\\n if list_objs:\\n for i in list_objs:\\n dictt.append(cls.to_dictionary(i))\\n\\n with open(filename + \\\".json\\\", \\\"w\\\") as myfile:\\n myfile.write(cls.to_json_string(dictt))\",\n \"def save(self, filename):\\n with open(filename, 'wb') as f:\\n pickle.dump({'wi': self.W_input_to_hidden, 'wo': self.W_hidden_to_output}, f)\",\n \"def save(self, filename):\\n with open(filename, 'w') as f:\\n pickle.dump((self.components, self.mean), f)\",\n \"def write_data_to_file(pos, fps, data_file):\\n xs = []\\n for x,y in pos:\\n xs.append(x)\\n with open(data_file,'wb') as f:\\n np.save(f,pos)\\n np.save(f,xs)\\n np.save(f,fps)\",\n \"def save_data(filename, data):\\n logger.info('Writing data into file')\\n with open(filename, 'w', encoding='utf-8') as f:\\n json.dump(data, f, ensure_ascii=False, indent=JSON_INDENT)\\n\\n logger.info('Done writing data into file')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75969416","0.7330002","0.7201176","0.71752346","0.7159063","0.7140122","0.71392435","0.7069632","0.6940411","0.6934702","0.69181776","0.68739957","0.6849441","0.68114215","0.67789257","0.67586243","0.67484975","0.67466575","0.6678462","0.66758204","0.6666971","0.66615415","0.663058","0.6612493","0.66118413","0.66034853","0.6593461","0.65862054","0.6578503","0.65640503","0.6560784","0.65605307","0.6560157","0.6499433","0.6478611","0.64593345","0.6425132","0.6418833","0.6416603","0.64019364","0.64015603","0.63852453","0.6369427","0.636831","0.6360032","0.6358974","0.6328848","0.63283414","0.6315534","0.63132846","0.63057303","0.62968993","0.6289891","0.62877077","0.62772614","0.6276733","0.6276003","0.6271263","0.6262994","0.62466455","0.62372017","0.6230055","0.6221145","0.6211697","0.62044144","0.62005115","0.6192208","0.61912936","0.6186662","0.6184505","0.61839527","0.6179517","0.6168148","0.61657214","0.61642826","0.61544967","0.6152703","0.6150956","0.6142945","0.6136421","0.61337906","0.6132921","0.6132242","0.6129742","0.6124141","0.61227566","0.61171085","0.61142206","0.6113356","0.6110779","0.6101179","0.6094653","0.6090042","0.60835284","0.6082812","0.6080786","0.6067607","0.60651374","0.6057228","0.6052912"],"string":"[\n \"0.75969416\",\n \"0.7330002\",\n \"0.7201176\",\n \"0.71752346\",\n \"0.7159063\",\n \"0.7140122\",\n \"0.71392435\",\n \"0.7069632\",\n \"0.6940411\",\n \"0.6934702\",\n \"0.69181776\",\n \"0.68739957\",\n \"0.6849441\",\n \"0.68114215\",\n \"0.67789257\",\n \"0.67586243\",\n \"0.67484975\",\n \"0.67466575\",\n \"0.6678462\",\n \"0.66758204\",\n \"0.6666971\",\n \"0.66615415\",\n \"0.663058\",\n \"0.6612493\",\n \"0.66118413\",\n \"0.66034853\",\n \"0.6593461\",\n \"0.65862054\",\n \"0.6578503\",\n \"0.65640503\",\n \"0.6560784\",\n \"0.65605307\",\n \"0.6560157\",\n \"0.6499433\",\n \"0.6478611\",\n \"0.64593345\",\n \"0.6425132\",\n \"0.6418833\",\n \"0.6416603\",\n \"0.64019364\",\n \"0.64015603\",\n \"0.63852453\",\n \"0.6369427\",\n \"0.636831\",\n \"0.6360032\",\n \"0.6358974\",\n \"0.6328848\",\n \"0.63283414\",\n \"0.6315534\",\n \"0.63132846\",\n \"0.63057303\",\n \"0.62968993\",\n \"0.6289891\",\n \"0.62877077\",\n \"0.62772614\",\n \"0.6276733\",\n \"0.6276003\",\n \"0.6271263\",\n \"0.6262994\",\n \"0.62466455\",\n \"0.62372017\",\n \"0.6230055\",\n \"0.6221145\",\n \"0.6211697\",\n \"0.62044144\",\n \"0.62005115\",\n \"0.6192208\",\n \"0.61912936\",\n \"0.6186662\",\n \"0.6184505\",\n \"0.61839527\",\n \"0.6179517\",\n \"0.6168148\",\n \"0.61657214\",\n \"0.61642826\",\n \"0.61544967\",\n \"0.6152703\",\n \"0.6150956\",\n \"0.6142945\",\n \"0.6136421\",\n \"0.61337906\",\n \"0.6132921\",\n \"0.6132242\",\n \"0.6129742\",\n \"0.6124141\",\n \"0.61227566\",\n \"0.61171085\",\n \"0.61142206\",\n \"0.6113356\",\n \"0.6110779\",\n \"0.6101179\",\n \"0.6094653\",\n \"0.6090042\",\n \"0.60835284\",\n \"0.6082812\",\n \"0.6080786\",\n \"0.6067607\",\n \"0.60651374\",\n \"0.6057228\",\n \"0.6052912\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8585977"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":831,"numItemsPerPage":100,"numTotalItems":95772,"offset":83100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjA3NzMxMCwianRpIjoiYjM2NzY3YjctZjY5YS00ODE0LWEwZDQtMzkzMjBlZDllYzdhIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwODA5MTAsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.EhrsfEqW-ZNxWhgC97k-PGx9ZqIVl6F2RTLpa9Uf7xJIrkPH7JfWP5IEGrq-g-6JOQINt7sWYYtAfxFFXpbEBw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Overrides the superclass is_executable. | def is_executable(self, path):
if (CGIHTTPServer.CGIHTTPRequestHandler.is_executable(self, path)):
return True
if self.is_python(path):
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_executable(self):\n raise NotImplementedError()",
"def supports_sys_executable(self):\n return bool(getattr(sys, \"executable\", None))",
"def is_executable(exe):\n return os.path.isfile(exe) and os.access(exe, os.X_OK)",
"def is_executable(path):\n return (os.path.exists(path)... | [
"0.8627345",
"0.752851",
"0.7447119",
"0.73333514",
"0.72728646",
"0.7150464",
"0.7150464",
"0.7135183",
"0.7128636",
"0.7040618",
"0.69863826",
"0.6962569",
"0.6943312",
"0.6934778",
"0.6912176",
"0.6887747",
"0.6695774",
"0.66032755",
"0.64987844",
"0.64442396",
"0.64369684... | 0.7610795 | 1 |
Return True if the superclass thinks its true, or if the path ends with .cgi | def is_python(self, path):
if (CGIHTTPServer.CGIHTTPRequestHandler.is_python(self, path)):
return True
if path.endswith(".cgi"):
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def path_is_base(self, path):\n\n return path is not None and len(path) == len(self.levels)",
"def _has_extension(self, path):\r\n if re.match(r'.*\\\\.*\\..*$', path):\r\n return True",
"def is_executable(self, path):\n if (CGIHTTPServer.CGIHTTPRequestHandler.is_executable(self, path)):\... | [
"0.59074575",
"0.5889889",
"0.5860048",
"0.58529234",
"0.5796067",
"0.57866293",
"0.57298136",
"0.5704744",
"0.56834686",
"0.5630984",
"0.55862296",
"0.5585162",
"0.5582354",
"0.5515081",
"0.5491662",
"0.5480578",
"0.5480194",
"0.5464567",
"0.54597604",
"0.5437157",
"0.543539... | 0.750505 | 0 |
test helper function for fetching local configs | def test_local_filepath_helper():
expected_local_filepath = TEST_LOCAL_CONFIG_PATH.replace('.cfg', '_local.cfg')
assert wf_utils.get_local_config_filepath(TEST_LOCAL_CONFIG_PATH) == TEST_LOCAL_CONFIG_PATH
assert wf_utils.get_local_config_filepath(TEST_LOCAL_CONFIG_PATH, True) == expected_local_filepath | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testGetConfig():\n configs = GetConfig()\n # print(configs.host_ip)\n # print(configs.proxy_local)\n \n # print(configs.proxy_online)\n # print(configs.user_img_url)\n # print(configs.user_login_url)\n print(configs.user_start_id)\n\n # assert isinstance(configs.proxy_getter_function... | [
"0.7022754",
"0.70146805",
"0.6905032",
"0.66916466",
"0.6684307",
"0.6653523",
"0.6568741",
"0.6543096",
"0.6520464",
"0.6519033",
"0.6509252",
"0.65080345",
"0.6457225",
"0.644575",
"0.6426769",
"0.64229554",
"0.6385807",
"0.63645416",
"0.6356513",
"0.63371557",
"0.63315684... | 0.67167866 | 3 |
Helper for executing logging same way for every test | def helper_log_messages(
logger,
log_capture_override=None,
):
with LogCapture(log_capture_override) as log_tracker:
logger.debug( LOG_MESSAGE + ' --DEBUG--')
logger.info( LOG_MESSAGE + ' --INFO--')
logger.warning( LOG_MESSAGE + ' --WARNING--')
logger.error( LO... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_logging(self):\n self._verify_logging()",
"def test(self):\n self.info(\"LOGGING: Testing log messages\")\n self.debug(\"This is a debugging message\")\n self.info(\"This is an informational message\")\n self.warning(\"This is a warning message\")\n self.error(\"Thi... | [
"0.7609698",
"0.7608522",
"0.7364038",
"0.7246294",
"0.7151149",
"0.7146603",
"0.70105374",
"0.6938734",
"0.69043374",
"0.68828154",
"0.6789341",
"0.6774802",
"0.6653296",
"0.66417444",
"0.6638516",
"0.66313976",
"0.66088593",
"0.6594909",
"0.6579426",
"0.65746903",
"0.657339... | 0.0 | -1 |
ECHO test for GET utility | def test_GET_fetcher():
params = {
'key1':'value1',
'arg2':'value2'
}
## test that request goes ok
resp = wf_utils.fetch_GET_request(
GET_ECHO_ENDPOINT,
params=params
)
## test that response json can be parsed
payload = resp.json()
## test that response... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def http_method_get():\n return 'GET'",
"def test_get(self):\n return self.doRequest(self.url, method=\"GET\", body=self.input)",
"def test_two_legged_get(self):\n resp, content = self._two_legged(\"GET\")\n self.assertEqual(int(resp['status']), 200)",
"def do_GET(self):\n self... | [
"0.6335031",
"0.6297777",
"0.61926717",
"0.6133453",
"0.6042478",
"0.59543127",
"0.59261894",
"0.59216285",
"0.5915813",
"0.5840221",
"0.5785862",
"0.5777845",
"0.5771906",
"0.57426494",
"0.5737699",
"0.5737379",
"0.5717399",
"0.569291",
"0.5655878",
"0.56524754",
"0.5612279"... | 0.6358074 | 0 |
excercize exceptions for GET utility | def test_GET_fetcher_fail():
bad_url = GET_ECHO_ENDPOINT.replace('.com', '.comx')
with pytest.raises(Exception): #TODO: specific exception?
resp = wf_utils.fetch_GET_request(bad_url)
#TODO: bad status code tests? | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _raise_http_error(self, *args, **kwargs):",
"def renderHTTP_exception(request, failure):",
"def _processGETErr(self, e, request):\r\n if e.check(InvalidRequest):\r\n msg = e.getErrorMessage()\r\n code = httplib.BAD_REQUEST\r\n elif e.check(UnauthorizedLogin):\r\n ... | [
"0.7084887",
"0.670926",
"0.66761374",
"0.66172314",
"0.6597244",
"0.65530616",
"0.65018415",
"0.6414881",
"0.6392359",
"0.63863003",
"0.63461536",
"0.6288013",
"0.62814754",
"0.62624824",
"0.62461483",
"0.62334555",
"0.6221849",
"0.62089056",
"0.6208572",
"0.62047553",
"0.61... | 0.6589292 | 5 |
ECHO test for GET utility | def test_POST_fetcher():
params = {
'key1':'value1',
'arg2':'value2'
}
data = {
'data1':'value1',
'data2':'morevalues'
}
## test that request goes ok
resp = wf_utils.fetch_POST_request(
POST_ECHO_ENDPOINT,
data,
params=params
)
##... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_GET_fetcher():\n params = {\n 'key1':'value1',\n 'arg2':'value2'\n }\n\n ## test that request goes ok\n resp = wf_utils.fetch_GET_request(\n GET_ECHO_ENDPOINT,\n params=params\n )\n\n ## test that response json can be parsed\n payload = resp.json()\n\n #... | [
"0.635816",
"0.63344365",
"0.6297723",
"0.61925864",
"0.6132596",
"0.6042227",
"0.59541154",
"0.5926037",
"0.59210306",
"0.59149337",
"0.5840348",
"0.57859087",
"0.57776403",
"0.57710594",
"0.57406265",
"0.57371694",
"0.57368046",
"0.5716191",
"0.5692497",
"0.5655314",
"0.565... | 0.0 | -1 |
excercize exceptions for GET utility | def test_POST_fetcher_fail():
bad_url = POST_ECHO_ENDPOINT.replace('.com', '.comx')
with pytest.raises(Exception): #TODO: specific exception?
resp = wf_utils.fetch_GET_request(bad_url)
#TODO: bad status code tests? | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _raise_http_error(self, *args, **kwargs):",
"def renderHTTP_exception(request, failure):",
"def _processGETErr(self, e, request):\r\n if e.check(InvalidRequest):\r\n msg = e.getErrorMessage()\r\n code = httplib.BAD_REQUEST\r\n elif e.check(UnauthorizedLogin):\r\n ... | [
"0.7084606",
"0.67075837",
"0.6675742",
"0.6616683",
"0.6596937",
"0.6589133",
"0.65520126",
"0.6501619",
"0.64153564",
"0.639142",
"0.63846123",
"0.6344829",
"0.62878734",
"0.62821543",
"0.626283",
"0.624501",
"0.6233241",
"0.6222646",
"0.6208485",
"0.6207755",
"0.6203567",
... | 0.59165287 | 59 |
Flag which documents are outliers based on zscore bigger than threshold. | def flag_outliers_in_col(self, df, col='paciente_idade', threshold=2):
data = df[col]
mean = np.mean(data)
std = np.std(data)
outlier = []
for i in data:
z = (i-mean)/std
outlier.append(z > threshold)
outlier = pd.Series(outlier)
print(f"Nu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_outlier(points, thresh=12):\n if len(points.shape) == 1:\n points = points[:,None]\n median = np.median(points, axis=0)\n diff = np.sum((points - median)**2, axis=-1)\n diff = np.sqrt(diff)\n med_abs_deviation = np.median(diff)\n\n modified_z_score = 0.6745 * diff / med_abs_deviatio... | [
"0.7033957",
"0.70032877",
"0.69774777",
"0.6887256",
"0.67809063",
"0.67686844",
"0.6646577",
"0.6607504",
"0.634495",
"0.62447006",
"0.62070817",
"0.61879426",
"0.6169662",
"0.6151862",
"0.61027694",
"0.6080594",
"0.60602206",
"0.60370225",
"0.6009786",
"0.5998541",
"0.5987... | 0.62983334 | 9 |
Filter outliers based on flag pd.Series. | def filter_outliers(self, df, outlier):
return df[~outlier].reset_index(drop=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_outliers(data: pd.Series, std: int=3) -> pd.Series:\n return data[(data - data.mean()).abs() <= (std * data.std())]",
"def filter_outliers(data): \n \n idx_out = find_outliers_IQR(data)\n \n cleaned = data[~idx_out].copy()\n\n # print(f'There were {idx_out.sum()} outliers.')\n ... | [
"0.72473335",
"0.7129621",
"0.6909567",
"0.686517",
"0.68358237",
"0.6784017",
"0.6765156",
"0.66363037",
"0.66167766",
"0.65355045",
"0.65329564",
"0.6509693",
"0.6402966",
"0.63938296",
"0.63908815",
"0.6374849",
"0.6361414",
"0.63555086",
"0.6327466",
"0.63204163",
"0.6289... | 0.73588157 | 0 |
Returns the real part of all the converged eigenvalues from arpack | def GetEigenvalues(self):
return self.Solver.GetEigenvalues().real.copy() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eigenvalues(self) -> ndarray:\n return self._vals",
"def eigenvalues(self, expand=False, factor=False, simplify=False):\n raise NotImplementedError",
"def eigvals(self):\n raise NotImplementedError",
"def GetEigenvalues(self, eigenvalues):\n return _hypre.HypreAME_GetEigenvalu... | [
"0.7210072",
"0.6718578",
"0.6628805",
"0.65749586",
"0.6457396",
"0.6456192",
"0.6427934",
"0.64171183",
"0.63999254",
"0.63643235",
"0.6360623",
"0.62789065",
"0.6247136",
"0.6236951",
"0.6201405",
"0.6178681",
"0.6170981",
"0.61528105",
"0.61432594",
"0.6131972",
"0.610695... | 0.6741684 | 1 |
Returns all eigenvectors as a N by M matrix, where N is the number of converged eigenvalues, and M is the size of the wavefunction. The eigenvectors is normalized in the vector 2norm, and can therefore not be expected to be normalized in the grid norm. Assign it to a wavefunction and call | def GetEigenvectors(self):
return self.Solver.GetEigenvectors() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_eigenvectors(self):\n return self.eigenVectors",
"def get_eigenvectors(self):\n return self._eigenvectors",
"def eig(self,manifold_num):\n num_sites = len(self.energies[manifold_num])\n ham = self.manifold_hamiltonian(manifold_num).toarray()\n eigvals, eigvecs = eigh(... | [
"0.7280959",
"0.7014462",
"0.68991834",
"0.6673352",
"0.66130096",
"0.6587522",
"0.6492255",
"0.6377612",
"0.63553613",
"0.6307149",
"0.6288552",
"0.62492836",
"0.6200734",
"0.6196136",
"0.61908334",
"0.61808556",
"0.6166238",
"0.614508",
"0.6144089",
"0.6143722",
"0.610234",... | 0.7069983 | 1 |
Sets psi to the eigenvector specified by eigenvetorIndex if normalize == True, psi will be normalized | def SetEigenvector(self, psi, eigenvectorIndex, normalize=True):
eigenvectors = self.GetEigenvectors()
shape = psi.GetData().shape
psi.GetData()[:] = numpy.reshape(eigenvectors[eigenvectorIndex, :], shape)
if normalize:
psi.Normalize() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eigsolve(self,**kwargs):\n return eigsolve(self,**kwargs)",
"def eigensolve(self, epsilon=0.85):\n raise NotImplementedError(\"eigensolve Incomplete\")",
"def eigen_vector_i(self, i):\n return self._eig_vec[:,i]",
"def set_eigenvalue_problem(self, *args, ncc_cutoff=1e-10, tolerance=1... | [
"0.56931436",
"0.55284667",
"0.54967713",
"0.54389435",
"0.5401519",
"0.5303515",
"0.522989",
"0.5135587",
"0.5133062",
"0.50980896",
"0.5096003",
"0.5075772",
"0.5053383",
"0.5042445",
"0.50405645",
"0.49959317",
"0.49945125",
"0.49574724",
"0.49294224",
"0.49113372",
"0.487... | 0.8005101 | 0 |
Do not return anything, modify root inplace instead. | def recoverTree(self, root: TreeNode) -> None:
self.first, self.second, self.pre = None, None, None
#中序遍历二叉树，找到递减的节点，如果有一个交换他们相邻的，如果有两个，交换这两个
def inorder(root: TreeNode) -> None:
if root == None:
return None
if root.left != None:
inorder(ro... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def uproot(self):\n self.__root__ = self\n return self",
"def root_replace(self,node):\r\n self.feature_index = node.feature_index\r\n self.threshold = node.threshold\r\n self.label = node.label\r\n self.left = node.left\r\n self.right = node.right\r\n self.substit... | [
"0.71675247",
"0.7090078",
"0.7052984",
"0.69619083",
"0.67892647",
"0.6614594",
"0.6551307",
"0.65119416",
"0.65119416",
"0.65119416",
"0.65119416",
"0.64319086",
"0.6413781",
"0.6397017",
"0.6397017",
"0.6370123",
"0.63613737",
"0.63289756",
"0.6325578",
"0.630594",
"0.6276... | 0.0 | -1 |
This view renders the general timeline. | def general_timeline():
return render_template('timeline.html', general=True, show_username=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def public_timeline():\n return render_template('timeline.html', messages=query_db('''\n select message.*, user.* from message, user\n where message.author_id = user.user_id\n order by message.pub_date desc limit ?''', [PER_PAGE]))",
"def public_timeline():\n return render_template('ti... | [
"0.68146354",
"0.68146354",
"0.646931",
"0.6225129",
"0.62190664",
"0.61926216",
"0.61690927",
"0.5976462",
"0.59268796",
"0.58612955",
"0.5815437",
"0.5813973",
"0.576644",
"0.57416373",
"0.5709168",
"0.5668732",
"0.55861884",
"0.5561978",
"0.5561588",
"0.5535532",
"0.552569... | 0.8364598 | 0 |
This view renders the user timeline. It also allows the user to post tweets. | def user_timeline(username=None): # pylint: disable=unused-argument
form = PostTweetForm()
if form.validate_on_submit():
try:
current_user.post_tweet(form.tweet.data)
flash('Tweet successfully posted')
except ValueError as excep:
flash(str(excep))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def public_timeline():\n return render_template('timeline.html', messages=query_db('''\n select message.*, user.* from message, user\n where message.author_id = user.user_id\n order by message.pub_date desc limit ?''', [PER_PAGE]))",
"def public_timeline():\n return render_template('ti... | [
"0.7028494",
"0.7028494",
"0.68925434",
"0.68407875",
"0.666454",
"0.64178663",
"0.63294685",
"0.6242161",
"0.6237933",
"0.61577386",
"0.61176234",
"0.61053467",
"0.6042958",
"0.5984481",
"0.5931631",
"0.5931134",
"0.5919422",
"0.5892258",
"0.57867306",
"0.57760817",
"0.57731... | 0.8192773 | 0 |
This view renders the user history. It will display all the tweets posted by this user; allow the loggedin user to follow/unfollow this user if they are different. | def user_history(username):
follow_form = FollowForm()
unfollow_form = UnfollowForm()
return render_template('user_history.html',
username=username,
follow_form=follow_form,
unfollow_form=unfollow_form) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def history():\n \n user_id = session[\"user_id\"]\n history_list = hist(user_id, db)\n return render_template('history.html', history=history_list)",
"def user_timeline(username):\n profile_user = query_db('select * from user where username = ?',\n [username], one=True)... | [
"0.65801525",
"0.6558955",
"0.65173095",
"0.65121293",
"0.6486155",
"0.64845365",
"0.643965",
"0.640158",
"0.6400872",
"0.6372886",
"0.63680434",
"0.63648087",
"0.6350884",
"0.632362",
"0.6294069",
"0.62907934",
"0.627852",
"0.62391174",
"0.62049097",
"0.61988515",
"0.6156545... | 0.74899447 | 0 |
This view handles the follow form in the user history page. | def follow(username):
follow_form = FollowForm()
unfollow_form = UnfollowForm()
if follow_form.validate_on_submit():
try:
current_user.follow(username)
flash('Followed {}'.format(username))
except ValueError as excep:
flash(str(excep))
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remote_follow_page(request):\n user = get_user_from_username(request.user, request.GET.get(\"user\"))\n data = {\"user\": user}\n return TemplateResponse(request, \"ostatus/remote_follow.html\", data)",
"def follow(request, usertofollow):\n to_follow = Member.objects.get(user__username=usertofoll... | [
"0.7149877",
"0.7063604",
"0.6739925",
"0.6728417",
"0.671004",
"0.6617824",
"0.6579484",
"0.6551827",
"0.6518894",
"0.650463",
"0.6486437",
"0.642817",
"0.64219815",
"0.64128906",
"0.6406436",
"0.6385301",
"0.6356875",
"0.63392025",
"0.63104033",
"0.6288673",
"0.62805295",
... | 0.7363769 | 0 |
This view handles the unfollow form in the user history page. | def unfollow(username):
follow_form = FollowForm()
unfollow_form = UnfollowForm()
if unfollow_form.validate_on_submit():
try:
current_user.unfollow(username)
flash('Unfollowed {}'.format(username))
except ValueError as excep:
flash(str(excep))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_unfollow():\n data = request.get_json(force=True)\n follower = User.query.get(data['follower'])\n following = User.query.get(data['following'])\n follower.followcheck.remove(following)\n db.session.commit()\n return {'unfollowed': True}",
"def unfollow(request, usertostopfollow):\n ... | [
"0.75263685",
"0.7512871",
"0.74527144",
"0.7343735",
"0.7333024",
"0.7246593",
"0.72271776",
"0.70816875",
"0.696819",
"0.68924844",
"0.68613744",
"0.6822375",
"0.67654264",
"0.676503",
"0.67183167",
"0.6688176",
"0.6617912",
"0.65045625",
"0.6494655",
"0.6466272",
"0.645384... | 0.822711 | 0 |
This function injects the function object 'Tweet.get_general_timeline' into the application context so that 'get_general_timeline' can be accessed in Jinja2 templates. | def inject_general_timeline():
return dict(get_general_timeline=Tweet.get_general_timeline) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def general_timeline():\n return render_template('timeline.html', general=True, show_username=True)",
"def common_context(request):\n c = {\n 'lessons': get_lesson_numbers(),\n }\n return c",
"def _timeline_context(self):\n\n timeline = self.channel.get_months_active()\n if not... | [
"0.6907658",
"0.55791354",
"0.5368909",
"0.5239636",
"0.5160229",
"0.5101733",
"0.50975186",
"0.50097936",
"0.50072044",
"0.49837127",
"0.49837127",
"0.4918119",
"0.49131495",
"0.49122372",
"0.4868816",
"0.48333994",
"0.4832774",
"0.48210987",
"0.4787424",
"0.47700545",
"0.47... | 0.7961719 | 0 |
Given surfaces from features files from ABC dataset, load it into geomdl object or samples points on the surfaces of primitives, depending on the case. Defines utility to sample points form the surface of splines and primitives. | def __init__(self):
self.function_dict = {
"Sphere": self.draw_sphere,
"BSpline": self.draw_nurbspatch,
"Cylinder": self.draw_cylinder,
"Cone": self.draw_cone,
"Torus": self.draw_torus,
"Plane": self.draw_plane,
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_parameters(self, data, bit_mapping=False):\n points = data[\"points\"]\n normals = data[\"normals\"]\n labels = data[\"labels\"]\n\n primitives = data[\"primitives\"]\n\n cluster_ids = data[\"seg_id\"]\n primitive_dict = data[\"primitive_dict\"]\n for k, v ... | [
"0.60803115",
"0.5795981",
"0.5724051",
"0.569382",
"0.56591415",
"0.5653855",
"0.5642791",
"0.5605703",
"0.5553292",
"0.5419038",
"0.5403903",
"0.53917825",
"0.5315353",
"0.5264245",
"0.5220138",
"0.52184683",
"0.5197713",
"0.51728046",
"0.5171846",
"0.51695555",
"0.5161669"... | 0.0 | -1 |
Takes a list containing surface in feature file format, and returns a list of sampled points on the surface of primitive/splines. | def load_shape(self, shape):
Points = []
for surf in shape:
function = self.function_dict[surf["type"]]
points = function(surf)
Points.append(points)
Points = np.concatenate(Points, 0)
return Points | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_random_surface_points() -> List[SurfacePoint]:\n surface_points: List[SurfacePoint] = []\n for _ in range(42):\n surface_point = SurfacePoint(\n idx=uuid.uuid4().hex,\n x=_gen_random_number(),\n y=_gen_random_number(),\n z=_gen_random_number(),\... | [
"0.6109882",
"0.6036777",
"0.5864705",
"0.58414865",
"0.5840645",
"0.57714117",
"0.57691383",
"0.57503223",
"0.5724751",
"0.57103294",
"0.56614566",
"0.56398237",
"0.56080896",
"0.5605836",
"0.55992913",
"0.557783",
"0.55328035",
"0.5519913",
"0.55067337",
"0.54709214",
"0.54... | 0.5382905 | 23 |
Convert degrees, minutes, seconds to decimal degress | def dms_to_dd(degrees, minutes, seconds):
fd = float(degrees)
if fd < 0:
return fd - float(minutes) / 60 - float(seconds) / 3600
return fd + float(minutes) / 60 + float(seconds) / 3600 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _convert_to_degress(value):\r\n d = float(value.values[0].num) / float(value.values[0].den)\r\n m = float(value.values[1].num) / float(value.values[1].den)\r\n s = float(value.values[2].num) / float(value.values[2].den)\r\n\r\n return d + (m / 60.0) + (s / 3600.0)",
"def _degrees_to_decimal(degre... | [
"0.7796841",
"0.77228105",
"0.7708203",
"0.76262164",
"0.74406266",
"0.7345186",
"0.7307236",
"0.71681195",
"0.7065902",
"0.68985623",
"0.67277086",
"0.6585821",
"0.65812045",
"0.65508264",
"0.6547631",
"0.65216386",
"0.65213",
"0.64031416",
"0.638162",
"0.6380068",
"0.635357... | 0.66474026 | 11 |
Test case for api_last_tested_repo_get | def test_api_last_tested_repo_get(self):
default_api = DefaultApi(api_client=self.api_client)
params = dlrnapi_client.Params()
path, method = default_api.api_last_tested_repo_get(params)
self.assertEqual(path, '/api/last_tested_repo')
self.assertEqual(method, 'GET') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_api_last_tested_repo_post(self):\n default_api = DefaultApi(api_client=self.api_client)\n params = dlrnapi_client.Params1()\n path, method = default_api.api_last_tested_repo_post(params)\n self.assertEqual(path, '/api/last_tested_repo')\n self.assertEqual(method, 'POST')... | [
"0.7768464",
"0.72451514",
"0.7038413",
"0.6969715",
"0.65839493",
"0.6558673",
"0.64816403",
"0.6443256",
"0.6438606",
"0.6329126",
"0.6317321",
"0.61880976",
"0.6162838",
"0.6152482",
"0.61490256",
"0.6125279",
"0.6106903",
"0.61035943",
"0.6100584",
"0.6053026",
"0.6051147... | 0.88925594 | 0 |
Test case for api_last_tested_repo_post | def test_api_last_tested_repo_post(self):
default_api = DefaultApi(api_client=self.api_client)
params = dlrnapi_client.Params1()
path, method = default_api.api_last_tested_repo_post(params)
self.assertEqual(path, '/api/last_tested_repo')
self.assertEqual(method, 'POST') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_api_last_tested_repo_get(self):\n default_api = DefaultApi(api_client=self.api_client)\n params = dlrnapi_client.Params()\n path, method = default_api.api_last_tested_repo_get(params)\n self.assertEqual(path, '/api/last_tested_repo')\n self.assertEqual(method, 'GET')",
... | [
"0.7607755",
"0.6482869",
"0.6286869",
"0.62830985",
"0.61684394",
"0.6084323",
"0.6048418",
"0.60430026",
"0.6034124",
"0.5954312",
"0.5915801",
"0.58691543",
"0.58313596",
"0.5807549",
"0.5777155",
"0.57586783",
"0.573755",
"0.57354254",
"0.57269734",
"0.5724796",
"0.570244... | 0.8940906 | 0 |
Test case for api_promote_post | def test_api_promote_post(self):
default_api = DefaultApi(api_client=self.api_client)
params = dlrnapi_client.Promotion()
path, method = default_api.api_promote_post(params)
self.assertEqual(path, '/api/promote')
self.assertEqual(method, 'POST') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_post(self):\n pass",
"def test_smoker_post(self):\n pass",
"def test_post_user_post(self):\n pass",
"def test_promote_goes_no_further_than_done(self):\n todo = Todo.create(title=\"Thing to do\", status=Todo.CHOICES[-1][0])\n assert todo.status == todo.CHOICES[-1][0... | [
"0.6381156",
"0.62768924",
"0.6186299",
"0.6080127",
"0.60648495",
"0.59423923",
"0.5903473",
"0.58985007",
"0.5884698",
"0.58770335",
"0.58684766",
"0.5868241",
"0.5822002",
"0.57952636",
"0.5735996",
"0.572518",
"0.5721291",
"0.5715468",
"0.56378376",
"0.56373036",
"0.56297... | 0.88653123 | 0 |
Test case for api_promotions_get | def test_api_promotions_get(self):
default_api = DefaultApi(api_client=self.api_client)
params = dlrnapi_client.Promotion()
path, method = default_api.api_promotions_get(params)
self.assertEqual(path, '/api/promotions')
self.assertEqual(method, 'GET') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self):\n app.logger.info(\"Request for promotions list\")\n promotion = []\n name = request.args.get(\"name\")\n description = request.args.get(\"description\")\n promo_code = request.args.get(\"promo_code\")\n if name:\n promotion = Promotions.find_by_n... | [
"0.59409016",
"0.57219326",
"0.56976277",
"0.5597588",
"0.55282253",
"0.5519187",
"0.55077225",
"0.5502402",
"0.5457423",
"0.54374766",
"0.54354423",
"0.5377362",
"0.5357199",
"0.5355699",
"0.5349281",
"0.5313175",
"0.5301036",
"0.5291509",
"0.52211195",
"0.5198851",
"0.51665... | 0.8312879 | 0 |
Test case for api_build_metrics_get | def test_api_build_metrics_get(self):
default_api = DefaultApi(api_client=self.api_client)
params = dlrnapi_client.MetricsRequest()
path, method = default_api.api_build_metrics_get(params)
self.assertEqual(path, '/api/metrics/builds')
self.assertEqual(method, 'GET') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_result_fields_with_metrics(cbcsdk_mock):\n api = cbcsdk_mock.api\n result = Result(api, initial_data=GET_RUN_RESULTS_RESP_1)\n metrics = result.metrics_\n assert metrics._info == {\"cpu\": 24.3, \"memory\": 8.0}",
"def test_metrics(client):\n response = client.get(\"/metrics\")\n asser... | [
"0.7185345",
"0.70361453",
"0.6999692",
"0.6963669",
"0.69537514",
"0.6777485",
"0.6712619",
"0.6622766",
"0.6521939",
"0.6513031",
"0.64969116",
"0.6484864",
"0.6482907",
"0.6441199",
"0.6406892",
"0.63881034",
"0.6368471",
"0.6339531",
"0.6260921",
"0.6234628",
"0.6190819",... | 0.8813328 | 0 |
Test case for api_remote_import_post | def test_api_remote_import_post(self):
default_api = DefaultApi(api_client=self.api_client)
params = dlrnapi_client.ModelImport()
path, method = default_api.api_remote_import_post(params)
self.assertEqual(path, '/api/remote/import')
self.assertEqual(method, 'POST') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_import_upload(self):\r\n self._login_admin()\r\n\r\n # verify we get the form\r\n res = self.app.get('/admin/import')\r\n self.assertTrue(\r\n '<form' in res.body,\r\n 'Should have a form in the body for submitting the upload')\r\n\r\n res = self._u... | [
"0.6340387",
"0.62975264",
"0.6129785",
"0.6082167",
"0.6075704",
"0.59829533",
"0.5974887",
"0.5939281",
"0.59220105",
"0.5799908",
"0.5782063",
"0.5755509",
"0.57277656",
"0.5705541",
"0.5701068",
"0.5679355",
"0.56710863",
"0.5662004",
"0.5627926",
"0.5620273",
"0.5619928"... | 0.87363845 | 0 |
Test case for api_repo_status_get | def test_api_repo_status_get(self):
default_api = DefaultApi(api_client=self.api_client)
params = dlrnapi_client.Params2()
path, method = default_api.api_repo_status_get(params)
self.assertEqual(path, '/api/repo_status')
self.assertEqual(method, 'GET') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_status(self):\n pass",
"def test_get_status(self):\n pass",
"def test_get_status(self):\n resp = self.build_api.getStatus().json()\n assert 'status' in resp\n assert 'message' in resp",
"def test_get_status(self):\n response = self.client.open(\n ... | [
"0.76847225",
"0.76847225",
"0.7624905",
"0.7335575",
"0.7133566",
"0.7124783",
"0.68932515",
"0.68918663",
"0.6867826",
"0.6845981",
"0.6791606",
"0.67886084",
"0.67723477",
"0.6749822",
"0.67219496",
"0.6644989",
"0.6614613",
"0.658524",
"0.6566437",
"0.6537004",
"0.6474428... | 0.87942904 | 0 |
Test case for api_report_result_post | def test_api_report_result_post(self):
default_api = DefaultApi(api_client=self.api_client)
params = dlrnapi_client.Params3()
path, method = default_api.api_report_result_post(params)
self.assertEqual(path, '/api/report_result')
self.assertEqual(method, 'POST') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_successful_report(self):\n from rest_framework.test import APIClient\n client = APIClient()\n response = client.post('/api/report/epic/', self.report,\n HTTP_AUTHORIZATION='Token ' + self.token_1,\n format='json')\n... | [
"0.71547884",
"0.7134954",
"0.6750663",
"0.6482854",
"0.6443237",
"0.6282149",
"0.62690705",
"0.6220305",
"0.62106735",
"0.62021273",
"0.6135198",
"0.6113796",
"0.6112314",
"0.6103845",
"0.60587716",
"0.60543984",
"0.60537034",
"0.60535234",
"0.6035478",
"0.5997932",
"0.59572... | 0.87548476 | 0 |
Plot reconstruction error as variance explained across all whole groupday TCA decomposition ensemble. | def groupday_varex_drop_worst_comp(
mouse,
trace_type='zscore_day',
method='ncp_hals',
cs='',
warp=False,
word=None,
group_by='all3',
nan_thresh=0.85,
score_threshold=0.8,
rectified=True,
verbose=False):
mouse = mo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train r... | [
"0.6626714",
"0.61986005",
"0.6093413",
"0.60877055",
"0.60319614",
"0.60185933",
"0.59652436",
"0.5910634",
"0.5900354",
"0.5876719",
"0.5846923",
"0.5820176",
"0.581589",
"0.57660216",
"0.5753341",
"0.5733544",
"0.57210577",
"0.5715147",
"0.57129216",
"0.56874424",
"0.56554... | 0.0 | -1 |
Plot reconstruction error as variance explained across all whole groupday TCA decomposition ensemble. | def groupday_varex(
mouse,
trace_type='zscore_day',
method='ncp_hals',
cs='',
warp=False,
word=None,
group_by='all3',
nan_thresh=0.85,
score_threshold=0.8,
rectified=True,
verbose=False):
mouse = mouse.mouse
p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train r... | [
"0.6626714",
"0.61986005",
"0.6093413",
"0.60877055",
"0.60319614",
"0.60185933",
"0.59652436",
"0.5910634",
"0.5900354",
"0.5876719",
"0.5846923",
"0.5820176",
"0.581589",
"0.57660216",
"0.5753341",
"0.5733544",
"0.57210577",
"0.5715147",
"0.57129216",
"0.56874424",
"0.56554... | 0.0 | -1 |
Plot reconstruction error as variance explained across all whole groupday TCA decomposition ensemble. | def groupday_varex_cv_train_set(
mouse,
trace_type='zscore_day',
method='ncp_hals',
cs='',
warp=False,
word=None,
group_by='all3',
nan_thresh=0.85,
score_threshold=0.8,
train_test_split=0.8,
rectified=True,
verbo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train r... | [
"0.66271156",
"0.61979055",
"0.609163",
"0.6088389",
"0.60322195",
"0.60189843",
"0.59633064",
"0.5909732",
"0.58992445",
"0.58761466",
"0.58461267",
"0.58211416",
"0.581732",
"0.57664233",
"0.57548785",
"0.57342",
"0.57206076",
"0.5714774",
"0.5714627",
"0.5686507",
"0.56552... | 0.0 | -1 |
Plot reconstruction error as variance explained across all whole groupday TCA decomposition ensemble. | def groupday_varex_cv_test_set(
mouse,
trace_type='zscore_day',
method='ncp_hals',
cs='',
warp=False,
word=None,
group_by='all3',
nan_thresh=0.85,
score_threshold=0.8,
train_test_split=0.8,
rectified=True,
verbos... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train r... | [
"0.6626761",
"0.61979336",
"0.60904497",
"0.60882133",
"0.6032409",
"0.60164094",
"0.5964159",
"0.5911293",
"0.5902218",
"0.587687",
"0.58464044",
"0.58204544",
"0.5817129",
"0.5768622",
"0.5752992",
"0.57344383",
"0.57194054",
"0.5714669",
"0.57140064",
"0.56863517",
"0.5654... | 0.0 | -1 |
Plot reconstruction error as variance explained across all whole groupday TCA decomposition ensemble. | def groupday_varex_byday(
mouse,
trace_type='zscore_day',
method='ncp_hals',
cs='',
warp=False,
word=None,
group_by='all3',
nan_thresh=0.85,
score_threshold=0.8,
rectified=True,
verbose=False):
mouse = mouse.mouse
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train r... | [
"0.6626714",
"0.61986005",
"0.6093413",
"0.60877055",
"0.60319614",
"0.60185933",
"0.59652436",
"0.5910634",
"0.5900354",
"0.5876719",
"0.5846923",
"0.5820176",
"0.581589",
"0.57660216",
"0.5753341",
"0.5733544",
"0.57210577",
"0.5715147",
"0.57129216",
"0.56874424",
"0.56554... | 0.0 | -1 |
Plot total dataset variance across all whole groupday TCA decomposition ensemble. | def groupday_var_byday(
mouse,
trace_type='zscore_day',
method='ncp_hals',
cs='',
warp=False,
word=None,
group_by='all3',
nan_thresh=0.85,
score_threshold=0.8,
rectified=True,
verbose=False):
mouse = mouse.mouse
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_PCA():\n X, languages = prepare_data_matrix()\n #print(X)\n eigenvectors, eigenvalues=power_iteration_two_components(X)\n explain = explained_variance_ratio(X, eigenvectors, eigenvalues)\n X=project_to_eigenvectors(X,eigenvectors)\n\n #print(X)\n plt.title('Explained variance: %.3f' %... | [
"0.63589156",
"0.5836832",
"0.5827785",
"0.57852423",
"0.569805",
"0.56924427",
"0.5647534",
"0.56309074",
"0.5551352",
"0.5546261",
"0.5531009",
"0.54955757",
"0.5475013",
"0.5473825",
"0.54661816",
"0.5440744",
"0.54330385",
"0.5412564",
"0.54053146",
"0.54017264",
"0.53706... | 0.0 | -1 |
Plot reconstruction error as variance explained across all whole groupday TCA decomposition ensemble. | def groupday_varex_byday_bycomp(
mouse,
trace_type='zscore_day',
method='ncp_hals',
cs='',
warp=False,
word=None,
group_by='all3',
nan_thresh=0.85,
score_threshold=0.8,
rectified=True,
verbose=False):
mouse = mouse... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train r... | [
"0.66271156",
"0.61979055",
"0.609163",
"0.6088389",
"0.60322195",
"0.60189843",
"0.59633064",
"0.5909732",
"0.58992445",
"0.58761466",
"0.58461267",
"0.58211416",
"0.581732",
"0.57664233",
"0.57548785",
"0.57342",
"0.57206076",
"0.5714774",
"0.5714627",
"0.5686507",
"0.56552... | 0.0 | -1 |
Plot reconstruction error as variance explained across all whole groupday TCA decomposition ensemble. | def groupday_varex_byday_bycomp_bycell(
mouse,
trace_type='zscore_day',
method='ncp_hals',
cs='',
warp=False,
word=None,
group_by='all3',
nan_thresh=0.85,
rectified=True,
verbose=False):
mouse = mouse.mouse
pars = {'tr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train r... | [
"0.6626761",
"0.61979336",
"0.60904497",
"0.60882133",
"0.6032409",
"0.60164094",
"0.5964159",
"0.5911293",
"0.5902218",
"0.587687",
"0.58464044",
"0.58204544",
"0.5817129",
"0.5768622",
"0.5752992",
"0.57344383",
"0.57194054",
"0.5714669",
"0.57140064",
"0.56863517",
"0.5654... | 0.0 | -1 |
Plot reconstruction error as variance explained across all whole groupday TCA decomposition ensemble. | def groupday_varex_bycomp_bycell(
mouse,
trace_type='zscore_day',
method='ncp_hals',
cs='',
warp=False,
word=None,
group_by='all3',
nan_thresh=0.85,
rectified=True,
verbose=False):
mouse = mouse.mouse
pars = {'trace_ty... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train r... | [
"0.6626714",
"0.61986005",
"0.6093413",
"0.60877055",
"0.60319614",
"0.60185933",
"0.59652436",
"0.5910634",
"0.5900354",
"0.5876719",
"0.5846923",
"0.5820176",
"0.581589",
"0.57660216",
"0.5753341",
"0.5733544",
"0.57210577",
"0.5715147",
"0.57129216",
"0.56874424",
"0.56554... | 0.0 | -1 |
Plot reconstruction error as variance explained across all whole groupday TCA decomposition ensemble. | def groupday_varex_bycomp(
mouse,
trace_type='zscore_day',
method='ncp_hals',
cs='',
warp=False,
word=None,
group_by='all3',
nan_thresh=0.85,
score_threshold=0.8,
rectified=True,
verbose=False):
mouse = mouse.mouse... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train r... | [
"0.6626714",
"0.61986005",
"0.6093413",
"0.60877055",
"0.60319614",
"0.60185933",
"0.59652436",
"0.5910634",
"0.5900354",
"0.5876719",
"0.5846923",
"0.5820176",
"0.581589",
"0.57660216",
"0.5753341",
"0.5733544",
"0.57210577",
"0.5715147",
"0.57129216",
"0.56874424",
"0.56554... | 0.0 | -1 |
Plot reconstruction error as variance explained across all whole groupday TCA decomposition ensemble. | def groupday_varex_bycomp_ablated(
mouse,
trace_type='zscore_day',
method='ncp_hals',
cs='',
warp=False,
word=None,
group_by='all3',
nan_thresh=0.85,
score_threshold=0.8,
rectified=True,
verbose=False):
# save sort... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train r... | [
"0.66271156",
"0.61979055",
"0.609163",
"0.6088389",
"0.60322195",
"0.60189843",
"0.59633064",
"0.5909732",
"0.58992445",
"0.58761466",
"0.58461267",
"0.58211416",
"0.581732",
"0.57664233",
"0.57548785",
"0.57342",
"0.57206076",
"0.5714774",
"0.5714627",
"0.5686507",
"0.56552... | 0.0 | -1 |
Plot reconstruction error as variance explained across all whole groupday TCA decomposition ensemble. | def groupday_varex_byday_bycell(
mouse,
trace_type='zscore_day',
method='ncp_hals',
cs='',
warp=False,
word=None,
group_by='all2',
nan_thresh=0.85,
rectified=True,
verbose=False):
mouse = mouse.mouse
pars = {'trace_typ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train r... | [
"0.6626761",
"0.61979336",
"0.60904497",
"0.60882133",
"0.6032409",
"0.60164094",
"0.5964159",
"0.5911293",
"0.5902218",
"0.587687",
"0.58464044",
"0.58204544",
"0.5817129",
"0.5768622",
"0.5752992",
"0.57344383",
"0.57194054",
"0.5714669",
"0.57140064",
"0.56863517",
"0.5654... | 0.0 | -1 |
Plot reconstruction error as variance explained across all whole groupday TCA decomposition ensemble. | def groupday_varex_bycell(
mouse,
trace_type='zscore_day',
method='ncp_hals',
cs='',
warp=False,
word=None,
group_by='all2',
nan_thresh=0.85,
rectified=True,
verbose=False):
mouse = mouse.mouse
pars = {'trace_type': tr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train r... | [
"0.6626714",
"0.61986005",
"0.6093413",
"0.60877055",
"0.60319614",
"0.60185933",
"0.59652436",
"0.5910634",
"0.5900354",
"0.5876719",
"0.5846923",
"0.5820176",
"0.581589",
"0.57660216",
"0.5753341",
"0.5733544",
"0.57210577",
"0.5715147",
"0.57129216",
"0.56874424",
"0.56554... | 0.0 | -1 |
Create full matrix from an ablated (one factor removed) KTensor. | def _full_ablated(tt_factors, fac_num_to_remove):
# turn factors into tuple, then remove factor from each mode's matrix
factors = tuple(tt_factors)
factors = tuple([np.delete(f, fac_num_to_remove, axis=1) for f in factors])
# create a KTensor from tensortools to speed up some math
kt = KTen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_full_matrix(AB, BA, AA, BB):\n a_size, b_size = AB.shape\n\n full_mat = sparse.csc_matrix((a_size + b_size, a_size + b_size))\n full_mat[:a_size, :a_size] = AA\n full_mat[:a_size, a_size:] = AB\n full_mat[a_size:, :a_size] = BA\n full_mat[a_size:, a_size:] = BB\n\n return full_mat",
... | [
"0.62535655",
"0.6194362",
"0.5881765",
"0.57952917",
"0.56678134",
"0.56190974",
"0.5563654",
"0.55563956",
"0.5539287",
"0.55289817",
"0.5493376",
"0.546882",
"0.54683924",
"0.54578173",
"0.54480875",
"0.544805",
"0.5428051",
"0.5427213",
"0.5424056",
"0.5413035",
"0.539482... | 0.63164496 | 0 |
Initializes this compiler. Default for classes is all in the given directory or expects a list or tuple, otherwise and ValueError is thrown | def __init__(self, compiler_name, src_ext, dst_ext, sources=None, directory=_os.curdir):
if sources is not None and not isinstance(sources, (list, set, tuple)):
raise TypeError('sources must be an iterable')
self.compiler_name = compiler_name
self.src_ext = src_ext
self.dst_e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _initialize_derived_class_folders(self):\n self.smooth_update_dir = self.opt_folder / \"SMOOTHED_UPDATES\"\n self.moment_dir = self.opt_folder / \"MOMENTS\"\n self.smoothed_model_dir = self.opt_folder / \"SMOOTHED_MODELS\"",
"def __init__(self, *paths):\r\n self.paths = paths",
... | [
"0.5769025",
"0.57047147",
"0.56077063",
"0.5606366",
"0.55970603",
"0.5477624",
"0.54756784",
"0.54678094",
"0.54382044",
"0.5425789",
"0.54102427",
"0.53504074",
"0.53469247",
"0.5345114",
"0.5299918",
"0.52958083",
"0.52947456",
"0.52946234",
"0.52822196",
"0.5268107",
"0.... | 0.6095816 | 0 |
Sets the path of this compiler to the given directory | def set_path(self, directory):
self.directory = directory | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SetPath(self, directory):\r\n\r\n if directory is not None and exists(directory) and isdir(directory):\r\n self.directory = directory",
"def set_script_dir(self, path):\n self.script_dir = path",
"def set_directory_path(self, directory_path: str) -> None:\n self.directory_pa... | [
"0.7257609",
"0.7105358",
"0.7008451",
"0.68472654",
"0.6803677",
"0.67048776",
"0.6698584",
"0.6678834",
"0.66785187",
"0.6646457",
"0.66388613",
"0.6610648",
"0.65984744",
"0.659206",
"0.6573202",
"0.65296423",
"0.65239066",
"0.64913666",
"0.63866687",
"0.63670313",
"0.6328... | 0.746776 | 0 |
Adds the given flag to the list of flags | def add_flag(self, flag):
self.flags.append(flag) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(self, flag):\n\n try:\n # Resolve the flag\n flag = self.eset[flag]\n except KeyError:\n raise TypeError('Unknown bit flag %r' % flag)\n\n # Save the current bitflags\n previous = self.bitflags\n\n self.bitflags |= int(flag)\n self.... | [
"0.75960606",
"0.7376466",
"0.730766",
"0.70087034",
"0.68559486",
"0.6774737",
"0.6746336",
"0.63983494",
"0.6393685",
"0.63705426",
"0.63703865",
"0.6267221",
"0.59687865",
"0.58709884",
"0.5841526",
"0.57966334",
"0.5731052",
"0.57130134",
"0.5683149",
"0.5680459",
"0.5653... | 0.85671544 | 0 |
Clears the list of flags | def clear_flags(self):
self.flags.clear() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resetFlags():\r\n for flag in flags:\r\n flags[flag] = False",
"def clearAllCanSelectFlags(self):\n for key in self.canSelectFlags.keys():\n self.canSelectFlags[key] = 0",
"def reset() -> None:\n\t_flag.clear()",
"def clearAccessedFlags(self):\n pass",
"def _resetFlag... | [
"0.8162865",
"0.77293634",
"0.7115795",
"0.68962365",
"0.68583477",
"0.68233705",
"0.6815525",
"0.6761658",
"0.6682103",
"0.66317004",
"0.6561998",
"0.6549232",
"0.64430094",
"0.64430094",
"0.64283997",
"0.6389182",
"0.6374279",
"0.63340294",
"0.63226664",
"0.63033676",
"0.62... | 0.8602546 | 0 |
Compiles the source files in this directory with this compiler's | def compile(self, exclude=None, recurse=True, references=None, verbose=False):
from clay.shell.core import lsgrep
_os.chdir(self.directory)
sources = self.sources
if sources is None:
sources = [_os.path.splitext(x)[0] for x in lsgrep(self.src_ext, self.directory, recurse=re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compile_dir(path):\r\n to_compile = get_pyx_files(path)\r\n print(\"De:\",path)\r\n if to_compile:\r\n print(\"Se compilaran:\", list(map(os.path.basename,to_compile)))\r\n Cythonize.main( ['-a', '-i'] + to_compile )\r\n else:\r\n print(\"Nada para compilar\")",
"def compile(... | [
"0.7384383",
"0.6637735",
"0.6614796",
"0.6554956",
"0.6524108",
"0.6508908",
"0.6475297",
"0.6471648",
"0.6450059",
"0.6450059",
"0.6403609",
"0.63995343",
"0.63847154",
"0.63383234",
"0.6291639",
"0.6264601",
"0.62318736",
"0.6183617",
"0.6145199",
"0.61386466",
"0.6107049"... | 0.6854204 | 1 |
Initialize each process with its own OSRM file | def init(a: str, h: str, c: str, r: bool, A: str, lock: Lock) -> None:
global host, action, report, router, algorithm
action = a
algorithm = A
if r:
report = r
if h:
host = h
if c:
lock.acquire()
try:
router = PyOSRM(c, use_shared_memory=False, algor... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_processes(rank, size, backend='gloo'):\n os.environ['MASTER_ADDR'] = '12.12.10.13'\n os.environ['MASTER_PORT'] = '29500'\n dist.init_process_group(backend, rank=rank, world_size=size)",
"def __init__(self, paths):\n Process.__init__(self)\n self.paths = paths",
"def __init__(sel... | [
"0.60539454",
"0.60366905",
"0.59817487",
"0.58167285",
"0.58035195",
"0.5778657",
"0.57217056",
"0.57196563",
"0.5703051",
"0.56834275",
"0.56599486",
"0.56153727",
"0.5592089",
"0.5569022",
"0.5486655",
"0.5480387",
"0.5471384",
"0.547018",
"0.54518867",
"0.54294914",
"0.54... | 0.0 | -1 |
Return the distance in meters or None (to be filtered by caller) | def work(params) -> Union[None, float]:
try:
# either HTTP or bindings
if host:
path = action if action == "route" else "sources_to_targets"
params_str = delimit_tuple(
tuple((delimit_tuple(x) for x in params)), delimiter=";"
)
route = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_distance(self) -> int:\n return self.get_measurement_data().distance",
"async def distance(self):\n return round(await self._rpc.distance(), 2)",
"def get_distance(self):\n\n # Activate trigger\n self.trigger()\n\n # Detect rising edge of echo pin\n channel = G... | [
"0.7287641",
"0.71533",
"0.70847905",
"0.70370567",
"0.6925204",
"0.68493444",
"0.68152845",
"0.6795716",
"0.6773997",
"0.6751818",
"0.67329544",
"0.6720923",
"0.6680369",
"0.66397786",
"0.657678",
"0.6526369",
"0.65154874",
"0.64958256",
"0.649231",
"0.6470604",
"0.6454386",... | 0.0 | -1 |
Generate a series of 1D plots of the cube parameters Does special treatment for the "alpha" parameter | def do_alpha_plot(uvals,vectors,wvectors,names,tag=None, fig_exten='.png',
dolevels=False,log=True,outdir='SingleFigs/',
vparams_dict=None, prefix='',truth=None,latexnames=None,
logspline=True, others=None):
import os
import math
if tag is not... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mlab_plt_cube(xmin, xmax, ymin, ymax, zmin, zmax):\n faces = cube_faces(xmin, xmax, ymin, ymax, zmin, zmax)\n for grid in faces:\n x, y, z = grid\n mlab.mesh(x, y, z, opacity=0.1, color=(0.1, 0.2, 0.3))",
"def SH_surface_plots(n_max=6,figsize=(15,15),fs=15,saveA=True,show=False,dpi=400,vi... | [
"0.6512349",
"0.6258401",
"0.6198374",
"0.59662074",
"0.594106",
"0.59283364",
"0.5919015",
"0.59163845",
"0.5897143",
"0.5843514",
"0.5832862",
"0.58112234",
"0.5749006",
"0.56579745",
"0.5616748",
"0.56120133",
"0.56120133",
"0.56094986",
"0.5609242",
"0.5600532",
"0.559543... | 0.5606482 | 19 |
for a given image name, generate a respective file name, the output should be saved as; e.g. xd.jpg > xd_features.npy can be used to find the files for the regression part | def generate_file_name(old_file_name: str) -> str:
return old_file_name.split(".")[0] + '_features' + '.npy' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_filename(images):\n image_file = {}\n for image in images:\n image_file[image['id']] = os.path.join('train2017', image['file_name'])\n return image_file",
"def createAllImageFiles(poly, name) :\n \n for i in range(len(poly.getPaths())):\n fileName = name + \"_\" + str(i) + \"... | [
"0.6532228",
"0.63980925",
"0.6393354",
"0.6317259",
"0.6311766",
"0.63059837",
"0.6289537",
"0.6256262",
"0.62549275",
"0.6253018",
"0.6176286",
"0.61517787",
"0.6143204",
"0.611888",
"0.6113079",
"0.6079711",
"0.60362726",
"0.6034775",
"0.6033952",
"0.6028542",
"0.6015237",... | 0.6681591 | 0 |
change the model, that will be used by the predictor; to get the model_names, refer to viable models at the top of this file | def select_model(model_name: str):
global predictor, currently_selected_model
predictor = FeatureExtractor(model_name)
currently_selected_model = model_name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setOldModel(self,model):\n self.modelName = model\n oldModel = load_model(self.modelPath + \"/\" + model + \".hdf5\",\n custom_objects={'recall': recall,\n 'precision': precision,\n 'f1Score':f1Sc... | [
"0.70904213",
"0.69119847",
"0.67973185",
"0.6719595",
"0.6565851",
"0.6494036",
"0.6449818",
"0.6443918",
"0.6391521",
"0.6389185",
"0.63809407",
"0.6304095",
"0.6300939",
"0.62952447",
"0.6261975",
"0.62455255",
"0.6224973",
"0.6174949",
"0.6136979",
"0.61338425",
"0.607484... | 0.694931 | 1 |
API function for Algonauts; for a given string, that is a path to an image file, compute a dictionary of of outputs of various layers from the encoding model | def get_features_by_image_path(path_to_image: str) -> t.Dict[str, torch.Tensor]:
image_data = loader(path_to_image)
with torch.no_grad():
return get_features_by_image_data(image_data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(\n self, \n image: ndarray, \n adversarial_image: ndarray\n ) -> Dict[str, Union[float, int]]:\n ...",
"def parse_function(filenames):\n \n img_filename, gt_filename = filenames['image'], filenames.get('segmentation_mask', None)\n \n # Reading the file and ... | [
"0.6114287",
"0.5772065",
"0.56981933",
"0.5651094",
"0.56293285",
"0.56234235",
"0.56135386",
"0.5601471",
"0.55929637",
"0.55676836",
"0.55646133",
"0.5551584",
"0.55348206",
"0.55257267",
"0.55229133",
"0.547941",
"0.54559493",
"0.54455626",
"0.54355234",
"0.54320383",
"0.... | 0.0 | -1 |
API function for Algonauts; for a loaded, not yet preprocessed image, return outputs of various layers of the encoding model; image data is expected to be in RGB the layers here are provided by detectron2 itself; no IntermediateLayerGetter | def get_features_by_image_data(image_data: np.ndarray) -> t.Dict[str, torch.Tensor]:
with torch.no_grad():
return _reorder_features(predictor(image_data)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inference(self, image_rgb):\n s = image_rgb.get_shape().as_list()\n with tf.name_scope('image-preprocessing'):\n MEAN = [103.939, 116.779, 123.68]\n assert s[1:] == [227, 227, 3]\n red, green, blue = tf.split(image_rgb, 3, 3)\n bgr = tf.concat([\n ... | [
"0.5769102",
"0.57382643",
"0.57309794",
"0.5680739",
"0.5673918",
"0.5655157",
"0.5644211",
"0.56367666",
"0.5591521",
"0.55862665",
"0.5567598",
"0.5562491",
"0.55506796",
"0.5523746",
"0.5522362",
"0.54794484",
"0.54794043",
"0.54676753",
"0.54660183",
"0.5465986",
"0.5463... | 0.0 | -1 |
vulnarable to future updates; | def _reorder_features(outputs: t.Dict[str, torch.Tensor]) -> t.Dict[str, torch.Tensor]:
results = collections.OrderedDict()
keys = outputs.keys()
res_keys: t.List = sorted([key for key in keys if 'res' in key])
p_keys: t.List = sorted([key for key in keys if 'p' in key], reverse=True)
new_k... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update( ):\r\n pass",
"def update():",
"def update():",
"def _update(self):\n pass",
"def update(self):",
"def update(self):",
"def update(self):",
"def dummy_update( self ):\r\n pass",
"def onUpdated(self):",
"def update(self):\r\n pass",
"def update(self) -> No... | [
"0.7782488",
"0.77389413",
"0.77389413",
"0.7653784",
"0.75854903",
"0.75854903",
"0.75854903",
"0.7537543",
"0.73864686",
"0.7356516",
"0.7338992",
"0.72717035",
"0.72717035",
"0.72717035",
"0.72717035",
"0.72717035",
"0.72717035",
"0.72717035",
"0.72717035",
"0.72717035",
"... | 0.0 | -1 |
unsafe to use, will download all models; | def _create_model_out_dictkeys():
model_names = []
result_keys = []
for model_name in model_zoo._ModelZooUrls.CONFIG_PATH_TO_URL_SUFFIX.keys():
try:
print(model_name, ":")
select_model(model_name)
result = get_features_by_image_path("./sample.jpg")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_all_models() -> None:\n model_keys = ModelInfo.get_all_models()\n for model_key in model_keys:\n download_model(model_key)",
"def download_models_and_data():\n\n for file in DATA_FILES:\n download_file(file[\"url\"], file[\"path\"])",
"def _retrieve_models(local=True):\n ... | [
"0.8000574",
"0.7724834",
"0.74329823",
"0.71786356",
"0.6747603",
"0.6745747",
"0.6659048",
"0.641336",
"0.63715756",
"0.6277509",
"0.6269505",
"0.626529",
"0.61694473",
"0.6133393",
"0.6132167",
"0.6128733",
"0.612146",
"0.6082238",
"0.6054536",
"0.6049674",
"0.60273546",
... | 0.0 | -1 |
Generates AppStream metadata of a specific kind | def _generate_metadata_kind(filename, targets=None, qa_group=None):
db = LvfsDatabase(os.environ)
db_firmware = LvfsDatabaseFirmware(db)
items = db_firmware.get_items()
store = appstream.Store('lvfs')
for item in items:
# filter
if item.target == 'private':
continue
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _generate_metadata_kind(filename, items, affidavit=None):\n store = appstream.Store('lvfs')\n for item in items:\n\n # add each component\n for md in item.mds:\n component = appstream.Component()\n component.id = md.cid\n component.kind = 'firmware'\n ... | [
"0.671694",
"0.60573244",
"0.57544136",
"0.5661377",
"0.56448686",
"0.5619563",
"0.5588338",
"0.55070674",
"0.5504906",
"0.5472223",
"0.5432367",
"0.54051733",
"0.5370304",
"0.53210187",
"0.53012925",
"0.5292331",
"0.5278983",
"0.52679557",
"0.5261438",
"0.52601606",
"0.52423... | 0.607395 | 1 |
updates metadata for a specific qa_group | def metadata_update_qa_group(qa_group):
# explicit
if qa_group:
filename = 'firmware-%s.xml.gz' % _qa_hash(qa_group)
_generate_metadata_kind(filename, qa_group=qa_group)
return [os.path.join(DOWNLOAD_DIR, filename)]
# do for all
db = LvfsDatabase(os.environ)
db_firmware = L... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _metadata_update_group(group_id):\n\n # get all firmwares in this group\n firmwares = db.firmware.get_all()\n firmwares_filtered = []\n for f in firmwares:\n if f.target == 'private':\n continue\n if f.group_id != group_id:\n continue\n firmwares_filtered.... | [
"0.62396324",
"0.5877734",
"0.576575",
"0.57327974",
"0.57194453",
"0.56374407",
"0.56304944",
"0.54979336",
"0.5483407",
"0.5479937",
"0.54672974",
"0.5455434",
"0.54246724",
"0.54197586",
"0.54063433",
"0.5388485",
"0.5379117",
"0.5371604",
"0.5357497",
"0.5346416",
"0.5345... | 0.647164 | 0 |
updates metadata for a specific target | def metadata_update_targets(targets):
filenames = []
for target in targets:
if target == 'stable':
filename = _generate_metadata_kind('firmware.xml.gz', targets=['stable'])
filenames.append(filename)
elif target == 'testing':
filename = _generate_metadata_kind... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _metadata_update_targets(targets):\n affidavit = _create_affidavit()\n firmwares = db.firmware.get_all()\n for target in targets:\n firmwares_filtered = []\n for f in firmwares:\n if f.target == 'private':\n continue\n if f.target != target:\n ... | [
"0.704391",
"0.6856124",
"0.680079",
"0.6698067",
"0.6497665",
"0.643017",
"0.6337812",
"0.6309755",
"0.61284596",
"0.61040866",
"0.6089916",
"0.60253173",
"0.5976579",
"0.5934039",
"0.59204215",
"0.59136456",
"0.5907409",
"0.58857447",
"0.5860491",
"0.5860491",
"0.58534926",... | 0.56407994 | 40 |
Writes the input out to a local file | def process(self, tup):
input = tup.values[0]
url = input['url']
now = datetime.datetime.now()
if url in self.seen:
lastSeen = self.seen[url]
delta = now - lastSeen
if delta.total_seconds() < 3600:
# seen less than an hour ago, don't... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _write_output_file(output: str, file_name: str):\n\tfile1 = open(file_name, 'w')\n\tfile1.write(output)\n\tfile1.close()",
"def __export_file(self, filename, output):\n outfile = open(filename, \"w\")\n outfile.write(output)\n outfile.close\n print(\"Output written to file: \" + f... | [
"0.7053892",
"0.67866904",
"0.668285",
"0.66073346",
"0.6562557",
"0.6537651",
"0.6532199",
"0.6498945",
"0.64802593",
"0.6445508",
"0.6445508",
"0.64421177",
"0.64155847",
"0.63887167",
"0.62964857",
"0.6274529",
"0.6260469",
"0.6249611",
"0.6246505",
"0.616572",
"0.6132764"... | 0.0 | -1 |
Test KS test for insertion indices with a specified mode | def test_ks_test(mode):
indices = np.random.randint(0, 1000, 1000)
out = compute_indices_ks_test(indices, 1000, mode=mode)
assert all([o > 0.0 for o in out]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_ks_test_undefined_mode():\n indices = np.random.randint(0, 1000, 1000)\n with pytest.raises(RuntimeError):\n compute_indices_ks_test(indices, 1000, mode=\"two-sided\")",
"def test_ks_test_empty_indices():\n out = compute_indices_ks_test([], 1000, mode=\"D+\")\n assert all(o is None fo... | [
"0.67841566",
"0.57195204",
"0.5679095",
"0.5437452",
"0.53641367",
"0.53341633",
"0.5320182",
"0.5270428",
"0.5263456",
"0.52053756",
"0.51995933",
"0.5183746",
"0.51783615",
"0.51379323",
"0.51002336",
"0.5085314",
"0.5072776",
"0.50716794",
"0.50716245",
"0.50713897",
"0.5... | 0.7882716 | 0 |
Test KS test for insertion indices with undefined mode | def test_ks_test_undefined_mode():
indices = np.random.randint(0, 1000, 1000)
with pytest.raises(RuntimeError):
compute_indices_ks_test(indices, 1000, mode="two-sided") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_ks_test(mode):\n indices = np.random.randint(0, 1000, 1000)\n out = compute_indices_ks_test(indices, 1000, mode=mode)\n assert all([o > 0.0 for o in out])",
"def test_ks_test_empty_indices():\n out = compute_indices_ks_test([], 1000, mode=\"D+\")\n assert all(o is None for o in out)",
"... | [
"0.8165338",
"0.746027",
"0.6211018",
"0.61494595",
"0.5980731",
"0.58581066",
"0.58403915",
"0.58055747",
"0.5776113",
"0.57654226",
"0.5763633",
"0.57397044",
"0.5628826",
"0.55964756",
"0.55854005",
"0.55454636",
"0.5536922",
"0.5515122",
"0.5509714",
"0.5504265",
"0.54790... | 0.7853589 | 1 |
Test KS test for insertion indices with empty input array | def test_ks_test_empty_indices():
out = compute_indices_ks_test([], 1000, mode="D+")
assert all(o is None for o in out) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_ks_test(mode):\n indices = np.random.randint(0, 1000, 1000)\n out = compute_indices_ks_test(indices, 1000, mode=mode)\n assert all([o > 0.0 for o in out])",
"def test_ks_test_undefined_mode():\n indices = np.random.randint(0, 1000, 1000)\n with pytest.raises(RuntimeError):\n comput... | [
"0.70587337",
"0.65909284",
"0.6385907",
"0.5999898",
"0.5820923",
"0.5819541",
"0.57032824",
"0.56986374",
"0.5642348",
"0.5551414",
"0.55201554",
"0.54983246",
"0.5488126",
"0.5454441",
"0.54420024",
"0.54296124",
"0.5424802",
"0.54022473",
"0.53976005",
"0.5383299",
"0.536... | 0.8038088 | 0 |
Test the Bonferroni correction for pvalues | def test_bonferroni_correction():
p_values = np.linspace(0, 0.5, 4)
rejected, corrected, alpha = bonferroni_correction(p_values)
np.testing.assert_array_equal(corrected, np.array([0, 2 / 3, 1, 1]))
assert rejected.tolist() == [True, False, False, False]
assert alpha == 0.0125 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bonferroni_correction(self):\r\n pvals = array([.1, .7, .5, .3, .9])\r\n exp = pvals * 5.\r\n obs = bonferroni_correction(pvals)\r\n self.assertFloatEqual(obs, exp)",
"def bonferroni_correction(pvals):\r\n return (\r\n array(pvals, dtype=float) * len(pvals) # float... | [
"0.83021456",
"0.71167046",
"0.6553124",
"0.6406347",
"0.6259637",
"0.6220493",
"0.60953826",
"0.602094",
"0.5866166",
"0.5811663",
"0.58097947",
"0.5803982",
"0.5756479",
"0.5751217",
"0.57412875",
"0.5739286",
"0.5718708",
"0.5704229",
"0.5698823",
"0.56808656",
"0.5674409"... | 0.80394477 | 1 |
Convert ID sequences into mask matrices | def idseqs_to_mask(idseqs: List[List[int]],
n_seqlen: Optional[int] = None,
n_vocab_sz: Optional[int] = None,
ignore: Optional[List[int]] = [],
dtype: Optional[torch.dtype] = torch.bool,
dense: Optional[bool] = False
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_attention_mask(input_ids): \n attention_masks = [] \n\n # 1 for input and 0 for pad\n for seq in input_ids: \n attention_masks.append([float(i>0) for i in seq])\n\n return attention_masks",
"def mask_id(self):\n m = 2 * self.mask_full()\n m[0:self.size, 0:self.size] = s... | [
"0.68125015",
"0.6421516",
"0.59341574",
"0.59032476",
"0.583509",
"0.5829133",
"0.5744523",
"0.5729663",
"0.5697411",
"0.56960577",
"0.5669003",
"0.5659483",
"0.56362015",
"0.5635536",
"0.5617417",
"0.5606554",
"0.5605875",
"0.5604915",
"0.5577015",
"0.5563572",
"0.55454534"... | 0.6793221 | 1 |
Finds the solution of the cubic equation involved in the computation of the proximity operator of the | def forward(ctx,gamma_mu,xtilde,mode_training=True):
# Device CPU/GPU
# if device == "cuda":
# dtype = torch.cuda.FloatTensor
# else :
dtype = torch.FloatTensor
#initialize variables
n,_,nx = xtilde.size()
x1,x2,x3 = torch.zeros(n,1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve(n=5000,C=-6*10**11,a=900,b=3):\n coeffs = np.zeros(n+2)\n coeffs[0] = a-b*n\n coeffs[1] = b*(n+1) - a\n coeffs[-3] = -C\n coeffs[-2] = 2*C - a\n coeffs[-1] = a+b-C\n mp.dps = 27\n roots = polyroots(coeffs)\n for root in roots:\n print root",
"def exactsolution(x, t, u):\n if 0 <= (x - u*t) and (x -... | [
"0.6496338",
"0.64271337",
"0.630471",
"0.6250335",
"0.6233523",
"0.62026256",
"0.61261874",
"0.60835856",
"0.6069071",
"0.60502964",
"0.6049461",
"0.60204566",
"0.59923995",
"0.59734356",
"0.5964771",
"0.595493",
"0.5916189",
"0.59153",
"0.59113973",
"0.59004",
"0.58809906",... | 0.0 | -1 |
Computes the first derivatives of the proximity operator of the log barrier with respect to x and gamma_mu. This method is automatically called by the backward method of the loss function. | def backward(ctx, grad_output_var):
xmin = 0
xmax = 1
grad_output = grad_output_var.data
gamma_mu,kappa,uTx,x = ctx.saved_tensors
n = kappa.size()[0]
nx = grad_output.size()[2]
u ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _forward_log_det_jacobian(self, x):\n d = self._compute_shared(x=x)\n relx = (x - d.x_k) / d.w_k\n relx = relx # tf.where(d.out_of_bounds, 0.5*tf.ones_like(x), relx)\n grad = (\n 2 * tf.math.log(d.s_k) +\n tf.math.log(d.d_kp1 * relx**2 + 2 * d.s_k * relx * (1 - relx) + # newln\n ... | [
"0.6992019",
"0.66589755",
"0.6592865",
"0.65579003",
"0.6555126",
"0.64870846",
"0.6481399",
"0.6379075",
"0.6354919",
"0.6340459",
"0.6330749",
"0.6322805",
"0.6269888",
"0.6226955",
"0.61627597",
"0.613101",
"0.61285204",
"0.6118351",
"0.6108239",
"0.61030525",
"0.6101484"... | 0.0 | -1 |
Accepts a size and text of a message to print on a shirt. | def make_shirt(size, text):
print(f"\nThe size of the shirt is {size} and the printed text reads: {text}.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_shirt(size, message):\n print(\"I need a shirt, size \" + size + \", that says \" + message + \".\")",
"def make_shirt(size, text):\n print('You wanted the t-shirt to be in size: ' + size)\n print('The message you wanted on the t-shirt: ' + text)",
"def make_shirt(size, message):\n print(\... | [
"0.7987473",
"0.7964641",
"0.7890728",
"0.7831767",
"0.7787454",
"0.7787454",
"0.7602366",
"0.7577227",
"0.75480956",
"0.7529585",
"0.73977256",
"0.7383219",
"0.7383219",
"0.7379657",
"0.73002464",
"0.71007955",
"0.6245159",
"0.61845994",
"0.5964087",
"0.59391963",
"0.5886760... | 0.76433444 | 6 |
Accepts a size and text of a message to print on a shirt. Defaults to size large. | def make_shirt(text='I love Python', size='large'):
print(f"\nThe size of the shirt is {size} and the printed text reads: {text}.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_shirt(size, message):\n print(\"I need a shirt, size \" + size + \", that says \" + message + \".\")",
"def make_shirt(message=\"I love Python\", size=\"L\"):\n print(\"A \" + size + \" t-shirt with the following message: \" + message)",
"def make_shirt(size, message):\n print(\"My t-shirt is... | [
"0.7936069",
"0.79013073",
"0.78979605",
"0.773878",
"0.7711005",
"0.7711005",
"0.761596",
"0.75709385",
"0.7525627",
"0.74698335",
"0.74698335",
"0.746105",
"0.7382213",
"0.7262654",
"0.7155463",
"0.70711285",
"0.6359491",
"0.6280973",
"0.6197354",
"0.6151389",
"0.6046193",
... | 0.72824085 | 13 |
Accepts a city and a country and prints a simple sentence with those values. | def describe_city(city, country='New Zealand'):
print(f"\nThe city of {city} is in {country}.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def city_country(city, country):\n print(f'\"{city.title()}, {country.title()}\"\\n')",
"def describe_city(city, country='canada'):\n print(f\"{city.title()} is in {country.title()}.\")",
"def describe_city(city, country='Germany'):\n\tprint(f'{city.title()} is in {country.title()}.')",
"def describe_c... | [
"0.856302",
"0.81208575",
"0.8088181",
"0.8051179",
"0.79706645",
"0.79012996",
"0.78986406",
"0.7809852",
"0.77355325",
"0.7704453",
"0.7686551",
"0.7686551",
"0.7685671",
"0.7684176",
"0.7679467",
"0.7600646",
"0.74408424",
"0.7436566",
"0.7406232",
"0.737946",
"0.73696256"... | 0.81209445 | 1 |
Scaled Exponential Linear Unit. (Klambauer et al., 2017) Arguments | def selu(x):
alpha = 1.6732632423543772848170429916717
scale = 1.0507009873554804934193349852946
return scale * elu(x, alpha) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setExponent(self, *args):\n return _libsbml.Unit_setExponent(self, *args)",
"def scale(inp, ab):\n\n return inp * ab[0] + ab[1]\n # pass",
"def scale(inp, ab):\n\n return inp * ab[0] + ab[1]",
"def scale(self):",
"def calculate_exponent():\n pass",
"def xscale(value):\n impl.xsc... | [
"0.62797046",
"0.61946106",
"0.61704326",
"0.61148554",
"0.59997374",
"0.5996937",
"0.5957179",
"0.5904153",
"0.5895206",
"0.58881485",
"0.5836805",
"0.57540625",
"0.57374054",
"0.5706502",
"0.5674149",
"0.5617635",
"0.5616218",
"0.5604117",
"0.5592343",
"0.55895114",
"0.5565... | 0.5287071 | 54 |
Constructor for the NasBackupParams class | def __init__(self,
backup_all_existing_snapshot=None,
blacklisted_ip_addrs=None,
continue_on_error=None,
encryption_enabled=None,
filtering_policy=None,
fld_config=None,
full_backup_snapshot_label=None... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(__self__, *,\n include_cluster_scope_resources: pulumi.Input[bool],\n object_type: pulumi.Input[str],\n snapshot_volumes: pulumi.Input[bool],\n excluded_namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n ... | [
"0.64447784",
"0.6168862",
"0.61534363",
"0.6098209",
"0.6049831",
"0.5995434",
"0.5983703",
"0.5983703",
"0.5976207",
"0.597005",
"0.59328234",
"0.5924585",
"0.59173024",
"0.5862991",
"0.58594143",
"0.58371496",
"0.58366156",
"0.58322644",
"0.5827591",
"0.58213955",
"0.58141... | 0.6467344 | 0 |
Creates an instance of this model from a dictionary | def from_dictionary(cls,
dictionary):
if dictionary is None:
return None
# Extract variables from the dictionary
backup_all_existing_snapshot = dictionary.get('backupAllExistingSnapshot')
blacklisted_ip_addrs = dictionary.get("blacklistedIpAddrs")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n id = dictionary.get('id')\n name = dictionary.get('name')\n mtype = dictionary.get('type')\n usage_bytes = diction... | [
"0.83185387",
"0.81679726",
"0.81679726",
"0.81194353",
"0.80894536",
"0.79789025",
"0.7949881",
"0.7922983",
"0.7898846",
"0.7892914",
"0.7888425",
"0.7882915",
"0.7882119",
"0.78765213",
"0.7858605",
"0.78363335",
"0.78024834",
"0.78024834",
"0.78024834",
"0.78024834",
"0.7... | 0.0 | -1 |
Catch Ctrl+C signal to termiante workers | def init_worker():
signal.signal(signal.SIGINT, signal.SIG_IGN) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def allowCtrlC():\n signal.signal(signal.SIGINT, signal.SIG_DFL)",
"def signal_handler(*unused_argvs):\n sys.stderr.write(\"\\nCtrl^C caught, bailing...\\n\")\n sys.exit(0)",
"def worker_initializer():\n signal.signal(signal.SIGINT, signal.SIG_IGN)",
"def _init_worker():\n signal.signal(signal.SIG... | [
"0.7222166",
"0.72151893",
"0.7180323",
"0.71768016",
"0.6984043",
"0.6946091",
"0.69356275",
"0.6917393",
"0.6899606",
"0.6881529",
"0.6845854",
"0.6804447",
"0.67696905",
"0.6766118",
"0.67553",
"0.67504436",
"0.66279745",
"0.65575314",
"0.6528643",
"0.64279413",
"0.6398735... | 0.72294533 | 0 |
Wrapper used to pass params to workers | def create_mask_wrapper(args, crop=None, scale=1, flip=False,
reflective=False, warm=False, reduce_red=False,
saturate=False):
input_filename, output_filename = args[0], args[1]
try:
img, mask = get_mask(input_filename, crop, scale, flip, reflective,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _worker(self, args):\n pass",
"def init_worker(*shared_args_list):\n global SHARED_ARGS\n SHARED_ARGS = shared_args_list",
"def job_as_parameter(f):\n f.job_as_parameter = True\n return f",
"def process_task(params):\n params['task'](params)",
"def set_params(self, params):",
"d... | [
"0.62962055",
"0.6150441",
"0.60870606",
"0.6063529",
"0.58948",
"0.5737697",
"0.57151204",
"0.5712164",
"0.56826967",
"0.56751645",
"0.5674729",
"0.5674717",
"0.5666531",
"0.5652284",
"0.56272703",
"0.56192535",
"0.5603987",
"0.559731",
"0.5591001",
"0.5564014",
"0.5558032",... | 0.0 | -1 |
This is the toplevel function for processing data. The function is meant to be passed to the importer (in this case GuiIO). The importer will call this function after it has parsed the raw data. | def processing_function(raw):
# Sort stewarded & unstewarded depts
STEWARDED_DEPTS = set(stewards.keys()) & kt.ALL_DEPTS
UNSTEWARDED_DEPTS = kt.ALL_DEPTS - STEWARDED_DEPTS
##############################
# Filter data in all the ways
##############################
actives = kt.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_data(self, data):\n if verbose(): print(\"TIParser.handle_data(self, '%s')\" % (data))\n pass",
"def processInputs(self):",
"def run(self, data):\n\t\t# no processing here\n\t\treturn data",
"def parse_data(self):\n\t\traise NotImplementedError('%s: No parse function implemented!' % ... | [
"0.6277665",
"0.6056177",
"0.59779894",
"0.59718275",
"0.5932694",
"0.59140706",
"0.58592844",
"0.5857117",
"0.5857117",
"0.5828108",
"0.58244014",
"0.5787937",
"0.5766094",
"0.5746301",
"0.5732957",
"0.571916",
"0.57150483",
"0.57103926",
"0.57093644",
"0.5667955",
"0.566795... | 0.0 | -1 |
Parse a readme file. | def read_readme(readme: str) -> Tuple[dict, list]:
metadata = {
"name": "na",
"provider": "na",
"original name": "na",
"original filename": "na",
"assembly_accession": "na",
"tax_id": "na",
"mask": "na",
"genome url": "na",
"annotation url": "n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_readme():\n # Get the long description from the relevant file\n readme_path = path.join(here, 'README.md')\n with codecs.open(readme_path, encoding='utf-8') as handle:\n desc = handle.read()\n\n return desc",
"def test_readme():\n readme = Path(README_PATH).read_text()\n Action... | [
"0.7862639",
"0.69449455",
"0.6925098",
"0.6874095",
"0.6678023",
"0.6647286",
"0.65171206",
"0.64888984",
"0.6395882",
"0.6373797",
"0.6318565",
"0.6261154",
"0.62290794",
"0.6200871",
"0.61734515",
"0.61639285",
"0.6114276",
"0.60170484",
"0.5915927",
"0.5900081",
"0.589507... | 0.66518 | 5 |
Create a new readme file with supplied information. | def write_readme(readme: str, metadata: dict, lines: list = None):
with open(readme, "w") as f:
for k, v in metadata.items():
print(f"{k}: {v}", file=f)
if lines:
for line in lines:
print(line, file=f) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_readme_txt(self, args):\n with open(self.readme_txt, 'w') as writer:\n log.info(\"args=%s\\n\", args)\n writer.write(\"# Created by pbtranscript-internal-validation.ValidationRunner.make_readme_txt()\\n\")\n writer.write(\"args=%s\\n\\n\" % args)\n\n file... | [
"0.7987224",
"0.782059",
"0.7738895",
"0.77343196",
"0.76951265",
"0.7692684",
"0.7475079",
"0.740073",
"0.7256037",
"0.70500207",
"0.6997206",
"0.69900995",
"0.68761015",
"0.68635523",
"0.68394893",
"0.6829391",
"0.6792584",
"0.6766892",
"0.6707527",
"0.6680079",
"0.66443956... | 0.6952783 | 12 |
Update a readme file with supplied information. | def update_readme(readme: str, updated_metadata: dict = None, extra_lines: list = None):
metadata, lines = read_readme(readme)
if updated_metadata:
metadata = {**metadata, **updated_metadata}
if extra_lines:
lines = lines + extra_lines
write_readme(readme, metadata, lines) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_readme():\n\n temp = \"\"\"<head>\n <title>Unittest Results</title>\n <meta charset=\"utf-8\">\n <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n <link rel=\"stylesheet\" href=\"https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css\" integrity=\... | [
"0.7689971",
"0.722182",
"0.70508206",
"0.6771436",
"0.6603375",
"0.65443844",
"0.6535205",
"0.6525045",
"0.6332471",
"0.6293604",
"0.62730294",
"0.6270745",
"0.6242984",
"0.6230076",
"0.6186949",
"0.6171401",
"0.61592084",
"0.61382926",
"0.60904527",
"0.6066599",
"0.6053936"... | 0.8195249 | 0 |
Context manager to work with (b)gzipped file. | def extracted_file(fname: str):
new_fname = extract_gzip(fname)
gzipped = True
if new_fname is None:
new_fname = fname
gzipped = False
try:
yield new_fname
finally:
if gzipped:
try:
bgzip_and_name(new_fname)
except Exception:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_gzip(fileobj):\r\n sio = cStringIO.StringIO()\r\n gzf = gzip.GzipFile(fileobj = sio, mode = \"wb\")\r\n while True:\r\n data = fileobj.read(buf_size)\r\n if not data:\r\n break\r\n gzf.write(data)\r\n gzf.close()\r\n return sio",
"def open_gz(filename, mode):... | [
"0.6809535",
"0.675466",
"0.661344",
"0.6587002",
"0.65678066",
"0.6511136",
"0.6488444",
"0.6413921",
"0.63567406",
"0.63266903",
"0.62170494",
"0.6216539",
"0.62095344",
"0.6157152",
"0.606511",
"0.60540587",
"0.6029327",
"0.60214204",
"0.59915817",
"0.59607774",
"0.5935949... | 0.66227496 | 2 |
Extract files from an archive. Archive may be a gzipped or bgzipped file (.gz), a zipped file (.zip) or a tarball (.tar.gz). Optionally, if multiple files are present they may be concatenated into one file. | def extract_archive(
fname: str, outfile: Optional[str] = None, concat: bool = False
) -> Union[str, None]:
if fname.endswith((".tgz", ".tar.gz")):
return extract_tarball(fname, outfile=outfile)
elif fname.endswith(".gz"):
return extract_gzip(fname, outfile=outfile)
elif fname.endswith(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract(apath, ffilter=[]):\n\n files = []\n\n def extract_recursive(curr_apath):\n \"\"\"Look into archive recursively to extract files considering ffilter\"\"\"\n\n handler = resolve_format(curr_apath)\n unpacker = HandlersFactory.get_handler(handler)\n _files = unpacker.fil... | [
"0.6960922",
"0.65000236",
"0.64723575",
"0.64007777",
"0.6359527",
"0.63576806",
"0.6291074",
"0.6273226",
"0.6227048",
"0.62031776",
"0.6190727",
"0.6112076",
"0.60922587",
"0.6081641",
"0.60304374",
"0.60125357",
"0.6003538",
"0.5969804",
"0.5898257",
"0.58356404",
"0.5832... | 0.62739277 | 7 |
Convert tar of multiple FASTAs to one file. | def extract_tarball(fname, outfile=None, concat=True) -> Union[str, None]:
fnames = []
# Extract files to temporary directory
tmp_dir = mkdtemp(dir=os.path.dirname(outfile))
with tarfile.open(fname) as tar:
tar.extractall(path=tmp_dir)
for root, _, files in os.walk(tmp_dir):
fnames +... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_tar(self):\n with tarfile.open(self.tgzfile, \"w:gz\") as tar_handle:\n for root, _, files in os.walk(self.dirname):\n for file in files:\n tar_handle.add(os.path.join(root, file))",
"def combine_fasta_files(fastas_paths, out_file):\n with open(ou... | [
"0.65684086",
"0.6300177",
"0.62254524",
"0.6161973",
"0.60660845",
"0.59409815",
"0.58384496",
"0.57276076",
"0.5682935",
"0.5628571",
"0.55928606",
"0.5521933",
"0.55169624",
"0.55039227",
"0.54637206",
"0.5451794",
"0.54454917",
"0.542897",
"0.53728896",
"0.53632414",
"0.5... | 0.5832278 | 7 |
Gunzips the file if gzipped. Also works on bgzipped files. | def extract_gzip(fname: str, outfile: Optional[str] = None) -> Union[str, None]:
if not outfile:
outfile = fname[:-3]
if fname.endswith(".gz"):
with gzip.open(fname, "rb") as f_in:
with open(outfile, "wb") as f_out:
shutil.copyfileobj(f_in, f_out)
os.unlink(f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gunzip_file(gzip_file, base_dir):\n full_gzip_file = os.path.join(base_dir, gzip_file)\n if not gzip_file.endswith(\".gz\"):\n return gzip_file\n gunzip_file = full_gzip_file.replace(\".gz\", \"\")\n with gzip.open(full_gzip_file, 'rb') as f_in:\n with open(gunzip_file, 'wb') as f_out... | [
"0.76103014",
"0.758293",
"0.7453833",
"0.74080575",
"0.73874843",
"0.73601073",
"0.7083313",
"0.6650277",
"0.6621982",
"0.66076165",
"0.6582111",
"0.65322065",
"0.6479576",
"0.64636713",
"0.64612234",
"0.64612234",
"0.6430386",
"0.6367628",
"0.6275241",
"0.6251574",
"0.62346... | 0.6552791 | 11 |
Unzips the file if zipped. | def extract_zip(
fname: str, outfile: Optional[str] = None, concat: bool = False
) -> Union[str, None]:
if not outfile:
outfile = fname[:-4]
with ZipFile(fname, "r") as fzip, TemporaryDirectory() as tmpdir:
fzip.extractall(path=tmpdir)
fnames = glob(f"{tmpdir}/*")
if len(fn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unzip(zip_path, output_file, data_folder):\n\n print('Unzipping file: {}'.format(zip_path))\n pyunpack.Archive(zip_path).extractall(data_folder)\n\n # Checks if unzip was successful\n if not os.path.exists(output_file):\n raise ValueError(\n 'Error in unzipping process! {} not found.'.format(outp... | [
"0.73103154",
"0.72895694",
"0.7225283",
"0.7122829",
"0.7118282",
"0.6995884",
"0.69455594",
"0.6819211",
"0.67483294",
"0.67109257",
"0.66977614",
"0.664706",
"0.66354054",
"0.6634382",
"0.6603002",
"0.65897787",
"0.6585848",
"0.6585062",
"0.6572348",
"0.65660316",
"0.65302... | 0.0 | -1 |
Gzip file if requested. | def gzip_and_name(fname, gzip_file=True) -> str:
if gzip_file:
with open(fname, "rb") as f_in:
with gzip.open(fname + ".gz", "wb") as f_out:
shutil.copyfileobj(f_in, f_out)
os.unlink(fname)
fname += ".gz"
return fname | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_file(self, path):\n\n if path:\n if not matches_patterns(path, self.gzip_patterns):\n return\n\n try:\n original_file = self.open(path, mode=\"rb\")\n except FileNotFoundError:\n pass\n else:\n ... | [
"0.7143728",
"0.6788087",
"0.654219",
"0.6520567",
"0.6455454",
"0.6441658",
"0.64261234",
"0.6391219",
"0.6348747",
"0.6328026",
"0.63114715",
"0.6300965",
"0.6233786",
"0.6195819",
"0.6182347",
"0.61750174",
"0.61693275",
"0.61632836",
"0.6142787",
"0.61406815",
"0.61263895... | 0.608778 | 23 |
Bgzip file if requested. | def bgzip_and_name(fname, bgzip_file=True) -> str:
if bgzip_file:
ret = sp.check_call(f"bgzip {fname}", shell=True)
fname += ".gz"
if ret != 0:
raise Exception(f"Error bgzipping genome {fname}. Is pysam installed?")
return fname | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compressIfNeeded(self):\n\n if self._mode == \"zip\":\n zip_folder(self._rootExportPath, self.getZipArchiveFullPath())",
"def zipFasta(self):\n utils.log(\"zipping {} ...\".format(self.fastaFileName))\n cmd = \"bgzip -f {}\".format(self.fastaFileName)\n utils.runCommand... | [
"0.64540195",
"0.61454713",
"0.61329705",
"0.6086035",
"0.5977188",
"0.5960336",
"0.58702797",
"0.5859002",
"0.58266616",
"0.57801116",
"0.5761597",
"0.575355",
"0.57480204",
"0.5744919",
"0.573051",
"0.5717974",
"0.56552184",
"0.5648838",
"0.5563235",
"0.5556836",
"0.555637"... | 0.6738823 | 0 |
Return a function to open a (gzipped) file. | def _open(fname: str, mode: Optional[str] = "r"):
if mode not in ["r", "w"]:
raise ValueError("mode must be either 'r' or 'w'.")
if fname.endswith(".gz"):
return gzip.open(fname, mode + "t")
return open(fname, mode) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_gz(filename, mode):\n return gzip.open(filename, mode)",
"def open_gzip(fn):\n magic = b'\\x1f\\x8b\\x08'\n l = len(magic)\n with open(fn, 'rb') as f:\n file_start = f.read(l)\n f.seek(0)\n # check if the file is compressed\n if file_start.startswith(magic):\n retu... | [
"0.82734615",
"0.8186003",
"0.8017077",
"0.78277725",
"0.7727428",
"0.7643111",
"0.73564893",
"0.73564893",
"0.732356",
"0.7103141",
"0.70543605",
"0.70016134",
"0.6944863",
"0.6920207",
"0.6873506",
"0.66928023",
"0.66770685",
"0.6631664",
"0.6631664",
"0.6600424",
"0.658002... | 0.677487 | 15 |
Returns the lower case file type of a file, and if it is (g)zipped | def get_file_info(fname) -> Tuple[str, bool]:
fname = fname.lower()
is_compressed = False
if fname.endswith((".tgz", ".tar.gz")):
is_compressed = True
fname = re.sub(r"\.(tgz|tar\.gz)$", "", fname)
elif fname.endswith(".gz"):
is_compressed = True
fname = fname[:-3]
el... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_file_type(cls, filename):\n with open(filename) as f:\n file_header = f.read(cls.MAX_FILE_HEADER_LEN)\n for magic, filetype in cls.MAGIC_DICT.items():\n if file_header.startswith(magic):\n return filetype\n return \"uncompressed\"",
"def is_zip(fi... | [
"0.75641257",
"0.739077",
"0.7374025",
"0.7309392",
"0.69896644",
"0.6765388",
"0.6685862",
"0.6668622",
"0.66228014",
"0.6619521",
"0.6540485",
"0.6445927",
"0.64198005",
"0.641593",
"0.6397573",
"0.6389309",
"0.63834107",
"0.63234156",
"0.6313959",
"0.6312306",
"0.63119596"... | 0.69038486 | 5 |
Return (gzipped) file names in directory containing the given extension. | def glob_ext_files(dirname, ext="fa") -> list:
fnames = glob(os.path.join(dirname, f"*.{ext}*"))
return [f for f in fnames if f.endswith((ext, f"{ext}.gz"))] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_file_names(path, extension='.json'):\n fn = os.listdir(path)\n l = []\n for f in fn:\n if f.endswith(extension, 4):\n l.append(f)\n l = sorted(l)\n return l",
"def list_all_files_with_extension(path, extension, do_unzip=True):\n files = []\n for file in os.listdir(p... | [
"0.7269909",
"0.71443665",
"0.71007",
"0.6931686",
"0.68851805",
"0.68763983",
"0.6823714",
"0.67866296",
"0.67852724",
"0.6752004",
"0.6724506",
"0.6646473",
"0.6645157",
"0.66420186",
"0.6624232",
"0.6605461",
"0.65348715",
"0.65346175",
"0.6510529",
"0.64909226",
"0.648030... | 0.77469283 | 0 |
filter a Fasta using the regex function. | def _apply_fasta_regex_func(infa, regex_func, outfa=None):
# move the original file to a tmp folder
out_dir = os.path.dirname(infa)
tmp_dir = mkdtemp(dir=out_dir)
old_fname = os.path.join(tmp_dir, "original") if outfa is None else infa
new_fname = os.path.join(tmp_dir, "filtered")
shutil.move(in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_fasta(\n infa: str,\n outfa: str = None,\n regex: str = \".*\",\n invert_match: Optional[bool] = False,\n) -> list:\n pattern = re.compile(regex)\n\n def keep(header):\n return bool(pattern.search(header)) is not invert_match\n\n return _apply_fasta_regex_func(infa, keep, out... | [
"0.65963423",
"0.6402181",
"0.6011408",
"0.600255",
"0.5881439",
"0.57979774",
"0.5762943",
"0.5755297",
"0.57551485",
"0.57547766",
"0.57397467",
"0.5717947",
"0.5692144",
"0.5634937",
"0.560354",
"0.5600734",
"0.5595965",
"0.5553075",
"0.55393845",
"0.5537095",
"0.55356854"... | 0.676315 | 0 |
Filter fasta file based on regex. | def filter_fasta(
infa: str,
outfa: str = None,
regex: str = ".*",
invert_match: Optional[bool] = False,
) -> list:
pattern = re.compile(regex)
def keep(header):
return bool(pattern.search(header)) is not invert_match
return _apply_fasta_regex_func(infa, keep, outfa) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _apply_fasta_regex_func(infa, regex_func, outfa=None):\n # move the original file to a tmp folder\n out_dir = os.path.dirname(infa)\n tmp_dir = mkdtemp(dir=out_dir)\n old_fname = os.path.join(tmp_dir, \"original\") if outfa is None else infa\n new_fname = os.path.join(tmp_dir, \"filtered\")\n ... | [
"0.69491684",
"0.6156863",
"0.60775024",
"0.59450454",
"0.5645844",
"0.55811054",
"0.5563482",
"0.5525892",
"0.5522686",
"0.5514822",
"0.55063164",
"0.5468016",
"0.5430675",
"0.5412103",
"0.5391324",
"0.5378578",
"0.53772795",
"0.53680974",
"0.5331787",
"0.5308409",
"0.530364... | 0.6979984 | 0 |
Detects faces in images, returns a list with images that contain faces and saves these face images in the FacePhoto directory. | def detectFaces_allFiles(directory):
files_list = glob.glob(directory)
for file in files_list:
print(file)
img = cv2.imread(file)
if img is not None:
height, width, channel = img.shape
faces = face_cascade.detectMultiScale(img, 1.3, 5)
age = find_age(f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_face_detections(self):\n self.detector.setInput(self.image_blob)\n self.detections = self.detector.forward()",
"def detect_faces(image):\n\n face_locations = face_recognition.face_locations(image)\n return face_locations",
"def get_check_folder():\r\n filelist = [file for fil... | [
"0.7326142",
"0.72739726",
"0.72709846",
"0.72338194",
"0.7221177",
"0.7106792",
"0.7075032",
"0.6982013",
"0.69769347",
"0.6973032",
"0.69372755",
"0.6921899",
"0.68639034",
"0.67961735",
"0.6771518",
"0.67294437",
"0.6728292",
"0.66689503",
"0.66174954",
"0.661695",
"0.6610... | 0.72242236 | 4 |
Finds the age of the person on the photo, based on the filename | def find_age(str):
regex = r"_([0-9]+).+_([0-9]+)"
matches = re.search(regex, str)
if matches:
birth = matches.group(1)
picture = matches.group(2)
age = int(picture) - int(birth)
return age | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_file_age(self, filepath):\n try:\n fileage = os.path.getmtime(filepath)\n return fileage\n except:\n return 0",
"def file_info(self, f):\n ld8 = self.ld8_extract(f) # get luna_date\n sid = self.sesid(ld8) # make luna_visitnum\n age =... | [
"0.6539053",
"0.63929635",
"0.6130632",
"0.6126099",
"0.60076624",
"0.59946716",
"0.5988924",
"0.5957687",
"0.5947357",
"0.5931525",
"0.5921615",
"0.5881921",
"0.5782887",
"0.57811505",
"0.5766714",
"0.5723021",
"0.57115793",
"0.5673089",
"0.5648261",
"0.56320405",
"0.5610792... | 0.68865573 | 0 |
Finds the filename in a path. | def extract_filename(str):
regex = r"([0-9_-]+).jpg"
matches = re.search(regex, str)
if matches:
return matches.group(1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search_file(filename, search_path, pathsep=os.pathsep):\n for path in string.split(search_path, pathsep):\n candidate = os.path.join(path, filename)\n if os.path.exists(candidate): return os.path.abspath(candidate)\n return None",
"def search_file(filename, search_path, pathsep=os.pathsep... | [
"0.77612054",
"0.77612054",
"0.7716344",
"0.750982",
"0.74376416",
"0.74000573",
"0.7346764",
"0.7340276",
"0.72320473",
"0.7171325",
"0.71397066",
"0.7084991",
"0.7063053",
"0.6908678",
"0.6906146",
"0.6898922",
"0.6848443",
"0.6828708",
"0.68076605",
"0.67631036",
"0.674357... | 0.0 | -1 |
Creates an array of images | def create_image_array(files_list):
im_array = np.array([np.array(cv2.imread(file)) for file in files_list])
return im_array | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makearray(self, *args, **kwargs):\n return _image.image_makearray(self, *args, **kwargs)",
"def gen_image(self, nimage):\n tmp = [0] * nimage\n for i in np.arange(nimage):\n tmp[i] = self.gen_one_image()\n \n return np.array(tmp)",
"def generate_images(\n n:... | [
"0.727521",
"0.7118611",
"0.7073577",
"0.70057833",
"0.69419736",
"0.689666",
"0.68892497",
"0.68005633",
"0.6778553",
"0.67391485",
"0.67278343",
"0.67162925",
"0.6715371",
"0.66987485",
"0.6670579",
"0.6658773",
"0.6611052",
"0.6609227",
"0.65959245",
"0.6590915",
"0.654894... | 0.7637464 | 0 |
Creates an array of labels | def create_label_array(files_list):
lab_array = np.array([np.array(turn_age_into_vector(find_age(file))) for file in files_list])
return lab_array | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def labels_array(self):\n return _build_label_vector_rows(\n [[(label, 1)] for label in self.labels], self.training_labels)[1:].T",
"def generate_labels(n_samples):\n return np.ones([n_samples, 1]), np.zeros([n_samples, 1])",
"def create_label_array(el):\n num_digits = len(el) # first ... | [
"0.8269726",
"0.76015544",
"0.7565441",
"0.7565441",
"0.7460371",
"0.73777056",
"0.73232925",
"0.7319245",
"0.72369486",
"0.7219482",
"0.7186704",
"0.716197",
"0.71618766",
"0.71541744",
"0.7145023",
"0.7082937",
"0.70737344",
"0.70646393",
"0.70617527",
"0.70523167",
"0.7051... | 0.74500805 | 5 |
Saves an array under the name 'filename' | def save_array(array, filename):
np.save(filename, array) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def quick_save_array(data, file_name, delimiter=',', ):\n data.tofile(file_name, sep=delimiter)",
"def write_csv_file(array, filename):\n\tnp.savetxt(filename, array, delimiter=\",\")",
"def save_array(self, name: str, array: np.ndarray):\r\n np.savetxt(self._path_for_csv(name), array, delimiter=\",\... | [
"0.75969416",
"0.7330002",
"0.7201176",
"0.71752346",
"0.7159063",
"0.7140122",
"0.71392435",
"0.7069632",
"0.6940411",
"0.6934702",
"0.69181776",
"0.68739957",
"0.6849441",
"0.68114215",
"0.67789257",
"0.67586243",
"0.67484975",
"0.67466575",
"0.6678462",
"0.66758204",
"0.66... | 0.8585977 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.